Modeling a Software Development Process Using itasks
|
|
- Alexis Howard
- 8 years ago
- Views:
Transcription
1 Modeling a Software Development Process Using itasks Steffen Michels Radboud University Nijmegen Abstract. itasks [11] is a system dealing with workflows. Workflows are used to define relationships between tasks to achieve a certain goal. They could therefore be used to describe the software development process. Here itasks is used for modelling a small part of the software development process which is the task of implementing functions. The result is a web-based simple development environment. The itasks language was very suited for implementing this kind of application. However it is not possible influence the layout or implement features such as syntax highlighting and to create an application which is as user-friendly as commonly used development environments. 1 Introduction itasks [11] is a system dealing with workflows which are used to define relationships between tasks to achieve a certain goal. They define which tasks depend on each other, in which order they have to be performed and who has to do them. There are several standard patterns (identified by van der Aalst et al. [16]) which are useful for defining workflows. For example tasks can have to be executed in sequence or parallel. Unlike most commercial workflow systems itasks uses a set of combinators, implemented in the functional programming language Clean [3], to specify workflows. The set of combinators can be considered as a language for describing workflows embedded in Clean which gives the advantage that it is possible to use the power of the language for the workflow specifications. So for instance it is possible to define high-order or recursive tasks. Also it is possible to formally define a semantics for the combinators and verify it [7]. Another advantage of itasks is that it makes it possible to create interactive web applications. For this the idata Toolkit [10], which makes use of the generic programming facilities of Clean [2] to automatically generate web-interfaces for editing data-values of any type, is used This paper describes a case study where itasks is used to model a small part of the software development process. There are many different models for this process, but they have one thing in common. That is that they describe different subtasks and the relationship between them. Examples for this are that first all
2 2 requirements have to be reviewed before it is continued with the design phase, that first all unit tests have to succeed before an integration test is started or that all classes have to be documented after they have been implemented. Obviously it is very difficult to manage the process and make sure that all requirements given by the used paradigm are fulfilled. Another issue is to coordinate the work of different people working together and assign subtasks to them. Using a process description based on workflows makes it possible to describe the requirements given by the used software development paradigm and build a system which enforces them. So it becomes impossible that one requirement is not reviewed or a function is forgotten to be tested. Also it is easy to enforce certain constraints, for example that there should be a unit test for certain kinds of units before they are implemented or extended as required for test-driven development. Also tasks can be assigned to users such that it is clear who is responsible for which subtasks. Of course, tasks cannot only be assigned to human users but also to computers, which for example can do type checking or perform unit tests. Another nice thing is that it is possible to get an overview which work has been done and what still has to be done at the moment. In this research I focus on a small part of the entire process which is implementing functions and testing. The idea here is that workflows can be used to specify dependencies between functions of the program. For instance a function may use several functions which are not implemented at the moment which can lead to the task to implement them. So actually the result would be a development environment with a little bit more structure. The programming language in which functions are implemented is Esther Script. For testing Gast is used. Developing such a kind of application leads to the idea that in fact itasks can be used as a as a more general I/O paradigm. Workflows could give a more intuitive way of programming applications with graphical user interfaces than existing solutions. So this research tries to answer the question if the software developing process can be described using workflows. Also it is a test if the itasks language is suitable for this kind of problems. The goal is to get a working implementation of a web-application supporting a small part of the process. Also it is evaluated how the resulting application compares with existing commercial development environments and how useful itasks is for building such applications. Related work is the field of Computer-Assisted Software Engineering (CASE) which means applying a set of tools to improve the software development process. Examples would be UML-tools supporting the design phase. Fuggetta [4] divided these tools into different categories. They are either limited to only specific tasks within the process (Tools, Workbenches) or combine a number of tools to support large parts of the process (Environments). In contrast the idea of this research is to model the entire process using the same formalism and to get one application instead of a collection of tools. Another term related to this research is Computer Supported Cooperative Work (CSCW), introduced by Greif and Cashman [5]. This is a highly multidisciplinary field trying to understand how computers can be used to improve the collaboration of humans. Workflow sys-
3 3 tems are examples of CSCW-tools. They coordinate the work of people working on different places at different times. Finally there is some old work about program synthesizers [14,15,13] which define the process of implementing programs in a very strict way, such that the programmer cannot enter free text but has to follow the syntactical structure of the programming-language to implement a program. In practise it is very difficult to use because it restricts the programmer too much. In the rest of this article first in Section 2 the technologies used for this research are briefly described. Then in Section 3 some general remarks about modelling the software development process are made and the process which is modelled later is defined. A synchronous implementation approach has been made first. It is described in Section 4. The actual asynchronous implementation is described in Section 5. In Section 6 the resulting application and the suitability of itasks are evaluated. Finally conclusions are drawn and some ideas for future work are given in Section 7. 2 Esther Script, itasks & Gast This section will give a short introduction to the technologies used in the paper. 2.1 Esther Script Esther Script is an experimental functional script language described by Arjen van Weelden in his PHD-thesis [17]. Its syntax is a subset of Clean s syntax and it offers the following things: function application, lambda abstraction, recursive let, pattern matching and a restricted form of overloading. If a new function is defined it is type-checked and the overloading is resolved. The type of the function is automatically derived. It can then be written to disk and later be read and used by any Clean program. Any expression is first type-checked before it is evaluated. The implementation makes use of Clean s dynamics[1,9] which makes it possible to store any function in a type-save way and is also used to realise the evaluation. Also it is easy to add existing function written in Clean to the scripting language by converting them into dynamics. The language is chosen for this project because an implementation in Clean already exists. Also it is a very simple but powerful language which is well suited for this kind of prototype. 2.2 itasks The itasks framework uses a set of basic tasks and combinators to specify workflows. In the following a simple example is used to show the basic concepts. First a data-type representing a function, which has a name and can either be implemented or not, is defined. In the case it is implemented a string containing the definition can be stored. For this research a similar data-structure is used to store Esther Script definitions.
4 4 :: Function = { name :: String, state :: FunctionState } :: FunctionState = NotImplemented Implemented String A simple task to let the user enter such a function is: enterfunc :: Task Function enterfunc = enterinformation "enter function:" The basic task enterinformation lets the user input any value. The type of the value can be derived from the type of the function. Automatically a user interface is generated where the user can insert a name and choose whether the function is implemented. Also if the function is implemented the user can enter a definition. This function can be combined with other tasks like in this example: example :: Task Void example = enterfunc >>= λfunc. showmessageabout "you entered:" func Here first the user has to enter the function. This task is combined with the next one using the sequence combinator (>>=). After the user entered the information, the result is given to the lambda expressions in the last line which uses showmessageabout to print out this information. There are more basic tasks like making a choice between a number of values (enterchoice) and also more combinators, like a choice between two tasks (- -). Also there are tasks for storing information in a database. What makes those tasks very powerful is the fact that all kinds of computation, like parsing source code, can be added at any place. For instance in the prototype implemented for this research, Clean dynamic files containing the compiled Esther Script code are generated. 2.3 Gast Gast [6] is a test system, written in Clean, which uses properties in first order logic to generate test cases. For example a simple property like commutativity ( xy.x + y = y + x) can be tested by Gast. This can be tested for arbitrary types for which addition and equality is defined by just changing the type of the property. Gast uses generic techniques to generate a number of inputs for the function and checks if the property holds for the generated test cases. If the input domain is relatively small it is possible to generate all possible inputs and to proof the property by exhaustive testing. Gast also comes with the possibility to use existential quantifiers, implications and equivalence. In this research Gast is integrated into Esther Script to make it possible for the users to test the functions they defined. 3 Modelling the Software Engineering Process First some remarks about modelling the software engineering process are made. Then the process modelled in this research is defined.
5 5 3.1 Freedom vs Structure When modelling a process there is always the risk that too much structure is put on it. In a paper about the relationship between order and chaos in the software development process Nogueira et al. [8] state that there is no variability if there is an absolute structure. So no change can happen and there is no creativity. On the other hand with too less structure it can become impossible to collaborate and to get coherent results. So there always has to be a balance between structure and freedom. A workflow description should not try to model everything including all communication, but should be used to keep track of the result in a structured way. So a system like program synthesizers or a system which forces the programmer to implement one certain function at a given moment will restrict the programmer s freedom too much. There should be room for choosing to implement a particular function, to add another one and to simply play around with the program. Still a system can enforce the programmer to eventually implement and test all functions. Also the process description itself is not static. First of all there is no single good process for developing software. Actually for each project the process has to be chosen and adapted in such a form that it fits the project. So a workflow description should be flexible enough to make this possible. But even with carefully designed workflows it can happen that in reality something unexpected happens and that the workflow has to be changed. There is ongoing research about how to change a running itasks workflow [12]. 3.2 A Simple Process for Implementing Programs Implementing software is only one building block of the all process models. In some models, like the waterfall model, it is one phase but in agile models it is one phase of each iteration. The goal here was not to define a process which can be used in practise, but to start with a simple process which shows some of the basic concepts of implementing software. Nevertheless it could be used as a basis for modelling a more realistic process. In the following the process modelled in this research is described. The only role in the process are programmers. The granularity of updates are single functions: The system tells which function to change or implement, but the implementation itself is done by entering free text. There are a number of different tasks: add function: The programmer can add a function with arbitrary name (of course it should not be used yet) which is not used inside an existing function at the moment. implement functions: The programmer can choose to implement functions which are used but not implemented yet and on which nobody else is already working. remove function: The programmer can remove any function which is not currently modified by another person.
6 6 modify function: The programmer can change an existing implemented function if it is not modified by another programmer at the moment. show program state: The programmer gets an overview about all functions. A list of both implemented and also used but unimplemented functions are given. For implemented functions the name, the type and possible error messages are given. Also for each function the information who is working on it is given. debug console: The programmer can insert an arbitrary Esther Script expression which is then evaluated. If there is no error its value and type is given. Obviously the process is not suited for developing a complex product, but still it has enough functionality to develop working programs. Of course, there has to be additional communication between programmers. For instance they have to agree on who implements which functionality. This is not modelled by the process, but still the process described above could help to keep the results in a consist form. 4 A synchronous Implementation Approach One of the powerful features of itasks is that the programmer only has to specify the flow of information and does not have to deal with how intermediate results are stored and retrieved. Also all concurrency problems are solved by the framework. So it would be nice if the whole process could be described by only one workflow which generates the finished program as a result. But in practise this is very difficult to achieve. 4.1 Restriction of Existing Parallel Combinators The existing combinator for parallel task composition provided by itasks turned out to be not powerful enough to deal with even a very simple situation. The problem is that once parallel tasks are started there is no possibility to interchange information between them any more. There is a simple example where this is a problem. Assume there are tasks for defining functions. After a function is defined a new task is started for each function which was used but has not been implemented yet. Assume that tasks to define functions f and g are started in parallel and both will use function h once they are defined. After the task for implementing f finished it can then start a new task to implement h. The problem then is that if the implementation of g finishes after that, this task cannot know that there is already a task for implementing h and so starts a second task for implementing the same function. Another possibility would be that no new tasks are started and it is waited until both f and g are implemented. Then the results of both tasks can be merged and one task to implement h can be started. But this has the disadvantage that no-one can start implementing h before both tasks are finished.
7 7 4.2 The Todo-list Combinator To solve this problem I propose a new kind of combinator, called the Todo-list combinator. It has the following type: todolist :: (a b (b,[task a])) b [Task a] Task b itask a & itask b The third parameter is a list of tasks which are executed in parallel. In our case it would be tasks producing new function definitions. Then as second parameter a state of type b is given to the combinator. A value of the same type is returned if all tasks are finished. In our case this is the state of the entire program. A function given as first parameter is used to update the value of type b. So in our case all function definitions are added to the state of the program. But the function also produces a second value of type [Task a] which is a list of new tasks. Those tasks are dynamically added to the list of parallel tasks. For the example given above this means that as soon as the task for implementing f is finished the function adds the definition of f to the program and also adds function h to the program and marks it as not implemented. Additionally a new task for implementing h is added to the list of tasks. When then the task implementing g also finished and the result is evaluated h is already included in the program and therefore no new task for implementing h is added. 4.3 Remaining Problems Although I was able to implement the new combinator and use it to solve the simple problem discussed above, it would be nearly infeasible to extend the idea of doing everything in a synchronous way. Especially task to show the current state of all functions would be very difficult to realize because there is no central database were all functions are stored, but everything is implicitly stored in the state of a single workflow. Consequently there are dependencies between all different kinds of tasks. From my point of view, while theoretically possible, a perfectly synchronous process description would be difficult to create, to understand and to extend. Because of this I continued with an asynchronous approach were everything is stored in a central database. 5 The Asynchronous Implementation Because of the problems with the synchronous approach the prototype was implemented using an asynchronous approach which makes it possible to describe all different kinds of operations as separate workflows. This comes with the cost that storage of data and concurrency problems are not fully solved by the framework any more. 5.1 Overview The idea of an asynchronous approach is that there are a number of different workflows for different tasks. For instance there is a workflow for adding functions
8 8 or for viewing the state of the program. The different workflows are described later. There is a database representing the state of the program which is the state of all implemented and used functions. Each workflow manipulates the database, which gives this approach a more imperative taste. As shown in Figure 1 the system is composed out of different layers. There is a central database keeping the state of the program and an interface used to manipulate it. Finally there are workflows dealing directly with user input. Nearly all functions are implemented as tasks which makes it possible to easily compose them and to use library tasks for instance for storing data. Fig. 1: The Asynchronous Approach All applications generated with itasks are multi-user applications. Even a single user can start many instances of the same workflow at the same time. Because of this using a central database gives a lot of problems with concurrency. It is undesirable that two programmer modify the same function at the same time or a programmer is working on a function which is removed by another one in the meantime. Those issues cannot be solved by the framework any more. To solve this I added facilities to lock functions to the database s interface. For each function it is stored in the database whether and by whom it is locked at the moment. A sequence of tasks without user interaction is an atomic operation in the itasks-framework, which makes it easy to implement the locking mechanism. 5.2 Esther Helper Tasks Some tasks are defined to deal with Esther Script programs. There are tasks for interpreting Esther expressions, to write a new function to disk, to remove it again and to check if a function is already build in Esther. Also there are some operations on the syntax tree such as getting a function s name or getting all free variables in a function definition. The functions dealing with the syntax tree are not implemented as tasks because they require no I/O and it is more convenient to implement them in a functional style. 5.3 The Database The database is implemented using the storage functionality of the itasks library. The program is just a list of functions and the following data-type is used for representing them:
9 9 :: Func = Func!(DBRef Func) String Lock FunctionState :: Lock :== Maybe ProcessId :: FunctionState = NotImpl Int Impl FunctionDef :: FunctionDef = { usedfuncs :: [String], def :: String, error :: Maybe String } Each Func first has a special identifier generated by the library. Then it has a name which is also unique and is used to identify a function in most cases because it is more convenient. The next argument is of type Lock which is the process identifier of a process locking the function or nothing if it is not locked. The last field gives the function state which can be either NotImpl or Impl. In the first case the function is not defined and has a reference counter indicating by how many other functions this function is used. If there is no function left using an unimplemented function it does not have to be implemented any more and can be remove from the database. If the function is implemented there is a record giving the definition of the function simply as source, a list of used functions identified by their names and maybe an error message if there is for example a type error in this function. The workflows dealing with user input never directly access the database. There is an interface for manipulating it. The most important operations are: :: DefineFuncRes = DFError String DFSuccess addfunct :: String Task DefineFuncRes updatefunct :: String String Task DefineFuncRes deletefunct :: String Task Void Of course there are tasks for adding, updating and deleting functions. Functions are identified by their name here and the new definition is just given as string containing the source. The first two tasks can fail, if for instance there is a parse error or a function with the same name already exists. So they can report success or give an error message. Type errors are not reported here, because the type cannot be derived if unimplemented functions are used and if there is a type error the problem can also be in another function. Deleting a function always succeeds. If the function does not exist nothing happens. The implementation of those task is not trivial. Source code has to be parsed, the used functions have to be determined and their reference counts have to be updated. Also types have to be inferred if possible and code for all functions has to be generated and stored on disk. Their are also operations for locking a function such that nobody else is allowed to change it: :: LockRes = LockSuccess LockedBy ProcessId FuncRemoved lockfunct :: String Task LockRes unlockfunct :: String Task Void If one tries to get a lock it can succeed or the function is already locked or is not existing any more. The task for locking functions is an atomic operation which is ensured by itasks.
10 10 Also there are some tasks for getting a list of (un)implemented functions, the source of a certain function or the state of the entire program. 5.4 Helper Tasks Some helper tasks are needed for the user interface. Cancelling For creating a cancel button this simple task is used: Cancel = enterchoice "or cancel.." ["Cancel"] >> return Void The button is created by letting the user choose between one alternative which is the string "Cancel". If the button is pressed the task is finished. This tasks can be combined with any other task with the - - combinator. Source Code Input Entering source code is more complex than just entering free text. If the source is submitted it first has to be syntax checked. If an error occurs an error message has to be shown. In this case the input field should preserve it s value, because it is inconvenient to enter the entire source again because of a syntax error. A generic workflow for entering code is given here: repeatsrcinputt :: String Note (String Task DefineFuncRes) Task Void repeatsrcinputt msg (Note src) dbfunct = updateinformation msg (Note src) >>= λ(note src). dbfunct src >>= λres. if (dfsuccess res) (return Void) (repeatsrcinputt (dfgeterror res) (Note src) dbfunct) First a message is shown and the source given as second argument is updated by the user. The type Note is just a string which is edited by a multi-line field instead of a normal one. Then a given function is called with the source as argument. The function processes the source and return either that everything was fine or gives an error message. In the first case the workflow finishes. In the second case the workflow is used recursively to show the error message and to update the current value of the input field. Selecting Functions There is a task for selecting an implemented function which is not locked at the moment: selfunct :: (String Task Void) Task Void If a function is chosen it is first locked such that no other user can change or remove it. Then a task given as first argument is invoked with the function s name as argument. After it has done its work the function is unlocked again. Additional complexity is added by the fact that it can happen that between the generation of the list and the user event choosing one of the functions, this function can be locked or removed. This has to be checked and an error message has to be given in this case.
11 Main workflows Finally the main workflows which can be carried out by the user are described. Adding Functions Using repeatsrcinputt it is very easy to define the workflow for adding new functions by starting with an empty string as source and giving the database task addfunct as argument. At each moment it is possible to cancel the task: implnewfunctiont :: Task Void implnewfunctiont = repeatsrcinputt "definition of new function:" (Note "") addfunct - - Cancel Modifying Functions The workflow for modifying functions looks like this: modifyfunct :: Task Void modifyfunct = selfunct (λname getsource name >>= λsrc. repeatsrcinputt ("new definition:") src (updatefunct name) - - Cancel ) First selfunct is used to select and lock a function. Then the current source is retrieved as start value for repeatsrcinputt. It is important that the cancel task is combined with repeatsrcinputt and not with selfunct. Otherwise the function would not be unlocked if the user cancels the task. Removing Functions The workflow for removing functions is very similar to the one for modifying them: removefunct :: Task Void removefunct = selfunct (λname requestconfirmation ("Do you really want to remove " +++ name +++ "?") >>= λrem. if rem (deletefunct name) (return Void) ) Again first selfunct is used to select a function. If the user confirms the operation the function is deleted. Implementing Unimplemented Functions First a number of unimplemented functions are chosen which is similar to the selection of one function with the exception that the basic task for multiple-choice is used (entermultiplechoice). For each chosen function a process is spawned by this subtask:
12 12 assigntome name = getcurrentuser >>= λuser. spawnprocess user.userid True (implfunct name <<@ label) where label = "implement function " +++ name +++ " " The task spawnprocess is defined in the itasks library. It assigns a new workflow to a user and continues after this. This construction allows to add several parallel workflows for implementing different functions. The task implfunct is similar to the task for defining new functions with the exception that it has to lock and unlock the function such that nobody else implements the same one. Showing the Program State It is very important to have an overview which functions are already implemented and which still have to be. With itasks it would be possible to simply view the content of the database with one line of code by retrieving the entire database and using showmessageabout to show it to the user. The disadvantage of this is that the database contains things which are not interesting for the user, for example internal identifiers of the functions. Also the user does not want to see by which process a function is locked, but the name of the processes owner. This is solved by defining a second data-structure which includes only the information which is interested for the user. Also the names of constructors are chosen in such a way that they are readable for the user, they contain no abbreviations. If a user requests to see the current state of the program the content of the database is first converted into a value of this type. Also other computations such as retrieving the type is done during this conversion. The result is then shown to the user. Debug Console The purpose of the debug console is to provide the programmer with the ability to play around with the program in it s current state. It is possible to enter any expression which is then evaluated using the currently implemented functions. The implementation of the console is not complex, the main work is done by the helper task for interpreting Esther expressions. 5.6 Testing For testing the test system Gast is used, which uses properties to automatically generate tests. The way properties are managed is very simplistic. There is no obligation to add properties, the programmers can freely choose to add as much or less properties they want. The goal here was to show that it is possible to integrate a test system into the implementation in a straightforward way. Properties A very simple system is implemented to handle properties. They can be added or removed. Each property consists of an expression which can be tested by Gast. Technically this means that they have a type for which an instance of the class Testable exists. A property not necessarily describes only
13 13 the behaviour of one function but can also express a relationship between a number of functions. When properties are added to the system, they are only checked for syntax errors. It is for example allowed to use undefined functions in properties. This makes it possible to add properties about functions which are not defined yet. Perform Tests A programmer can perform the tests at any point in time. All properties are checked using the current state of the program. The result of all tests are divided into categories. Properties can pass all test or even be proven for a restricted input domain where exhaustive testing is possible. Test fail if a counterexample is found. There are also two other categories if for example there was no value found making an existential quantifier true but not all possible values were tested or for the case that all test values were rejected. Finally there can be test which could not be executed because of errors. Integration of Gast Esther Script makes it relatively easy to integrate existing functions written in Clean. However there are some problems when integrating Gast. The overloading mechanism of Esther Script seems not to be able to handle the following instance of the class Testable: instance Testable (a b) Testable b & TestArg a This makes functions which an arbitrary number of arguments testable. The problem here is that a part of the instance s type depends on the same class. However it is possible to add an instance for any concrete type. For example it is possible to add instances for functions handling integers and retuning a boolean up to an arbitrary number of arguments. So it is possible to add a huge number of instances such that most practical properties are covered. Another workaround was needed for converting a dynamic generated by Esther Script into a testable value, because unpacking of overloaded functions is not implemented in Clean yet. A last problem is that the interface provided by Gast is not very convenient for classifying the results. The result is a string containing the result which has to be analysed in order to get the kind of the result. 6 Evaluation The evaluation goes in two steps. First the functionality and usability of the prototype is evaluated. Then it is evaluated how suited the itasks language was for implementing it. 6.1 The Prototype The prototype has all of the intended functionality. It would be possible to develop any kind of program one wants with this development environment.
14 14 This shows that itasks in principle is powerful enough to describe this kind of application. It would also be possible to extend the prototype with more functionality like dealing which larger parts of the software development process or to use a more realistic language. The problem of the prototype is that it is not very user-friendly. For example when entering a function one would to have a larger text area. Of course, also things like syntax highlighting and code completion would be nice. It is not very convenient that each time a function is changed the task is closed. One would like to have the choice between only saving the change and closing the task. Also the view on the state of the program is not very user-friendly and would become unusable for larger programs. There should be the possibility to order and filter the list of functions in an interactive way. It would be nice if one could start implementing a function just by clicking on it in this view. 6.2 Suitability of itasks The most complex part of the application was actually the backend dealing with storing the program s state. It was not just storing some values but the database structure with locks and reference counts has to be kept in a consistent state. Actually the itasks language was very suited for defining those kind of I/O operations. Checking and changing a database is a sequential process which can conveniently be encoded by sequencing tasks. Also the storage capabilities of the library were easy to use. A nice thing is that in situations were it is easier to program in a functional style, like going through a syntax tree and collecting free variables, this is still possible. The tasks dealing with user interaction can easily be defined once the database interface is implemented. It is very intuitive to define the interaction with the user as a sequence of tasks. Also itasks makes it possible to define high-order task which were used to input source code and to select a function in this prototype. This makes it possible to easily reuse functionality which is useful for different situations. Repetition is defined using recursion which is not a problem for a functional programmer but might be difficult to read for other programmers. The real problems of itasks are that it is impossible to create a user-friendly interface if the application is not just about filling in forms. Now if there is more than one possibility what should be done with the input, first the user would have to press the okay-button and then get a choice what to do. Things like a simple save-button which should not change the interface but just process the contents of the input-field cannot be described at the moment. For example an enterinformation task with more than one button would already help in many situations. Also it is very inconvenient to view data. For this a data-type has to be constructed which contains all information the user needs. Using a record it can be influenced which labels the data gets. The problem is that it is impossible to influence the layout of the view or to insert some kind of interactivity, for example buttons.
15 15 7 Conclusions & Future Work I used itasks to describe a small part of the software development process which was a simple process for implementing functions. The resulting prototype has enough functionality to make it possible to implement any kind of program. Also it was possible to integrate the testing-system Gast for testing the implemented functions. This shows that itasks is powerful enough to describe this kind of processes. Although the process is very simple and might be not very usable for a realistic scenario it shows some basic concepts and could serve as a basis for a more complex process. The itasks language was very suited for implementing this kind of application. Describing database manipulations and user interaction as sequence of tasks is very intuitive. Also the possibility to use high-order tasks makes it possible to define generic tasks which can be used at several places. Compared to existing development environments the usability of the application is bad. The layout is not suited for implementing functions and there are no features such as syntax highlighting and code completion. The problem here is that the itasks language cannot be used to change the layout or to manipulate the user interface in such a way that it would be possible to implement a better user interface. The first direction for future work is to investigate how itasks has to be extended in order to make it powerful enough to develop user interfaces comparable to interfaces created by other techniques which means using itasks as general I/O paradigm. Ideally itasks should give the same flexibility as if writing a program with a normal library for creating user interfaces, like ExtJS, without loosing the power of creating reasonable user interfaces for any given data-type automatically. Another direction for more research is to extend the case study and to model larger parts of the software development process. The final goal would be to model the entire process from the first requirements to the acceptance test or even the support. Having the whole process in one single system has the advantage that relationships between all phases of the project can be defined and enforced. A model for the entire process has to be flexible enogh to cover several paradigm and programming languages, because there is no perfect fixed model but for each project the model is adjusted. Also it would be interesting to verify properties of the model. A semantics for itasks has been defined and general properties were tested using Gast [7]. This semantics could also be used to specify properties about a process modelled in the language of itasks. Finally a finished system has to show that it is usable for a real-world situation. So it has to be used for a real project and it has to be evaluated if it actually improves the process or not, also in comparison to existing other solutions. References 1. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Didier Rémy. Dynamic typing in polymorphic languages. Journal of Functional Programming, 5(1): ,
16 16 January Also appeared as SRC Research Report 120. Preliminary version appeared in the Proceedings of the ACM SigPlan Workshop on ML and its Applications, June Artem Alimarine. Generic Functional Programming - Conceptual Design, Implementation and Applications. PhD thesis, Radboud University Nijmegen, T. Brus, M.C.J.D. van Eekelen, M. van Leer, M.J. Plasmeijer, and H.P. Barendregt. CLEAN - A Language for Functional Graph Rewriting. In Proc. of Conference on Functional Programming Languages and Computer Architecture (FPCA 87), volume 274 of LNCS, pages , Portland, Oregon, USA, Springer. 4. Alfonso Fuggetta. A classification of CASE technology. Computer, 26(12):25 38, December Jonathan Grudin. Computer-supported cooperative work: history and focus. Computer, 27(5):19 26, May Pieter Koopman, Artem Alimarine, Jan Tretmans, and Rinus Plasmeijer. Gast: Generic automated software testing. In The 14th International Workshop on the Implementation of Functional Languages, IFL02, Selected Papers, volume 2670 of LNCS, pages Springer, Pieter Koopman, Rinus Plasmeijer, and Peter Achten. An executable and testable semantics for itasks. In Scholz, S.-B. (ed.), IFL 08 : Proceedings of the 20th International Symposium on the Implementation and Application of Functional Languages, pages Hertfordshire, UK : University of Hertfordshire, September J. Nogueira, C. Jones, and Luqi. Surfing the edge of chaos: Applications to software engineering. In Command and Control Research and Technology Symposium, June R. Plasmeijer and M. van Eekelen. Clean language report (version 2.1). November Rinus Plasmeijer and Peter Achten. idata for the world wide web - programming interconnected web forms. In In Proceedings Eighth International Symposium on Functional and Logic Programming (FLOPS 2006), volume 3945 of LNCS, pages Springer Verlag, Rinus Plasmeijer, Peter Achten, and Pieter Koopman. An Introduction to itasks: Defining Interactive Work Flows for the Web. In Central European Functional Programming School, Revised Selected Lectures, CEFP 2007, volume 5161 of LNCS, pages 1 40, Cluj-Napoca, Romania, June Springer. 12. Rinus Plasmeijer, Peter Achten, Pieter Koopman, Bas Lijnse, Thomas van Noort, and john van Groningen. itasks for a change: Enabling run-time change in an embedded workflow language. Submission for POPL Thomas Reps and Tim Teitelbaum. The synthesizer generator. SIGPLAN Not., 19(5):42 48, Tim Teitelbaum and Thomas Reps. The cornell program synthesizer: a syntaxdirected programming environment. Commun. ACM, 24(9): , Tim Teitelbaum, Thomas Reps, and Susan Horwitz. The why and wherefore of the cornell program synthesizer. SIGPLAN Not., 16(6):8 16, W. M. P. Van Der Aalst, A. H. M. Ter Hofstede, B. Kiepuszewski, and A. P. Barros. Workflow patterns. Distrib. Parallel Databases, 14(1):5 51, Arjen van Weelden. Putting Types To Good Use. PhD thesis, Radboud University Nijmegen, October 2007.
Using a Functional Language as Embedding Modeling Language for Web-Based Workflow Applications
Using a Functional Language as Embedding Modeling Language for Web-Based Workflow Applications Rinus Plasmeijer 1, Jan Martin Jansen 2, Pieter Koopman 1, Peter Achten 1 1 Institute for Computing and Information
More informationOntology-Based Discovery of Workflow Activity Patterns
Ontology-Based Discovery of Workflow Activity Patterns Diogo R. Ferreira 1, Susana Alves 1, Lucinéia H. Thom 2 1 IST Technical University of Lisbon, Portugal {diogo.ferreira,susana.alves}@ist.utl.pt 2
More information[Refer Slide Time: 05:10]
Principles of Programming Languages Prof: S. Arun Kumar Department of Computer Science and Engineering Indian Institute of Technology Delhi Lecture no 7 Lecture Title: Syntactic Classes Welcome to lecture
More informationThomas Jefferson High School for Science and Technology Program of Studies Foundations of Computer Science. Unit of Study / Textbook Correlation
Thomas Jefferson High School for Science and Technology Program of Studies Foundations of Computer Science updated 03/08/2012 Unit 1: JKarel 8 weeks http://www.fcps.edu/is/pos/documents/hs/compsci.htm
More informationThe Clean programming language. Group 25, Jingui Li, Daren Tuzi
The Clean programming language Group 25, Jingui Li, Daren Tuzi The Clean programming language Overview The Clean programming language first appeared in 1987 and is still being further developed. It was
More informationJava Application Developer Certificate Program Competencies
Java Application Developer Certificate Program Competencies After completing the following units, you will be able to: Basic Programming Logic Explain the steps involved in the program development cycle
More informationModeling the User Interface of Web Applications with UML
Modeling the User Interface of Web Applications with UML Rolf Hennicker,Nora Koch,2 Institute of Computer Science Ludwig-Maximilians-University Munich Oettingenstr. 67 80538 München, Germany {kochn,hennicke}@informatik.uni-muenchen.de
More informationSo today we shall continue our discussion on the search engines and web crawlers. (Refer Slide Time: 01:02)
Internet Technology Prof. Indranil Sengupta Department of Computer Science and Engineering Indian Institute of Technology, Kharagpur Lecture No #39 Search Engines and Web Crawler :: Part 2 So today we
More informationMoving from CS 61A Scheme to CS 61B Java
Moving from CS 61A Scheme to CS 61B Java Introduction Java is an object-oriented language. This document describes some of the differences between object-oriented programming in Scheme (which we hope you
More informationCo-Creation of Models and Metamodels for Enterprise. Architecture Projects.
Co-Creation of Models and Metamodels for Enterprise Architecture Projects Paola Gómez pa.gomez398@uniandes.edu.co Hector Florez ha.florez39@uniandes.edu.co ABSTRACT The linguistic conformance and the ontological
More informationLecture Notes in Computer Science 5161
Lecture Notes in Computer Science 5161 Commenced Publication in 1973 Founding and Former Series Editors: Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen Editorial Board David Hutchison Lancaster University,
More informationDemonstrating WSMX: Least Cost Supply Management
Demonstrating WSMX: Least Cost Supply Management Eyal Oren 2, Alexander Wahler 1, Bernhard Schreder 1, Aleksandar Balaban 1, Michal Zaremba 2, and Maciej Zaremba 2 1 NIWA Web Solutions, Vienna, Austria
More informationCurriculum Map. Discipline: Computer Science Course: C++
Curriculum Map Discipline: Computer Science Course: C++ August/September: How can computer programs make problem solving easier and more efficient? In what order does a computer execute the lines of code
More informationSyntax Check of Embedded SQL in C++ with Proto
Proceedings of the 8 th International Conference on Applied Informatics Eger, Hungary, January 27 30, 2010. Vol. 2. pp. 383 390. Syntax Check of Embedded SQL in C++ with Proto Zalán Szűgyi, Zoltán Porkoláb
More informationThe Software Development Process
Systeme hoher Qualität und Sicherheit Universität Bremen WS 2015/2016 Lecture 03 (26.10.2015) The Software Development Process Christoph Lüth Jan Peleska Dieter Hutter Your Daily Menu Models of software
More informationMasters in Human Computer Interaction
Masters in Human Computer Interaction Programme Requirements Taught Element, and PG Diploma in Human Computer Interaction: 120 credits: IS5101 CS5001 CS5040 CS5041 CS5042 or CS5044 up to 30 credits from
More information6. Control Structures
- 35 - Control Structures: 6. Control Structures A program is usually not limited to a linear sequence of instructions. During its process it may bifurcate, repeat code or take decisions. For that purpose,
More informationOverview Motivating Examples Interleaving Model Semantics of Correctness Testing, Debugging, and Verification
Introduction Overview Motivating Examples Interleaving Model Semantics of Correctness Testing, Debugging, and Verification Advanced Topics in Software Engineering 1 Concurrent Programs Characterized by
More informationLecture 03 (04.11.2013) Quality of the Software Development Process
Systeme hoher Qualität und Sicherheit Universität Bremen, WS 2013/14 Lecture 03 (04.11.2013) Quality of the Software Development Process Christoph Lüth Christian Liguda Your Daily Menu Models of Software
More informationMasters in Computing and Information Technology
Masters in Computing and Information Technology Programme Requirements Taught Element, and PG Diploma in Computing and Information Technology: 120 credits: IS5101 CS5001 or CS5002 CS5003 up to 30 credits
More informationMasters in Networks and Distributed Systems
Masters in Networks and Distributed Systems Programme Requirements Taught Element, and PG Diploma in Networks and Distributed Systems: 120 credits: IS5101 CS5001 CS5021 CS4103 or CS5023 in total, up to
More informationSemantic Stored Procedures Programming Environment and performance analysis
Semantic Stored Procedures Programming Environment and performance analysis Marjan Efremov 1, Vladimir Zdraveski 2, Petar Ristoski 2, Dimitar Trajanov 2 1 Open Mind Solutions Skopje, bul. Kliment Ohridski
More informationSoftware quality improvement via pattern matching
Software quality improvement via pattern matching Radu Kopetz and Pierre-Etienne Moreau INRIA & LORIA {Radu.Kopetz, Pierre-Etienne.Moreau@loria.fr Abstract. Nested if-then-else statements is the most common
More informationDeveloping Physical Solutions for InfoSphere Master Data Management Server Advanced Edition v11. MDM Workbench Development Tutorial
Developing Physical Solutions for InfoSphere Master Data Management Server Advanced Edition v11 MDM Workbench Development Tutorial John Beaven/UK/IBM 2013 Page 1 Contents Overview Machine Requirements
More informationDomains and Competencies
Domains and Competencies DOMAIN I TECHNOLOGY APPLICATIONS CORE Standards Assessed: Computer Science 8 12 I VII Competency 001: The computer science teacher knows technology terminology and concepts; the
More informationIntegration of an open source rule engine to enhance the IHTSDO Workbench testing
Integration of an open source rule engine to enhance the IHTSDO Workbench testing Dr. Guillermo Reynoso Dr. Alejandro Lopez Osornio termmed IT Buenos Aires, Argentina 2009 termmed SA Terminology maintenance
More informationArchitecture Design & Sequence Diagram. Week 7
Architecture Design & Sequence Diagram Week 7 Announcement Reminder Midterm I: 1:00 1:50 pm Wednesday 23 rd March Ch. 1, 2, 3 and 26.5 Hour 1, 6, 7 and 19 (pp.331 335) Multiple choice Agenda (Lecture)
More informationKITES TECHNOLOGY COURSE MODULE (C, C++, DS)
KITES TECHNOLOGY 360 Degree Solution www.kitestechnology.com/academy.php info@kitestechnology.com technologykites@gmail.com Contact: - 8961334776 9433759247 9830639522.NET JAVA WEB DESIGN PHP SQL, PL/SQL
More informationTesting LTL Formula Translation into Büchi Automata
Testing LTL Formula Translation into Büchi Automata Heikki Tauriainen and Keijo Heljanko Helsinki University of Technology, Laboratory for Theoretical Computer Science, P. O. Box 5400, FIN-02015 HUT, Finland
More information1.. This UI allows the performance of the business process, for instance, on an ecommerce system buy a book.
* ** Today s organization increasingly prompted to integrate their business processes and to automate the largest portion possible of them. A common term used to reflect the automation of these processes
More information1 Introduction. 2 An Interpreter. 2.1 Handling Source Code
1 Introduction The purpose of this assignment is to write an interpreter for a small subset of the Lisp programming language. The interpreter should be able to perform simple arithmetic and comparisons
More informationLecture 03 (26.10.2015) The Software Development Process. Software Development Models. Where are we? Your Daily Menu.
Your Daily Menu Systeme hoher Qualität und Sicherheit Universität Bremen WS 2015/2016 Lecture 03 (26.10.2015) The Software Development Process Christoph Lüth Jan Peleska Dieter Hutter Models of software
More informationTHE CERN/SL XDATAVIEWER: AN INTERACTIVE GRAPHICAL TOOL FOR DATA VISUALIZATION AND EDITING
THE CERN/SL XDATAVIEWER: AN INTERACTIVE GRAPHICAL TOOL FOR DATA VISUALIZATION AND EDITING Abstract G. Morpurgo, CERN As a result of many years of successive refinements, the CERN/SL Xdataviewer tool has
More informationProgramming Languages
Programming Languages Qing Yi Course web site: www.cs.utsa.edu/~qingyi/cs3723 cs3723 1 A little about myself Qing Yi Ph.D. Rice University, USA. Assistant Professor, Department of Computer Science Office:
More informationImplementação. Interfaces Pessoa Máquina 2010/11. 2009-11 Salvador Abreu baseado em material Alan Dix. Thursday, June 2, 2011
Implementação Interfaces Pessoa Máquina 2010/11 2009-11 baseado em material Alan Dix 1 Windowing systems Architecture Layers Higher level Tool UI Toolkit (Widgets) Window System OS Application Hardware
More informationHow To Develop Software
Software Engineering Prof. N.L. Sarda Computer Science & Engineering Indian Institute of Technology, Bombay Lecture-4 Overview of Phases (Part - II) We studied the problem definition phase, with which
More informationABET General Outcomes. Student Learning Outcomes for BS in Computing
ABET General a. An ability to apply knowledge of computing and mathematics appropriate to the program s student outcomes and to the discipline b. An ability to analyze a problem, and identify and define
More informationCompute Cluster Server Lab 3: Debugging the parallel MPI programs in Microsoft Visual Studio 2005
Compute Cluster Server Lab 3: Debugging the parallel MPI programs in Microsoft Visual Studio 2005 Compute Cluster Server Lab 3: Debugging the parallel MPI programs in Microsoft Visual Studio 2005... 1
More informationObject-Oriented Software Specification in Programming Language Design and Implementation
Object-Oriented Software Specification in Programming Language Design and Implementation Barrett R. Bryant and Viswanathan Vaidyanathan Department of Computer and Information Sciences University of Alabama
More informationII. PREVIOUS RELATED WORK
An extended rule framework for web forms: adding to metadata with custom rules to control appearance Atia M. Albhbah and Mick J. Ridley Abstract This paper proposes the use of rules that involve code to
More informationFunctional Programming. Functional Programming Languages. Chapter 14. Introduction
Functional Programming Languages Chapter 14 Introduction Functional programming paradigm History Features and concepts Examples: Lisp ML 1 2 Functional Programming Functional Programming Languages The
More informationHTML5 Data Visualization and Manipulation Tool Colorado School of Mines Field Session Summer 2013
HTML5 Data Visualization and Manipulation Tool Colorado School of Mines Field Session Summer 2013 Riley Moses Bri Fidder Jon Lewis Introduction & Product Vision BIMShift is a company that provides all
More informationSoftware Process for QA
Software Process for QA Basic approaches & alternatives CIS 610, W98 / M Young 1/7/98 1 This introduction and overview is intended to provide some basic background on software process (sometimes called
More informationInformatica e Sistemi in Tempo Reale
Informatica e Sistemi in Tempo Reale Introduction to C programming Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa October 25, 2010 G. Lipari (Scuola Superiore Sant Anna)
More informationAAF. Improving the workflows. Abbreviations. Advanced Authoring Format. Brad Gilmer AAF Association
AAF the Advanced Authoring Format Brad Gilmer AAF Association The Advanced Authoring Format (AAF) enables content creators to easily exchange digital media essence and metadata across platforms, and between
More informationModeling Workflow Patterns
Modeling Workflow Patterns Bizagi Suite Workflow Patterns 1 Table of Contents Modeling workflow patterns... 4 Implementing the patterns... 4 Basic control flow patterns... 4 WCP 1- Sequence... 4 WCP 2-
More informationExecution of A Requirement Model in Software Development
Execution of A Requirement Model in Software Development Wuwei Shen, Mohsen Guizani and Zijiang Yang Dept of Computer Science, Western Michigan University {wwshen,mguizani,zijiang}@cs.wmich.edu Kevin Compton
More informationEssential Visual Studio Team System
Essential Visual Studio Team System Introduction This course helps software development teams successfully deliver complex software solutions with Microsoft Visual Studio Team System (VSTS). Discover how
More informationIntegration of Application Business Logic and Business Rules with DSL and AOP
Integration of Application Business Logic and Business Rules with DSL and AOP Bogumiła Hnatkowska and Krzysztof Kasprzyk Wroclaw University of Technology, Wyb. Wyspianskiego 27 50-370 Wroclaw, Poland Bogumila.Hnatkowska@pwr.wroc.pl
More informationModel-Based Testing of Web Applications using NModel
Model-Based Testing of Web Applications using NModel Juhan Ernits 1, Rivo Roo 2, Jonathan Jacky 3, and Margus Veanes 4 1 University of Birmingham, UK j.ernits@cs.bham.ac.uk 2 Reach-U Ltd,Tartu, Estonia
More informationMasters in Advanced Computer Science
Masters in Advanced Computer Science Programme Requirements Taught Element, and PG Diploma in Advanced Computer Science: 120 credits: IS5101 CS5001 up to 30 credits from CS4100 - CS4450, subject to appropriate
More informationDemonstration of an Automated Integrated Test Environment for Web-based Applications
Demonstration of an Automated Integrated Test Environment for Web-based Applications Tiziana Margaria 1,2, Oliver Niese 2, and Bernhard Steffen 2 1 METAFrame Technologies GmbH, Dortmund, Germany TMargaria@METAFrame.de
More informationObject Oriented Programming. Risk Management
Section V: Object Oriented Programming Risk Management In theory, there is no difference between theory and practice. But, in practice, there is. - Jan van de Snepscheut 427 Chapter 21: Unified Modeling
More informationPeter Mileff PhD SOFTWARE ENGINEERING. The Basics of Software Engineering. University of Miskolc Department of Information Technology
Peter Mileff PhD SOFTWARE ENGINEERING The Basics of Software Engineering University of Miskolc Department of Information Technology Introduction Péter Mileff - Department of Information Engineering Room
More informationMASTERTAG DEVELOPER GUIDE
MASTERTAG DEVELOPER GUIDE TABLE OF CONTENTS 1 Introduction... 4 1.1 What is the zanox MasterTag?... 4 1.2 What is the zanox page type?... 4 2 Create a MasterTag application in the zanox Application Store...
More informationCRM 2013 Workflows. Description
CRM 2013 Workflows What can Workflows do? In CRM 2013, there are four types of Processes that can be created. We are covering Workflows today, but here is a brief explanation of each type. Process category
More informationVariable Base Interface
Chapter 6 Variable Base Interface 6.1 Introduction Finite element codes has been changed a lot during the evolution of the Finite Element Method, In its early times, finite element applications were developed
More informationCS 2112 Spring 2014. 0 Instructions. Assignment 3 Data Structures and Web Filtering. 0.1 Grading. 0.2 Partners. 0.3 Restrictions
CS 2112 Spring 2014 Assignment 3 Data Structures and Web Filtering Due: March 4, 2014 11:59 PM Implementing spam blacklists and web filters requires matching candidate domain names and URLs very rapidly
More informationMasters in Artificial Intelligence
Masters in Artificial Intelligence Programme Requirements Taught Element, and PG Diploma in Artificial Intelligence: 120 credits: IS5101 CS5001 CS5010 CS5011 CS4402 or CS5012 in total, up to 30 credits
More information09336863931 : provid.ir
provid.ir 09336863931 : NET Architecture Core CSharp o Variable o Variable Scope o Type Inference o Namespaces o Preprocessor Directives Statements and Flow of Execution o If Statement o Switch Statement
More informationToad for Oracle 8.6 SQL Tuning
Quick User Guide for Toad for Oracle 8.6 SQL Tuning SQL Tuning Version 6.1.1 SQL Tuning definitively solves SQL bottlenecks through a unique methodology that scans code, without executing programs, to
More informationBuilding Web-based Infrastructures for Smart Meters
Building Web-based Infrastructures for Smart Meters Andreas Kamilaris 1, Vlad Trifa 2, and Dominique Guinard 2 1 University of Cyprus, Nicosia, Cyprus 2 ETH Zurich and SAP Research, Switzerland Abstract.
More informationSMock A Test Platform for the Evaluation of Monitoring Tools
SMock A Test Platform for the Evaluation of Monitoring Tools User Manual Ruth Mizzi Faculty of ICT University of Malta June 20, 2013 Contents 1 Introduction 3 1.1 The Architecture and Design of SMock................
More informationDefinition of SOA. Capgemini University Technology Services School. 2006 Capgemini - All rights reserved November 2006 SOA for Software Architects/ 2
Gastcollege BPM Definition of SOA Services architecture is a specific approach of organizing the business and its IT support to reduce cost, deliver faster & better and leverage the value of IT. November
More informationVerifying Semantic of System Composition for an Aspect-Oriented Approach
2012 International Conference on System Engineering and Modeling (ICSEM 2012) IPCSIT vol. 34 (2012) (2012) IACSIT Press, Singapore Verifying Semantic of System Composition for an Aspect-Oriented Approach
More informationAdvanced compiler construction. General course information. Teacher & assistant. Course goals. Evaluation. Grading scheme. Michel Schinz 2007 03 16
Advanced compiler construction Michel Schinz 2007 03 16 General course information Teacher & assistant Course goals Teacher: Michel Schinz Michel.Schinz@epfl.ch Assistant: Iulian Dragos INR 321, 368 64
More informationTemporal Logics. Computation Tree Logic
Temporal Logics CTL: definition, relationship between operators, adequate sets, specifying properties, safety/liveness/fairness Modeling: sequential, concurrent systems; maximum parallelism/interleaving
More informationGeneral Problem Solving Model. Software Development Methodology. Chapter 2A
General Problem Solving Model Software Development Methodology These focus on understanding what the problem is about Chapter 2A Concerned with understanding more about the nature of the problem and possible
More informationDecomposition into Parts. Software Engineering, Lecture 4. Data and Function Cohesion. Allocation of Functions and Data. Component Interfaces
Software Engineering, Lecture 4 Decomposition into suitable parts Cross cutting concerns Design patterns I will also give an example scenario that you are supposed to analyse and make synthesis from The
More informationTopics. Introduction. Java History CS 146. Introduction to Programming and Algorithms Module 1. Module Objectives
Introduction to Programming and Algorithms Module 1 CS 146 Sam Houston State University Dr. Tim McGuire Module Objectives To understand: the necessity of programming, differences between hardware and software,
More informationUseful Patterns for BPEL Developers
Central Page 457 of 493 Useful Patterns for BPEL Developers Darko Andročec, Dragutin Kermek Faculty of Organization and Informatics University of Zagreb Pavlinska 2, 42000 {darko.androcec, dragutin.kermek}@foi.hr
More informationHow To Write An Electronic Health Record
EHR Requirements David LLOYD and Dipak KALRA CHIME Centre for Health Informatics and Multiprofessional Education, University College London N19 5LW, by email: d.lloyd@chime.ucl.ac.uk. Abstract. Published
More informationDatavetenskapligt Program (kandidat) Computer Science Programme (master)
Datavetenskapligt Program (kandidat) Computer Science Programme (master) Wolfgang Ahrendt Director Datavetenskap (BSc), Computer Science (MSc) D&IT Göteborg University, 30/01/2009 Part I D&IT: Computer
More informationVHDL Test Bench Tutorial
University of Pennsylvania Department of Electrical and Systems Engineering ESE171 - Digital Design Laboratory VHDL Test Bench Tutorial Purpose The goal of this tutorial is to demonstrate how to automate
More informationThe ConTract Model. Helmut Wächter, Andreas Reuter. November 9, 1999
The ConTract Model Helmut Wächter, Andreas Reuter November 9, 1999 Overview In Ahmed K. Elmagarmid: Database Transaction Models for Advanced Applications First in Andreas Reuter: ConTracts: A Means for
More information(Refer Slide Time: 01:52)
Software Engineering Prof. N. L. Sarda Computer Science & Engineering Indian Institute of Technology, Bombay Lecture - 2 Introduction to Software Engineering Challenges, Process Models etc (Part 2) This
More informationSoftware Engineering
Software Engineering Lecture 06: Design an Overview Peter Thiemann University of Freiburg, Germany SS 2013 Peter Thiemann (Univ. Freiburg) Software Engineering SWT 1 / 35 The Design Phase Programming in
More informationMonitoring Infrastructure (MIS) Software Architecture Document. Version 1.1
Monitoring Infrastructure (MIS) Software Architecture Document Version 1.1 Revision History Date Version Description Author 28-9-2004 1.0 Created Peter Fennema 8-10-2004 1.1 Processed review comments Peter
More informationJos Warmer, Independent jos.warmer@openmodeling.nl www.openmodeling.nl
Domain Specific Languages for Business Users Jos Warmer, Independent jos.warmer@openmodeling.nl www.openmodeling.nl Sheet 2 Background Experience Business DSLs Insurance Product Modeling (structure) Pattern
More informationDigital Industries Trailblazer Apprenticeship. Software Developer - Occupational Brief
Digital Industries Trailblazer Apprenticeship Software Developer - Occupational Brief Table of Contents Contents 1 Software Developer Trailblazer Apprenticeship Introduction... 1 2 Software Developer Trailblazer
More informationProgramming Database lectures for mathema
Programming Database lectures for mathematics students April 25, 2015 Functions Functions are defined in Postgres with CREATE FUNCTION name(parameter type,...) RETURNS result-type AS $$ function-body $$
More informationC Compiler Targeting the Java Virtual Machine
C Compiler Targeting the Java Virtual Machine Jack Pien Senior Honors Thesis (Advisor: Javed A. Aslam) Dartmouth College Computer Science Technical Report PCS-TR98-334 May 30, 1998 Abstract One of the
More informationAlgorithm & Flowchart & Pseudo code. Staff Incharge: S.Sasirekha
Algorithm & Flowchart & Pseudo code Staff Incharge: S.Sasirekha Computer Programming and Languages Computers work on a set of instructions called computer program, which clearly specify the ways to carry
More informationSTRUCTURE AND FLOWS. By Hagan Rivers, Two Rivers Consulting FREE CHAPTER
UIE REPORTS FUNDAMENTALS SERIES T H E D E S I G N E R S G U I D E T O WEB APPLICATIONS PART I: STRUCTURE AND FLOWS By Hagan Rivers, Two Rivers Consulting FREE CHAPTER User Interface Engineering User Interface
More informationGeneric Graphical User Interfaces
Generic Graphical User Interfaces Peter Achten, Marko van Eekelen, and Rinus Plasmeijer Department of Software Technology, University of Nijmegen, The Netherlands peter88@cs.kun.nl, marko@cs.kun.nl, rinus@cs.kun.nl
More informationUML-based Test Generation and Execution
UML-based Test Generation and Execution Jean Hartmann, Marlon Vieira, Herb Foster, Axel Ruder Siemens Corporate Research, Inc. 755 College Road East Princeton NJ 08540, USA jeanhartmann@siemens.com ABSTRACT
More informationVerifying Business Processes Extracted from E-Commerce Systems Using Dynamic Analysis
Verifying Business Processes Extracted from E-Commerce Systems Using Dynamic Analysis Derek Foo 1, Jin Guo 2 and Ying Zou 1 Department of Electrical and Computer Engineering 1 School of Computing 2 Queen
More informationTowards a Framework for Generating Tests to Satisfy Complex Code Coverage in Java Pathfinder
Towards a Framework for Generating Tests to Satisfy Complex Code Coverage in Java Pathfinder Matt Department of Computer Science and Engineering University of Minnesota staats@cs.umn.edu Abstract We present
More informationBPMN PATTERNS USED IN MANAGEMENT INFORMATION SYSTEMS
BPMN PATTERNS USED IN MANAGEMENT INFORMATION SYSTEMS Gabriel Cozgarea 1 Adrian Cozgarea 2 ABSTRACT: Business Process Modeling Notation (BPMN) is a graphical standard in which controls and activities can
More informationA STEP Towards a Computer based Integrated Building Design System
A STEP Towards a Computer based Integrated Building Design System Sun M. and Lockley S. R. University of Newcastle upon Tyne Department of Architecture Newcastle upon Tyne United Kingdom ABSTRACT Building
More informationARIZONA CTE CAREER PREPARATION STANDARDS & MEASUREMENT CRITERIA SOFTWARE DEVELOPMENT, 15.1200.40
SOFTWARE DEVELOPMENT, 15.1200.40 1.0 APPLY PROBLEM-SOLVING AND CRITICAL THINKING SKILLS TO INFORMATION TECHNOLOGY 1.1 Describe methods and considerations for prioritizing and scheduling software development
More informationTool Support for Inspecting the Code Quality of HPC Applications
Tool Support for Inspecting the Code Quality of HPC Applications Thomas Panas Dan Quinlan Richard Vuduc Center for Applied Scientific Computing Lawrence Livermore National Laboratory P.O. Box 808, L-550
More informationBasic Testing Concepts and Terminology
T-76.5613 Software Testing and Quality Assurance Lecture 2, 13.9.2006 Basic Testing Concepts and Terminology Juha Itkonen SoberIT Contents Realities and principles of Testing terminology and basic concepts
More informationTHE BCS PROFESSIONAL EXAMINATIONS Diploma. April 2006 EXAMINERS REPORT. Systems Design
THE BCS PROFESSIONAL EXAMINATIONS Diploma April 2006 EXAMINERS REPORT Systems Design Question. a) Write a BRIEF explanation of the purpose of TWO of the following UML diagrams as used in Object- Oriented
More informationTOP. to the. Rescue. Bas Lijnse. Task-Oriented Programming For Incident Response Applications
Task-Oriented Programming For Incident Response Applications TOP to the Rescue Bas Lijnse TOP to the Rescue Task-Oriented Programming for Incident Response Applications Bas Lijnse This research has been
More informationSoftware Engineering Reference Framework
Software Engineering Reference Framework Michel Chaudron, Jan Friso Groote, Kees van Hee, Kees Hemerik, Lou Somers, Tom Verhoeff. Department of Mathematics and Computer Science Eindhoven University of
More informationCedalion A Language Oriented Programming Language (Extended Abstract)
Cedalion A Language Oriented Programming Language (Extended Abstract) David H. Lorenz Boaz Rosenan The Open University of Israel Abstract Implementations of language oriented programming (LOP) are typically
More informationDynamic Business Process Management based on Process Change Patterns
2007 International Conference on Convergence Information Technology Dynamic Business Process Management based on Process Change Patterns Dongsoo Kim 1, Minsoo Kim 2, Hoontae Kim 3 1 Department of Industrial
More informationA Mind Map Based Framework for Automated Software Log File Analysis
2011 International Conference on Software and Computer Applications IPCSIT vol.9 (2011) (2011) IACSIT Press, Singapore A Mind Map Based Framework for Automated Software Log File Analysis Dileepa Jayathilake
More informationComplexities of Simulating a Hybrid Agent-Landscape Model Using Multi-Formalism
Complexities of Simulating a Hybrid Agent-Landscape Model Using Multi-Formalism Composability Gary R. Mayer Gary.Mayer@asu.edu Hessam S. Sarjoughian Sarjougian@asu.edu Arizona Center for Integrative Modeling
More information