Ambiguously formulated and constantly changing requirements for software systems make it hard to translate them into working code. To overcome these problem, we propose an approach that consolidates the requirements speci cation level with the design and implementation levels in order to shorten the path from initial requirements to the nal code. The end-user of the system will be able to specify requirements in a precise, semantically rich and domain independent User-centric Programming Language (UcPL), which will allow for direct transformation into application logic code.
Typical software development lifecycles comprise activities that lead from the initial requirements to the nal working system. These activities produce various artifacts at di erent level of abstraction: design models and code. The level of technical complexity makes these artifacts inaccessible to the end-users of the system. However, end-users can discuss the logic (functionality) of the system that abstracts away all the technical details of the software system. This should be done in a language understandable to them. The logic of the problem is usually expressed within the user requirements speci cations.
Considering this two main problems arise. The rst problem pertains to the process of transition from end-user needs into design and implementation. This includes problems with requirements elicitation and translating the functional requirements into the logic of the system. Attempts to solve these problems are mainly based on the introduction of formal and semi-formal requirements speci cation languages and automation of transformation between requirements and certain technical artifacts.
The second problem is that the path from requirements to code makes it di cult to maintain appropriate traceability links. This is especially an issue in projects that face high changeability of the requirements. Attempts to solve these problems include rapid application development environments, certain agile methodologies, which try to shorten the path from requirements to code and certain generative approaches where the traces are generated automatically.
Despite shifting the level of abstraction through the introduction of the object-oriented paradigm, still, the existing approaches necessitate a signi cant level of technical expertise to develop a working system. Thus, there is a rising need to bring the end-user closer to the software developers. The idea here is to let the end-users write some signi cant portions of software systems. The Gartner Group, in its 2008 study predicts signi cant growth in end-user software development. In 2010 an average of 34% of companies are expected to conduct more than 20% of application development outside of IT. Unfortunately, there are no approaches to allow the users to construct software through writing the problem logic at the level of requirements. The traditional way of producing software systems is to shift from requirements to code in a generally manual process. More modern approaches try to utilize dedicated tools to automate that process. This necessitates formalizing requirements and constraining the natural language in which they are normally written. 2
Requirements engineering has been established in the industry as a method for
awless transition from the early system vision over the design, implementation
up to the validation and tests. The current practice in this area is more focused
on requirements management [
Few of the above mentioned general purpose requirements languages can
execute the requirements speci cation written in it, or can be transformed directly
into complete working code. On the other hand, in recent years there has been
a drive towards developing executable domain speci c languages (DSL) [
To go further in resolving mentioned problems, we propose to allow the end-users actively participate in writing software while retaining their role of \requirements speci ers". They would specify the system logic in the language understandable for them and then automatically transform such speci cations directly into code. This would certainly lead to signi cant gains in productivity.
We aim at delivering a framework consisting of three main elements: the Usercentric Programming Language (UcPL), the design time environment and the transformation engine along with appropriate transformation algorithms. Figure 1 shows an overview of the UcPL approach. In UcPL we will substitute procedural or object-oriented programming with, so called, user-centric programming. The user-centric language constructs would just allow to specify the logic of the problem. This means that the user-centric programs could be written and read by end-users with no software development background. Most of the design and technological decisions will be hidden by the language platform.
A scenario of developing software application with UcPL is very straightforward. End-users creates requirements speci cation in the form of user-centric program. Then they choose the desired transformation algorithm. Precision required in order to apply automatic transformation, necessitates extensive mechanism for validation and correction of the UcPL language constructs. Validation should precede the transformation step. The transformation engine takes complete requirements speci cation in the form of user-centric program as an input and produces complete code of the application logic (or controller in MVC model). The output code lacks implementation of the application's business model { only class stubs with appropriate methods are generated. The application logic code contains calls to these business entities. The same pertains to the user interface elements like windows, buttons, messages, etc. However, the generated code constitutes the application framework which can be compiled and executed, what signi cantly shorten the time needed to develop the whole system.
In order to generate code of a full system, appropriate extension of UcPL for specifying business logic and user interface would be needed. This is, though, outside the scope of this work.
A programming language (Java, C++, etc.) and all technological details (e.g. use of a speci c user interface technology or speci c application framework) of the generated code will depend on the transformation algorithm used. The transformation engine built into the UcPL framework will be able to run any transformation algorithm speci ed in appropriate transformation language.
In order to ensure end-user comprehension, the UcPL language will be based on use case scenarios written in natural language with simple imperative sentences (e.g. "User enters login data\ or "System calculates exchange rate\) and control sentences expressing conditions, loops, etc. (e.g. "exchange rate greater than previous exchange rate\).
The language will clearly separate description of the user-system interaction from the description of the domain (see Figure 1). Scenarios will be hyperlinked with appropriate notions de ned in a separate vocabulary. Such hyperlinks could be then transformed into operation calls from application logic to business logic and user interface layer.
The syntax of the language will be precisely de ned as a meta-model in MOF in order to enable automatic handling of user-centric programs. 4
As we mentioned UcPL will need to combine informality with necessary
precision, that the end-users would be able to comprehend and write user-centric
programs, as well as they are able to understand and write common-prose
requirements. The language that addresses most of mentioned issues is the RSL
language [
Also an appropriate set of transformation algorithms will be implemented in
the model transformation language MOLA [
An important part of the solution is the design time environment for writing user-centric programs and performing transformations to code. It will be implemented as an extension to the existing ReDSeeDS tool which o ers appropriate infrastructure that can be utilized by using plug-in mechanism.
This will enable us to build a system that allows for developing software applications by the end-users by direct transformation from requirements to application logic code. Preliminary studies shows that the proposed approach is possible through skilful extension and combination of the existing technologies.
This goal of retaining end-user comprehensibility of the UcPL as well as useability and e ectiveness of the whole framework will be assured and validated through extensive experimental studies. These studies will be mainly carried out by students during software engineering courses. The students will be divided into two subgroups. One group will be developing a system using UcPL approach while the second group will be developing the same or similar system in a traditional way. The results will be compared and analyzed taking into account such factors as time needed to develop the nal system and quality of the system measured as the degree of initial user requirements ful llment.