DOCSLIB.ORG

Computational Methods for Oil Recovery PASI: Scientific Computing in the Americas

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Computational Methods for Oil Recovery PASI: Scientific Computing in the Americas Computational Model Computational Methods for Oil Recovery PASI: Scientific Computing in the Americas The Challenge of Massive Parallelism Luis M. de la Cruz Salas Instituto de Geof´ısica Universidad Nacional Aut´onomade M´exico January 2011 Valpara´ıso,Chile Comp EOR LMCS 1 / 47 Computational Model Table of contents 1 Computational Model OOP & Generic Programming TUNA CUDA & Seldon Final Remarks Comp EOR LMCS 2 / 47 Modular Programming Module: contains a set of procedures along the data they work on (F90, C++, ::: ). Object{Oriented Programming Construction of user defined Abstract Data Types (ADT), called classes of objects. Behaviour and data are encapsulated in classes (C++, Java, F90+). Generic Programming We focus on the implementation of models defined by a set of requirements bundled into a concept (C++). E. g. the study of linear algebra algorithms produce Matrix and Vector concepts. Computational Model Structured Programming Subroutines, Functions, Procedures (C, F77, ::: ) Comp EOR LMCS 3 / 47 Object{Oriented Programming Construction of user defined Abstract Data Types (ADT), called classes of objects. Behaviour and data are encapsulated in classes (C++, Java, F90+). Generic Programming We focus on the implementation of models defined by a set of requirements bundled into a concept (C++). E. g. the study of linear algebra algorithms produce Matrix and Vector concepts. Computational Model Structured Programming Subroutines, Functions, Procedures (C, F77, ::: ) Modular Programming Module: contains a set of procedures along the data they work on (F90, C++, ::: ). Comp EOR LMCS 3 / 47 Generic Programming We focus on the implementation of models defined by a set of requirements bundled into a concept (C++). E. g. the study of linear algebra algorithms produce Matrix and Vector concepts. Computational Model Structured Programming Subroutines, Functions, Procedures (C, F77, ::: ) Modular Programming Module: contains a set of procedures along the data they work on (F90, C++, ::: ). Object{Oriented Programming Construction of user defined Abstract Data Types (ADT), called classes of objects. Behaviour and data are encapsulated in classes (C++, Java, F90+). Comp EOR LMCS 3 / 47 Computational Model Structured Programming Subroutines, Functions, Procedures (C, F77, ::: ) Modular Programming Module: contains a set of procedures along the data they work on (F90, C++, ::: ). Object{Oriented Programming Construction of user defined Abstract Data Types (ADT), called classes of objects. Behaviour and data are encapsulated in classes (C++, Java, F90+). Generic Programming We focus on the implementation of models defined by a set of requirements bundled into a concept (C++). E. g. the study of linear algebra algorithms produce Matrix and Vector concepts. Comp EOR LMCS 3 / 47 Computational Model OOP & Generic Programming Table of contents 1 Computational Model OOP & Generic Programming TUNA CUDA & Seldon Final Remarks Comp EOR LMCS 4 / 47 Computational Model OOP & Generic Programming Generic Programming (GP)I To developing efficient and reusable software libraries [6]. Main idea: many algorithms can be abstracted away from the particular data structures on which they operate. For example: The algorithm accumulate(), which successively applies a binary operator to each element of a container. Typical use would be to sum the elements of a container, using the addition operator. accumulate() algorithm in C++: t e m p l a t e < class InputIterator , c l a s s T > double x[10]; T accumulate(InputIterator first , v e c t o r <double> y ( 1 0 ) ; InputIterator last , l i s t <complex<double> > z ( 1 0 ) ; T i n i t ) f a=accumulate(x, x+10, 0.0); for (; first != last; ++first) b=accumulate(y.begin() ,y.end() ,0.0); i n i t = i n i t + ∗ f i r s t ; c=accumulate(z.begin() ,z.end() ,0.0); return init; g Comp EOR LMCS 5 / 47 Computational Model OOP & Generic Programming Generic Programming (GP)II The algorithm can be used with any container that exports the InputIterator interface. An InputIterator can be de-referenced. An InputIterator can be incremented. GP process (lifting): Identify useful and efficient algorithms. Focus on finding commonality among similar implementations of the same algorithm, and then find its generic representation. Derive a set of (minimal) requirements that allow these algorithms to run and run efficiently. Construct a framework based on classifications of requeriments. Lifting process provide us with a suitable abstractions so that a single, generic algorithm can cover many concrete implementations. Comp EOR LMCS 6 / 47 Computational Model OOP & Generic Programming Generic Programming (GP) III Concepts : describe a set of abstractions, each of which meets all of the requirements. Graph algorithms will produce Graph concepts. Linear algebra algorithms will produce Matrix and Vector concepts. Model : is an abstraction that meets all requirements. Summary: GP process give us a better understanding of the problem domain. GP is the creation of a systematic organization of abstract and efficient software components. GP is to program with concepts. GP is not about languages features. Standard Template Library (STL) uses generic programming. THRUST use many concepts from STL. Comp EOR LMCS 7 / 47 Computational Model OOP & Generic Programming Classes and Objects A C++ Implementation while ( t <= Tmax) f IMPES Algorithm pressure. calcCoefficients (); Solver ::TDMA1D( pressure ); 1: while (t < Tmax) do pressure .update(); 2: Calc. coeff. of pressure equation. 3: Solve the pressure equation implicitly. saturation. calcCoefficients (); 4: Calc. coeff. of saturation equation. Solver :: solExplicit(saturation); 5: Solve the saturation eq. explicitly. saturation .update(); 6: t t + ∆t 7: end while t += dt ; g An object has a name, attributes and behaviour. A class is a construct that is used as a blueprint to create objects. An object of a given class is called an instance of the class. Comp EOR LMCS 8 / 47 Computational Model OOP & Generic Programming Class declaration class Vector f class Matrix f p r i v a t e : p r i v a t e : i n t s i z e ; int rows, cols; double ∗ data ; Vector ∗ d v e c t o r s ; p u b l i c : p u b l i c : Vector ( ) ; Matrix(int , int); Vector(int ); Matrix(const Matrix&); Vector(const Vector&); int getCols() const; int getDimension() const; int getRows() const void setDimension(int ); void setCols(int); void resize(int); void setRows(); double& operator()(int i) const g ; f return data[i ]; g ; g ; Vector x(10), y(10), z(10); Matrix A(10,10), B(10,10); Vector& operator+(const Vector&, z = x + y ; const Vector); A = B ∗ z ; Comp EOR LMCS 9 / 47 Computational Model OOP & Generic Programming Templates Classes Functions template<typename T> class Vector f t e m p l a t e <typename T> p r i v a t e : inline T const& max (T const& a, i n t s i z e ; T c o n s t& b ) T ∗ data ; f p u b l i c : r e t u r n a < b ? b : a ; Vector ( ) ; g Vector(int ); Vector(const Vector&); i n t main ( ) f int getDimension() const; i n t i = 4 2 ; void setDimension(int ); ::max(7,i); //max<i n t >(7 , i ) void resize(int); double f1 = 3.4; T& operator()(int i) const double f 2 = −6.7; f return data[i ]; g ; ::max(f1,f2); //max<double >(f1 , f 2 ) //... string s1 = "mathematics"; g ; string s2 = "math"; //... ::max(s1,s2); //max<s t r i n g >(s1 , s2 ) Vector<i n t > a r r a y i ( 1 0 ) ; r e t u r n 0 ; Vector<double> a r r a y d ( 1 0 0 ) ; g Substitution of type parameters during compile time: template instantation. C++ templates supports: functions, classes and member functions. Comp EOR LMCS. 10 / 47 Computational Model OOP & Generic Programming Dynamic polymorphism In C++ this is about the use of virtual functions. Virtual functions can introduce an overhead in run time: class Matrix f public: virtual double operator()(int i, int j); g ; class SymmetricMatrix : public Matrix f public: virtual double operator()(int i, int j); g ; class UpperTriangularMatrix : public Matrix f public: virtual double operator()(int i, int j); g ; //... double sum(Matrix &A) f double suma; for(int j = 0; j < A.cols(); ++j) for(int i = 0; i < A.cols(); ++i) suma += A(i ,j); return suma; g //... SymmetricMatrix A(N,N); double suma = sum(A); Comp EOR LMCS 11 / 47 Computational Model OOP & Generic Programming Engines class Symmetric f //... g ; class UpperTriangular f //... g ; template<c l a s s T engine> class Matrix f p r i v a t e : T engine engine; g ; template<c l a s s T engine> double sum(Matrix<T engine> &A) f //... g Matrix<Symmetric> A(N,N ) ; double suma = sum(A); Matrix is a template class with the T engine parameter. Symmetric and UpperTriangular are two different engines that hide the particular implementation for each kind of matrix. All engines must have the same set of operations. Comp EOR LMCS 12 / 47 Computational Model OOP & Generic Programming Curiosly Recurring Template Pattern (CRTP) [3] Also known as Barton & Nackman trick [2]. template<c l a s s T l e a f t y p e > class Matrix f p u b l i c : T leaftype& asLeaf() f return static c a s t <T l e a f t y p e &>(∗ t h i s ) ; g double operator()(int i, int j) f return asLeaf()(i ,j); g g ; class SymmetricMatrix : public Matrix<SymmetricMatrix > f //... g ; class UpperTriangularMatrix : public Matrix<UpperTriangularMatrix > f //... g ; template<c l a s s T l e a f t y p e > double sum(Matrix<T l e a f t y p e >&A); SymmetricMatrix A; double suma = sum(A); The base class takes as parameter the type of the derived class.
Load more

Recommended publications
  • Object-Oriented Programming in Scheme with First-Class Modules
    Ob jectOriented Programming in Scheme with FirstClass Mo dules and Op eratorBased Inheritance Guruduth Banavar Gary Lindstrom Department of Computer Science University of Utah Salt LakeCityUT Abstract Wecharacterize ob jectoriented programming as structuring and manipulating a uniform space of rstclass values representing modules a distillation of the notion of classes Op erators over mo dules individually achieve eects such as encapsulation sharing and static binding A variety of idioms of OO programming nd convenient expression within this mo del including several forms of single and multiple inheritance abstract classes class variables inheritance hierarchy combination and reection Weshow that this programming style simplies OO programming via enhanced uniformity and supp orts a exible mo del of ob jectorientation that provides an attractive alternative to metaprogramming Finallyweshow that these notions of OO programming are language indep endent by implementing a Mo dular Scheme prototyp e as a completion of a generic OO framework for mo dularity Pap er Category Research Topic Area Language design and implementation Intro duction Classbased ob jectoriented programming is usually thought of as creating a graph structured inher itance hierarchy of classes instantiating some of these classes and computing with these instances Instances are typically rstclass values in the language ie they can b e created stored accessed and passed into and out of functions Classes on the other hand are usually not rstclass values and inheritance is
    [Show full text]
  • Modular Programming with Functions
    CHAPTER 4 MODULAR PROGRAMMING WITH FUNCTIONS Copyright © 2013 Pearson Education, Inc. Modularity •A program may also contain other functions, and it may refer to functions in another file or in a library. These functions , or modules , are sets of statements that perform an operation or compute a value •To maintain simplicity and readability in long and complex programs, we use a short main, and other functions instead of using one long main function. •By separating a solution into a group of modules, each module is easier to understand, thus adhering to the basic guidelines of structured programming Copyright © 2013 Pearson Education, Inc. Modularity •Braking a problem into a set of modules has many advantages: 1. Every module can be written and tested separately from the rest of the program 2. A module is smaller than a complete program, so testing is easier 3. Once a module has been tested, it can be used in new program without having to retest it ( reusability ) 4. Use of modules ( modularity ) usually reduces the overall length of programs 5. Several programmers can work on the same project if it is separated into modules Copyright © 2013 Pearson Education, Inc. Modularity Main Modules Copyright © 2013 Pearson Education, Inc. Function Definition •A function consists of a definition statement followed by declarations and statements. The general form of a function is: return_type function_name(parameter_declarations) { declarations; statements; return expression; } •The parameter declarations represent the information passed to the function •Additional variables used by the function are defined in declarations statement •All functions should include a return statement Copyright © 2013 Pearson Education, Inc.
    [Show full text]
  • Scope in Fortran 90
    Scope in Fortran 90 The scope of objects (variables, named constants, subprograms) within a program is the portion of the program in which the object is visible (can be use and, if it is a variable, modified). It is important to understand the scope of objects not only so that we know where to define an object we wish to use, but also what portion of a program unit is effected when, for example, a variable is changed, and, what errors might occur when using identifiers declared in other program sections. Objects declared in a program unit (a main program section, module, or external subprogram) are visible throughout that program unit, including any internal subprograms it hosts. Such objects are said to be global. Objects are not visible between program units. This is illustrated in Figure 1. Figure 1: The figure shows three program units. Main program unit Main is a host to the internal function F1. The module program unit Mod is a host to internal function F2. The external subroutine Sub hosts internal function F3. Objects declared inside a program unit are global; they are visible anywhere in the program unit including in any internal subprograms that it hosts. Objects in one program unit are not visible in another program unit, for example variable X and function F3 are not visible to the module program unit Mod. Objects in the module Mod can be imported to the main program section via the USE statement, see later in this section. Data declared in an internal subprogram is only visible to that subprogram; i.e.
    [Show full text]
  • A Parallel Program Execution Model Supporting Modular Software Construction
    A Parallel Program Execution Model Supporting Modular Software Construction Jack B. Dennis Laboratory for Computer Science Massachusetts Institute of Technology Cambridge, MA 02139 U.S.A. [email protected] Abstract as a guide for computer system design—follows from basic requirements for supporting modular software construction. A watershed is near in the architecture of computer sys- The fundamental theme of this paper is: tems. There is overwhelming demand for systems that sup- port a universal format for computer programs and software The architecture of computer systems should components so users may benefit from their use on a wide reflect the requirements of the structure of pro- variety of computing platforms. At present this demand is grams. The programming interface provided being met by commodity microprocessors together with stan- should address software engineering issues, in dard operating system interfaces. However, current systems particular, the ability to practice the modular do not offer a standard API (application program interface) construction of software. for parallel programming, and the popular interfaces for parallel computing violate essential principles of modular The positions taken in this presentation are contrary to or component-based software construction. Moreover, mi- much conventional wisdom, so I have included a ques- croprocessor architecture is reaching the limit of what can tion/answer dialog at appropriate places to highlight points be done usefully within the framework of superscalar and of debate. We start with a discussion of the nature and VLIW processor models. The next step is to put several purpose of a program execution model. Our Parallelism processors (or the equivalent) on a single chip.
    [Show full text]
  • The Best of Both Worlds?
    The Best of Both Worlds? Reimplementing an Object-Oriented System with Functional Programming on the .NET Platform and Comparing the Two Paradigms Erik Bugge Thesis submitted for the degree of Master in Informatics: Programming and Networks 60 credits Department of Informatics Faculty of mathematics and natural sciences UNIVERSITY OF OSLO Autumn 2019 The Best of Both Worlds? Reimplementing an Object-Oriented System with Functional Programming on the .NET Platform and Comparing the Two Paradigms Erik Bugge © 2019 Erik Bugge The Best of Both Worlds? http://www.duo.uio.no/ Printed: Reprosentralen, University of Oslo Abstract Programming paradigms are categories that classify languages based on their features. Each paradigm category contains rules about how the program is built. Comparing programming paradigms and languages is important, because it lets developers make more informed decisions when it comes to choosing the right technology for a system. Making meaningful comparisons between paradigms and languages is challenging, because the subjects of comparison are often so dissimilar that the process is not always straightforward, or does not always yield particularly valuable results. Therefore, multiple avenues of comparison must be explored in order to get meaningful information about the pros and cons of these technologies. This thesis looks at the difference between the object-oriented and functional programming paradigms on a higher level, before delving in detail into a development process that consisted of reimplementing parts of an object- oriented system into functional code. Using results from major comparative studies, exploring high-level differences between the two paradigms’ tools for modular programming and general program decompositions, and looking at the development process described in detail in this thesis in light of the aforementioned findings, a comparison on multiple levels was done.
    [Show full text]
  • C++ Metastring Library and Its Applications⋆
    C++ Metastring Library and its Applications! Zal´anSz˝ugyi, Abel´ Sinkovics, Norbert Pataki, and Zolt´anPorkol´ab Department of Programming Languages and Compilers, E¨otv¨osLor´andUniversity P´azm´any P´eter s´et´any 1/C H-1117 Budapest, Hungary {lupin, abel, patakino, gsd}@elte.hu Abstract. C++ template metaprogramming is an emerging direction of generative programming: with proper template definitions wecanenforce the C++ compiler to execute algorithms at compilation time. Template metaprograms have become essential part of today’s C++ programs of industrial size; they provide code adoptions, various optimizations, DSL embedding, etc. Besides the compilation time algorithms, template metaprogram data-structures are particularly important. From simple typelists to more advanced STL-like data types there are a variety of such constructs. Interesting enough, until recently string, as one of the most widely used data type of programming, has not been supported. Al- though, boost::mpl::string is an advance in this area, it still lacks the most fundamental string operations. In this paper, we analysed the pos- sibilities of handling string objects at compilation time with a metastring library. We created a C++ template metaprogram library that provides the common string operations, like creating sub-strings, concatenation, replace, and similar. To provide real-life use-cases we implemented two applications on top of our Metastring library. One use case utilizes com- pilation time inspection of input in the domain of pattern matching al- gorithms, thus we are able to select the more optimal search method at compilation time. The other use-case implements safePrint, a type-safe version of printf –awidelyinvestigatedproblem.Wepresentboththe performance improvements and extended functionality we haveachieved in the applications of our Metastring library.
    [Show full text]
  • 13 Templates-Generics.Pdf
    CS 242 2012 Generic programming in OO Languages Reading Text: Sections 9.4.1 and 9.4.3 J Koskinen, Metaprogramming in C++, Sections 2 – 5 Gilad Bracha, Generics in the Java Programming Language Questions • If subtyping and inheritance are so great, why do we need type parameterization in object- oriented languages? • The great polymorphism debate – Subtype polymorphism • Apply f(Object x) to any y : C <: Object – Parametric polymorphism • Apply generic <T> f(T x) to any y : C Do these serve similar or different purposes? Outline • C++ Templates – Polymorphism vs Overloading – C++ Template specialization – Example: Standard Template Library (STL) – C++ Template metaprogramming • Java Generics – Subtyping versus generics – Static type checking for generics – Implementation of Java generics Polymorphism vs Overloading • Parametric polymorphism – Single algorithm may be given many types – Type variable may be replaced by any type – f :: tt => f :: IntInt, f :: BoolBool, ... • Overloading – A single symbol may refer to more than one algorithm – Each algorithm may have different type – Choice of algorithm determined by type context – Types of symbol may be arbitrarily different – + has types int*intint, real*realreal, ... Polymorphism: Haskell vs C++ • Haskell polymorphic function – Declarations (generally) require no type information – Type inference uses type variables – Type inference substitutes for variables as needed to instantiate polymorphic code • C++ function template – Programmer declares argument, result types of fctns – Programmers
    [Show full text]
  • Software Quality / Modularity
    Software quality EXTERNAL AND INTERNAL FACTORS External quality factors are properties such as speed or ease of use, whose presence or absence in a software product may be detected by its users. Other qualities applicable to a software product, such as being modular, or readable, are internal factors, perceptible only to computer professionals who have access to the actual software text. In the end, only external factors matter, but the key to achieving these external factors is in the internal ones: for the users to enjoy the visible qualities, the designers and implementers must have applied internal techniques that will ensure the hidden qualities. EXTERNAL FACTORS Correctness: The ability of software products to perform their tasks, as defined by their specification. Correctness is the prime quality. If a system does not do what it is supposed to do, everything else about it — whether it is fast, has a nice user interface¼ — matters little. But this is easier said than done. Even the first step to correctness is already difficult: we must be able to specify the system requirements in a precise form, by itself quite a challenging task. Robustness: The ability of software systems to react appropriately to abnormal conditions. Robustness complements correctness. Correctness addresses the behavior of a system in cases covered by its specification; robustness characterizes what happens outside of that specification. There will always be cases that the specification does not explicitly address. The role of the robustness requirement is to make sure that if such cases do arise, the system does not cause catastrophic events; it should produce appropriate error messages, terminate its execution cleanly, or enter a so-called “graceful degradation” mode.
    [Show full text]
  • Chapter-2 Object Oriented Programming Very Short/ Short Answer Questions 1
    CHAPTER-2 OBJECT ORIENTED PROGRAMMING VERY SHORT/ SHORT ANSWER QUESTIONS 1. Discuss major OOP concepts briefly. Ans. Following are the general OOP concepts: 1. Data Abstraction: Data abstraction means, providing only essential information to the outside word and hiding their background details i.e. to represent the needed information in program without presenting the details. 2. Data Encapsulation: The wrapping up of data and operations/functions (that operate o the data) into a single unit (called class) is known as Encapsulation. 3. Modularity: Modularity is the property of a system that has been decomposed into a set of cohesive and loosely coupled modules. 4. Inheritance: Inheritance is the capability of one class of things to inherit capabilities or properties from another class. 5. Polymorphism: Polymorphism is the ability for a message or data to be processed in more than one form. 2. What are programming paradigms? Give names of some popular programming paradigms. Ans. Programming Paradigm: A Programming Paradigm defines the methodology of designing and implementing programs using the key features and building blocks of a programming language. Following are the different programming paradigms: (i) Procedural Programming (ii) Object Based Programming (iii) Object Oriented Programming 3. What are the shortcomings of procedural and modular programming approaches? Ans. Following are the various shortcomings of procedural and modular programming approaches: Procedural Programming is susceptible to design changes. Procedural Programming leads to increased time and cost overheads during design changes. Procedural and Modular programming both are unable to represent real world relationship that exists among objects. In modular programming, the arrangement of the data can’t be changed without modifying all the functions that access it.
    [Show full text]
  • Modular Programming
    Modular Programming Prof. Clarkson Fall 2016 Today’s music: "Giorgio By Moroder" by Daft Punk Te Moog modular synthesizer Review Previously in 3110: • Functions, data • lots of language features • how to build small programs Today: • language features for building large programs: structures, signatures, modules Question What’s the largest program you’ve ever worked on, by yourself or as part of a team? A. 10-100 LoC B. 100-1,000 LoC C. 1,000-10,000 LoC D. 10,000-100,000 LoC E. 100,000 LoC or bigger Scale • My solution to A1: 100 LoC • My solution to A2: 300 LoC • OCaml: 200,000 LoC • Unreal engine 3: 2,000,000 LoC • Windows Vista: 50,000,000 LoC http://www.informationisbeautiful.net/visualizations/million-lines-of-code/ ...can’t be done by one person ...no individual programmer can understand all the details ...too complex to build with subset of OCaml we’ve seen so far Modularity Modular programming: code comprises independent modules – developed separately – understand behavior of module in isolation – reason locally, not globally Java features for modularity • classes, packages: organize identifiers (classes, methods, fields, etc.) into namespaces • interfaces: describe related classes • public, protected, private: control what is visible outside a namespace • subtyping, inheritance: enables code reuse OCaml features for modularity • structures: organize identifiers (functions, values, etc.) into namespaces • signatures: describe related modules • abstract types: control what is visible outside a namespace • functors, includes: enable
    [Show full text]
  • Functional Programming with C++ Template Metaprograms
    Functional Programming with C++ Template Metaprograms Zolt´an Porkol´ab E¨otv¨os Lor´and University, Faculty of Informatics Dept. of Programming Languages and Compilers P´azm´any P´eter s´et´any 1/C H-1117 Budapest, Hungary [email protected] Abstract. Template metaprogramming is an emerging new direction of generative programming: with the clever definitions of templates we can enforce the C++ compiler to execute algorithms at compilation time. Among the application areas of template metaprograms are the expres- sion templates, static interface checking, code optimization with adap- tion, language embedding and active libraries. However, as this feature of C++ was not an original design goal, the language is not capable of elegant expression of template metaprograms. The complicated syn- tax leads to the creation of code that is hard to write, understand and maintain. Despite that template metaprogramming has a strong rela- tionship with functional programming paradigm, language syntax and the existing libraries do not follow these requirements. In this paper we give a short and incomplete introduction to C++ templates and the ba- sics of template metaprogramming. We will enlight the role of template metaprograms, some important and widely used idioms and techniques. 1 Introduction Templates are key elements of the C++ programming language [3, 32]. They enable data structures and algorithms to be parameterized by types, thus cap- turing commonalities of abstractions at compilation time without performance penalties at runtime [37]. Generic programming [28, 27, 17] is a recently popu- lar programming paradigm, which enables the developer to implement reusable codes easily. Reusable components { in most cases data structures and algo- rithms { are implemented in C++ with the heavy use of templates.
    [Show full text]
  • Modularity and Reuse of Domain-Specific Languages
    Modularity and reuse of domain-specific languages Citation for published version (APA): Sutii, A. M. (2017). Modularity and reuse of domain-specific languages: an exploration with MetaMod. Technische Universiteit Eindhoven. Document status and date: Published: 07/11/2017 Document Version: Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers) Please check the document version of this publication: • A submitted manuscript is the version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher's website. • The final author version and the galley proof are versions of the publication after peer review. • The final published version features the final layout of the paper including the volume, issue and page numbers. Link to publication General rights Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain • You may freely distribute the URL identifying the publication in the public portal. If the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement: www.tue.nl/taverne Take down policy If you believe that this document breaches copyright please contact us at: [email protected] providing details and we will investigate your claim.
    [Show full text]