Information systems must be able to quickly adapt to changing requirements. In software development, changing the requirements often entails a repetition of development tasks such as implementation or testing. To accelerate such tasks, model-driven development (MDD) ofers users to express their requirements as domain models and to automatically generate code from these models. Most MDD approaches, however, require users to learn new tools and languages. Thus, MDD has found little adoption beyond a few niches and most code is still written by hand, which is slow, costly, and error prone. In this paper, we propose an approach to using existing business artifacts as reusable models in software development. These models can be either transformed into executable code, or they can be used as functional modules using an interpreter. This approach allows product owners to update requirements and build information systems by having the behavior and logic of existing business artifacts immediately reflected in the software, which drastically increases business agility. We validate our approach with a proof of concept for automatically transforming existing business logic and domain data encoded in an Excel document into a web service and generating a web-based user interface for it.
Businesses must be agile to cope with changes in their environment. This is especially true in
the context of digitalization, which often accelerates both the frequency and the amplitude of
change [
Model-driven development (MDD [
The key to success of the niches above is considered to be that they use domain-specific
languages [
We propose an approach to using existing business artifacts as models in an MDSE process.
This allows domain experts to apply changes to the requirements directly to their business
artifacts and automatically generate a new release of the software. Through such automatic
integration of artifacts from a domain-specific language (e.g., spreadsheets in Excel or illustrations
in Visio) into the software development life cycle, companies can rapidly develop applications
and thus, react to changing business requirements in an agile way. In this paper, we address
the research question: Can business artifacts such as spreadsheets be used to automatically
generate software prototypes?
1.1. Related Work
Ofice documents such as Excel spreadsheets can be considered domain-specific languages [
Although ofice documents are widely used in many domains and even have inspired some
approaches to automating the software development life cycle such as low-code platforms [
Excel documents have been used in an approach to automatically generating web pages [
Several others have started to see the value of making the data and calculations in spreadsheets
available through an API. As an example, Microsoft Graph [
In this section, we present an example application from the domain of electrical substations, which are nodes in electrical grids. They are composed of many diferent types of electrical assets, e.g., circuit breakers or transformers. Substation owners must ensure their optimal operation at all times. This can be achieved with a balanced mix of maintenance, replacement of aging assets, and availability of spare parts. A key element in this optimization problem is the storage of “enough” spare parts.
At Hitachi Energy we have extended an existing algorithm for the calculation of the optimal amount of spare parts to be kept in storage, which will ensure the best balance between cost of spares and risk of power interruptions. We have built a proof-of-concept model for this algorithm using Microsoft Excel. Two steps must be taken to further transform this proof of concept into a prototype: first, validation with product managers, and second, scale-up to represent a real-world problem.
The challenge with the first step is that complex Excel models can be hard to understand by anyone else than their creator. Thus, we seek a method to quickly convert such models into a tool that can be handled, tried, and validated by others. We want to hide the intricacies of the models and highlight the input/outputs in a UI wrapper, without the efort and the know-how for such development.
The challenge with the second step is that an excel model can handle a handful of variables, but it becomes impractical or impossible to use when the number of variables increases to represent a real scale problem, e.g., with hundreds or thousands of spare parts. In this study we focus on the first challenge, but a natural continuation will be to explore how to automatically extract the logic of the algorithm and implement it into a software, so that it can be scaled up at wish. Figure 1 shows several of the input parameters to the optimization algorithm in Excel.
We propose the model-view-controller (MVC) design pattern [
We use a model interpretation approach [
In this section, we show our proof-of-concept implementation in Python to demonstrate how we have used the MVC pattern to automatically generate a web application from an Excel document.
The Model The model is the Excel document that contains both business logic and (often) domain data. Instead of generating code from the model (which is the most common approach in MDD), we follow the model interpretation (or models at runtime) approach: the Excel document remains unchanged, and we add a wrapper around it to enable programmatic access.
This ofers several advantages with respect to business agility. First, changes to the model
are immediately reflected in the application because no code needs to be generated. Second, the
application does not have to be stopped when the business logic is updated, which allows for
dynamic software updates [
For our proof-of-concept implementation, we have developed a wrapper that provides a REST API to change cells, trigger calculations, and read cells of an Excel document. This REST API allows the view and the controller to interact with the Excel sheet. To this end, we use the Python package formulas1 to update data in Excel sheets and trigger the calculation of formulas in the sheets and the package flask2 to build a web API for the Excel document.
This results in a microservice, which can be immediately integrated into existing web applications or serve as the foundation of new applications. As an example, the API call curl -H "Content-Type: application/json" -d ’{"ExcelFileName": "simple.xlsx", "a":"5"}’ -X POST http://localhost:5000/ExcelCalculator updates the input cell named “a” in the Excel sheet “simple.xlsx” to the value 5. Then, the calculations in that sheet are triggered and the results of the calculations are returned in the JSON output { "result": [ 6.0, "text"] }.
Besides updating values in the Excel document and recalculating the formulas contained therein, our web service provides an API to add rows to the tables in the document. This enables users to add additional data to the document at runtime and calculate functions that operate on a set of values (such as sum or average).
The View The view is realized through a web page, which is automatically generated from
the data in the model. In our implementation, we use the well-established stack of HTML,
CSS, and JavaScript for the front-end of the view and Python (again, the flask package) for its
backend. Our approach provides a URL /webform/<filename>, which automatically renders a
flask HTML template. An example view that was automatically generated is shown in Figure 2.
In this figure, the relation to the elements in the Excel document (cf. Figure 1) are obvious:
parameters of the spare parts optimization algorithm such as the planning strategy and the
planning horizon have become input elements on the web page. The results of the optimization
1https://pypi.org/project/formulas/
2https://flask.palletsprojects.com/en/2.0.x/
algorithm become outputs on the web page as simple text fields or graphical widgets. In our
implementation, we use gauges and column charts from Google Charts [
The answer to our research question “Can business artifacts such as spreadsheets be used to automatically generate software prototypes?” is a clear yes: we have presented an approach to rapid software prototyping by using ofice documents as first-class modeling artifacts and integrating them into existing applications through code generation and model interpretation. Any changes in the ofice documents are immediately reflected in the application without further design or implementation efort, which significantly increases agility in information systems engineering.
The presented approach provides an architecture and proof-of-concept implementation with several limitations and open questions, which we enumerate for further discussion in the workshop.
1. We have shown that spreadsheets can be valuable artifacts for rapid software prototyping.
We are going to explore systematically what other artifacts (e.g., technical drawings, Gantt charts) can be automatically integrated into the software development process. 2. The manual mapping of inputs and outputs in the Excel document could be automated by identifying all existing formulas and their input cells in the Excel document and assigning them as outputs in the Outputs and Inputs sheets. 3. The Python package that we use to access Excel documents does yet not support all function types of Excel. There are alternative APIs available for Python and other languages that should be investigated in terms of supported Excel features and functions.