Dissertations / Theses on the topic 'BPEL (Computer program language) Programming languages (Electronic computers)'

A concurrent program is one in which a number of processes are considered to be active simultaneously . It is possib l e to t hink of a process as being a separate sequential program executing independently of other processes, although perhaps communicating with them at desired pOints . The concurrent program, as a whole, can be executed in one of two ways: il ii) in true concurrent manner, wi th each process executing on a dedicated processor in a quasi - concurrent manner, where a processor's processes . time is multiplexed between single the There are two motivations for the study of concurrency in programming languages : i) concurrent programming facilities can be exploited in systems where one has more t han one processor . As technology i mproves, machines having multiple processors will proliferate ii) concurrent p r ogramming facilities may allow programs to be structured as independent , bu t co - operating, processes which can then be implemented on a single processor system . This structure may be more natural to the programmer then the traditional sequential structures. An example is provided by Conway's - 1- Clearly, languages Pascal) problem [Ben82] . by their very nature, traditional sequential- type (Fortran, Basic, Cobol and earlier versions of prove inadequate for the purposes of concurrent programming without considerable extension (which some manufacturers have provided, rendering their compilers non standard-conforming). The general convenience of high level languages provides strong motivation for their development for rea l time programming. Modula - 2 [Wir83] is but one of a number of such r ecently developed languages, designed not only to fulfil a "sequential" role but also to offer facilities for concurrent programming. Developed by Niklaus Wirth in 1979 as a successor to Pascal and Modula, it is intended to serve under the banner of a generalpurpose systems - implementation language. This thesis investigates concurrency i n Modula - 2 and takes the following form: i ) an analYSis of the concurrent facilities offered ii) problems and difficulties associated with these facilities iii) improveme nts and enhancements, including the feasibility of using Modula - 2 to simulate constructs found in other languages, such as the Hoare monitor [Hoa74] and the Ada rendezvous [Uni81]. - 2- Each section concludes with an appraisal of the work conducted in that section . The final section consists of a critical assessment of those Modula - 2 language constructs and facilities provided for the implementation of concurrency and a brief look at concurrency in Modula, Modula-2's predecessor. - Introduction.
KMBT_363
Adobe Acrobat 9.53 Paper Capture Plug-in

This thesis presents Lighthouse, an experimental branch of the Haskell-based House operating system which integrates Li et al.'s Lightweight Concurrency framework. First and foremost, it improves House's viability as a "real operating system" by providing a new extensible scheduler framework which makes it easy to experiment with different scheduling policies. In particular, Lighthouse extends Concurrent Haskell with thread priority and implements a priority-based scheduler which significantly improves system responsiveness when compared with GHC's normal round-robin scheduler. Even while doing this, it improves on House's claim of being "written in Haskell" by moving a whole subsystem out of the complex C-based runtime system and into Haskell itself. In addition, Lighthouse also includes an alternate, simpler implementation of Lightweight Concurrency which takes advantage of House's unique setting (running directly on uniprocessor x86 hardware). This experience sheds light on areas that need further attention before the system can truly be viable---primarily interactions between blackholing and interrupt handling. In particular, this thesis uncovers a potential case of self-deadlock and suggests potential solutions. Finally, this work offers further insight into the viability of using high-level languages such as Haskell for systems programming. Although laziness and blackholing present unique problems, many parts of the system are still much easier to express in Haskell than traditional languages such as C.

Thesis (Ph. D.)--University of Oregon, 2004.
Typescript. Includes vita and abstract. Includes bibliographical references (leaves 152-155). Also available for download via the World Wide Web; free to University of Oregon users.

Thesis (Ph.D.) - University of Glasgow, 2007.
Ph.D. thesis submitted to the Department of Computing Science, Faculty of Information and Mathematical Sciences, University of Glasgow, 2007. Includes bibliographical references. Print version also available.

This study aims to design and implement a domain-specific computer programming language: the Building Environment Rule and Analysis (BERA) Language. As a result of the growing area of Building Information Modeling (BIM), there has been a need to develop highly customized domain-specific programming languages for handling issues in building models in the architecture, engineering and construction (AEC) industry. The BERA Language attempts to deal with building information models in an intuitive way in order to define and analyze rules in design stages. The application of the BERA Language aims to provide efficiency in defining, analyzing and checking rules. Specific example applications implemented in this dissertation are on the evaluation of two key aspects: building circulation and spatial programming. The objective of this study is to accomplish an effectiveness and ease of use without precise knowledge of general-purpose languages that are conventionally used in BIM software development. To achieve the goal, this study proposes an abstraction of the universe of discourse - it is the BERA Object Model (BOM). It is a human-centered abstraction of complex state of building models rather than the computation-oriented abstraction. By using BOM, users can enjoy the ease of use and portability of BIM data, rather than complex and platform-dependent data structures. This study also has reviewed and demonstrated its potential for extensibility of BOM. Not only its lateral extensions such as structural building elements, but also the vertical extensions such as additional properties for existing BOM objects are good examples. In current BERA Language Tool, many computed and derived properties/relations have been proposed and implemented, as well as some basic data directly from the given building model. Target users of the BERA Language are domain experts such as architects, designers, reviewers, owners, managers, students, etc., rather than BIM software developers. It means that the people who are interested in the building environment rule and analysis are the potential users. The BERA Language Tool comprises many libraries to alleviate common but unnecessary problems and limitations that are encountered when users attempt to analyze and evaluate building models using commercially available tools. Combined with other libraries which populate rich and domain-specific datasets for certain purposes, the BERA Language will be fairly versatile to define rules and analyze various building environmental conditions.

Atuais paradigmas correntes de programação de software, mais precisamente o Paradigma Imperativo (PI) e o Paradigma Declarativo (PD), apresentam deficiências que afetam o desempenho das aplicações e a obtenção de “desacoplamento” (ou acoplamento mínimo) entre elementos de software. Com o objetivo de amenizar essas deficiências, foi desenvolvido o Paradigma Orientado a Notificações (PON). O PON se inspira nos conceitos do PI (e.g. objetos) e do PD (e.g. base de fatos e regras), mas altera a essência da execução ou inferência lógica-causal. Basicamente, o PON usa objetos para tratar de fatos e regras na forma de composições de outros objetos menores que, entretanto, apresentam características comportamentais de certa autonomia, independência, reatividade e colaboração por meio de notificações pontuais para fins de inferência. Isto dito, salienta-se que a materialização dos conceitos do PON se deu por meio de um arquétipo ou Framework elaborado em linguagem de programação C++. Tal materialização do PON vem sendo utilizada como uma alternativa para o desenvolvimento de aplicações sob o domínio desse paradigma e possibilitou, de fato, a criação de aplicações para ambientes computacionais usuais baseados na chamada arquitetura Von Neumann. Apesar destas contribuições para com a sua materialização, o desenvolvimento de aplicações no PON ainda não apresentava resultados satisfatórios em termos de desempenho tal qual deveria a luz do seu cálculo assintótico, nem a facilidade de programação que seria uma das suas características principais. Nesse âmbito, o presente trabalho propõe como evolução para o estado da técnica do PON a criação de uma linguagem e compilador para o paradigma. Sendo assim, este trabalho apresenta a definição da linguagem criada com a utilização de exemplos práticos guiados pelo desenvolvimento de aplicações. Subsequentemente são apresentados detalhes do compilador bem como sua estrutura. Para demonstrar a evolução do estado da técnica do paradigma, no tocante a desempenho (e.g. tempo de processamento) e facilidade de programação foram realizados estudos comparativos com a utilização da linguagem e compilador. Os estudos comparativos foram guiados com a elaboração de dois softwares denominados aplicação Mira ao Alvo e aplicação de Vendas. Essas aplicações foram desenvolvidas com base na linguagem PON e foram realizados experimentos simulando sequências de execução com o intuito de avaliar o tempo de processamento para o resultado gerado pelo compilador PON. Ainda, tais experimentos possibilitaram a avaliação de maneira subjetiva da linguagem de programação PON no tocante a facilidade de programação. Deste modo, foi possível observar com tais estudos comparativos que os resultados apresentados pelo compilador PON foram satisfatórios quando comparados aos resultados obtidos pelo Framework e por aplicações equivalentes desenvolvidas baseadas no Paradigma Orientado a Objetos (POO).
The current software development paradigms, specifically the Imperative Paradigm (IP) and the Declarative Paradigm (DP), have weaknesses that affect the applications performance and decoupling (or minimal coupling) between the software modules. In order to provide a solution regarding these weaknesses, the Notification Oriented Paradigm (NOP) was developed. NOP is inspired by the concepts of the IP (e.g. objects) and DP (e.g. base of facts and Rules). Basically, NOP uses objects to deal with facts and Rules as compositions of other, smaller, objects. These objects have the following behavioral characteristics: autonomy, independence, responsiveness and collaboration through notifications. Thus, it’s highlighted that the realization of these concepts was firstly instantiated through a Framework developed in C++. Such NOP materialization has been used as an alternative for Application development in the domain of this paradigm and made possible, in fact, the creation of applications for typical computing environments based on Von Neumann architecture. The development of the C++ materialization of NOP has not presented satisfactory results in terms of performance as it should when taking into account its asymptotic calculation and programming facility. In this context, this work presents an evolution of NOP by creating a specific programming language, and its respective compiler, for this paradigm. Therefore, this work presents the language definition and the details of the development of its compiler. To evaluate the evolution regarding to performance (e.g. processing time) and programming facility, some comparative studies using the NOP language and compiler are presented. These comparative studies were performed by developing two software applications called Target and Sales Application. These applications have been developed based on NOP language, and the experiments were performed simulating sequences of execution in order to evaluate the processing time for the generated results by NOP compiler. Still, these experiments allowed the evaluation of NOP programming language, in a subjective way, regarding to ease programming. Thus, with such comparative studies, it was possible to observe that the results presented by the compiler NOP were satisfactory when compared to the results achieved via Framework and for equivalent applications developed based on the Oriented Object Paradigm (OOP).

Este trabalho trata do tema de Paradigma Orientado a Notificações (PON) e sua adequação para prover suporte a conceitos fuzzy. O PON se inspira em elementos dos paradigmas imperativo e declarativo, buscando resolver inconvenientes de ambos. Ao decompor uma aplicação em uma rede de entidades computacionais menores que são executadas apenas quando necessário, o PON elimina a necessidade de realizar computações desnecessárias e alcança melhor desacoplamento lógico-causal facilitando o reaproveitamento e distribuição. Ademais, o PON permite expressar o seu conhecimento lógico-causal em alto nível, por meio de regras no formato SE-ENTÃO. Os sistemas fuzzy, por sua vez, realizam inferências em bases de conhecimento lógico-causal (regras SE-ENTÃO) que lidam com problemas que envolvem imprecisão. Uma vez que o PON utiliza regras SE-ENTÃO de uma forma alternativa, reduzindo avaliações redundantes e acoplamento, este trabalho foi realizado para identificar, propor e avaliar as mudanças necessárias a serem realizadas sobre o PON para que este possa ser utilizado no desenvolvimento de sistemas fuzzy. Após a realização da proposta, foram criadas materializações na forma de um framework em linguagem C++, e uma linguagem de programação própria (LingPONFuzzy) com suporte a inferência fuzzy. A partir delas foram criados casos de estudo e realizados diversos testes para validar a solução proposta. Os resultados dos testes mostram uma redução significativa no número de regras avaliadas em relação a um sistema fuzzy desenvolvido utilizando ferramentas convencionais (frameworks), o que poderia representar uma melhoria no desempenho das aplicações.
This work proposes to adjust the Notification Oriented Paradigm (NOP) so that it provides support to fuzzy concepts. NOP is inspired by elements of imperative and declarative paradigms, seeking to solve some of the drawbacks of both. By decomposing an application into a network of smaller computational entities that are executed only when necessary, NOP eliminates the need to perform unnecessary computations and helps to achieve better logical-causal uncoupling, facilitating code reuse and application distribution over multiple processors or machines. In addition, NOP allows to express the logical-causal knowledge at a high level of abstraction, through rules in IF-THEN format. Fuzzy systems, in turn, perform logical inferences on causal knowledge bases (IF-THEN rules) that can deal with problems involving uncertainty. Since PON uses IF-THEN rules in an alternative way, reducing redundant evaluations and providing better decoupling, this research has been carried out to identify, propose and evaluate the necessary changes to be made on NOP allowing to be used in the development of fuzzy systems. After that, two fully usable materializations were created: a C++ framework, and a complete programming language (LingPONFuzzy) that provide support to fuzzy inference systems. From there study cases have been created and several tests cases were conducted, in order to validate the proposed solution. The test results have shown a significant reduction in the number of rules evaluated in comparison to a fuzzy system developed using conventional tools (frameworks), which could represent an improvement in performance of the applications.

Thesis (M.Sc.)--York University, 2005. Graduate Programme in Computer Science.
Typescript. Includes bibliographical references (leaves 190-198). Also available on the Internet. MODE OF ACCESS via web browser by entering the following URL: http://gateway.proquest.com/openurl?url%5Fver=Z39.88-2004&res%5Fdat=xri:pqdiss &rft_val_fmt=info:ofi/fmt:kev:mtx:dissertation&rft_dat=xri:pqdiss:MR11816

by Chat Siu Wing.
Thesis (M.Phil.)--Chinese University of Hong Kong, 1990.
Bibliography: leaves 104-107.
ABSTRACT --- p.i
ACKNOWLEDGEMENTS --- p.ii
TABLE OF CONTENTS --- p.iii
Chapter CHAPTER 1 --- INTRODUCTION --- p.1
Chapter CHAPTER 2 --- TEMPORAL DATABASES --- p.5
Chapter 2.1 --- The Importance of Temporal Data --- p.5
Chapter 2.2 --- Incorporating Time in Databases --- p.6
Chapter 2.2.1 --- Time Dimensions --- p.6
Chapter 2.2.2 --- Classification --- p.6
Chapter 2.2.2.1 --- Snapshot Databases --- p.6
Chapter 2.2.2.2 --- Rollback Databases --- p.7
Chapter 2.2.2.3 --- Historical Databases --- p.8
Chapter 2.2.2.4 --- Temporal Databases --- p.9
Chapter 2.2.3 --- Current Research Areas --- p.9
Chapter 2.2.3.1 --- Time Semantics at the Conceptual Level --- p.10
Chapter 2.2.3.2 --- Temporal Data Model --- p.11
Chapter 2.2.3.3 --- Temporal Query Language --- p.11
Chapter CHAPTER 3 --- CONCEPTUAL TEMPORAL DATA MODELING …… --- p.13
Chapter 3.1 --- The Time Generic --- p.13
Chapter 3.1.1 --- Time Unit --- p.14
Chapter 3.1.2 --- Interval --- p.15
Chapter 3.1.3 --- Periodic Time --- p.16
Chapter 3.1.4 --- Time Point --- p.17
Chapter 3.2 --- Extended Entity Relationship (EER) Model --- p.17
Chapter 3.2.1 --- Attribute --- p.18
Chapter 3.2.2 --- Entity --- p.22
Chapter 3.2.3 --- Relationship --- p.23
Chapter 3.2.4 --- Event --- p.23
Chapter 3.3 --- EER Modeling of Temporal Data --- p.25
Chapter 3.3.1 --- Classify entities and attributes --- p.25
Chapter 3.3.2 --- Define events --- p.26
Chapter 3.3.3 --- Define relationships --- p.27
Chapter 3.3.4 --- Classify Attributes --- p.27
Chapter CHAPTER 4 --- LOGICAL TEMPORAL DATABASE DESIGN --- p.28
Chapter 4.1 --- Embedding a Temporal Relation into a Snapshot Relation --- p.28
Chapter 4.2 --- The Proposed Temporal Relational Model --- p.29
Chapter 4.2.1 --- Extension to Relational Model --- p.30
Chapter 4.2.2 --- Extended Properties --- p.31
Chapter 4.2.3 --- Extended Information Contents --- p.32
Chapter 4.2.3.1 --- Different Temporal Information --- p.32
Chapter 4.2.3.2 --- Retroactive and Postactive Recording --- p.33
Chapter 4.2.3.3 --- Multiple Values at an Instant --- p.33
Chapter 4.2.3.4 --- Discrete Valid Intervals --- p.34
Chapter 4.2.4 --- Data Manipulation --- p.34
Chapter 4.2.4.1 --- Retrieval --- p.35
Chapter 4.2.4.2 --- Updating --- p.36
Chapter 4.2.5 --- Probable Undesirable Properties --- p.37
Chapter 4.2.5.1 --- Redundancy --- p.37
Chapter 4.2.5.2 --- Update Anomalies --- p.39
Chapter 4.2.5.3 --- Retrieval Anomalies --- p.39
Chapter 4.3 --- Mapping Conceptual to Temporal Relational Model --- p.40
Chapter 4.3.1 --- Relations For the Time Generic --- p.40
Chapter 4.3.1.1 --- Interval --- p.40
Chapter 4.3.1.2 --- Time Point --- p.41
Chapter 4.3.1.3 --- Periodic Time --- p.42
Chapter 4.3.2 --- Mapping History into Time Attributes --- p.42
Chapter 4.3.2.1 --- Attribute History --- p.42
Chapter 4.3.2.2 --- Existence History --- p.43
Chapter 4.3.3 --- Mapping Entity Type --- p.43
Chapter 4.3.3.1 --- Strong Entity --- p.43
Chapter 4.3.3.2 --- Weak Entity --- p.46
Chapter 4.3.3.3 --- Temporally Weak Entity --- p.46
Chapter 4.3.4 --- Mapping Event Type --- p.46
Chapter 4.3.5 --- Mapping Relationship Type --- p.48
Chapter 4.4 --- Joining Synchronous Relations --- p.49
Chapter 4.5 --- Integrity Constraints --- p.50
Chapter 4.5.1 --- Creation --- p.51
Chapter 4.5.2 --- Deletion --- p.51
Chapter 4.5.3 --- Modification of Past States --- p.52
Chapter CHAPTER 5 --- A TEMPORAL QUERY LANGUAGE - TempSQL --- p.53
Chapter 5.1 --- New Statements --- p.53
Chapter 5.2 --- New Constructs in Statements --- p.54
Chapter 5.2.1 --- Temporal Operators --- p.54
Chapter 5.2.2 --- Temporal Comparison Operators --- p.55
Chapter 5.2.3 --- WHEN Clause --- p.56
Chapter 5.2.4 --- AS OF clause --- p.58
Chapter 5.2.5 --- VALID clause --- p.58
Chapter 5.2.6 --- A General Example --- p.60
Chapter 5.3 --- Semantics of TempSQL Statements --- p.61
Chapter 5.3.1 --- SELECT --- p.62
Chapter 5.3.2 --- INSERT --- p.64
Chapter 5.3.3 --- DISCARD --- p.66
Chapter 5.3.4 --- UPDATE --- p.68
Chapter CHAPTER 6 --- IMPLEMENTATION OF TempSQL --- p.78
Chapter 6.1 --- The Underlying Environment --- p.78
Chapter 6.2 --- The Preprocessor --- p.79
Chapter 6.3 --- The Interactive Interpreter --- p.81
Chapter 6.4 --- Limitations --- p.82
Chapter CHAPTER 7 --- AN EXAMPLE TEMPORAL DATABASE --- p.84
Chapter 7.1 --- The Scenario --- p.84
Chapter 7.2 --- EER modeling of data --- p.84
Chapter 7.3 --- Transformation into Temporal Relations --- p.85
Chapter 7.4 --- Joining Synchronous Relations --- p.87
Chapter 7.5 --- Sample Queries --- p.87
Chapter 7.6 --- Remarks --- p.91
Chapter CHAPTER 8 --- CONCLUSION AND FUTURE RESEARCH
DIRECTIONS --- p.94
Chapter APPENDIX A --- BNF of TempSQL --- p.100
REFERENCES --- p.104

Thesis (Ph. D.)--Florida State University, 2003.
Advisor: Dr. Gordon Erlebacher, Florida State University, College of Arts and Sciences, Dept. of Computer Science. Title and description from dissertation home page (viewed Apr. 8, 2004). Includes bibliographical references.

Thesis (M.Tech.: Computer Studies)-Dept. of Computer Science, Durban Institute of Technology, 2002.
Computer programming has been a science for approximately 50 years. It this time there havebeen two major paradigm shifts that have taken place. The first was from “spaghetti code” to structured programs. The second paradigm shift is from procedural programs to object oriented programs. The change in paradigm involves a change in the way in which a problem is approached, can be solved, as well as a difference in the language that is used. The languages that were chosen to be studied, are COBOL and Java. These programming languages were identified as key languages, and the languages that software development are the most reliant on. COBOL, the procedural language for existing business systems, and Java the object oriented language, the most likely to be used for future development. To complete this study, both languages were studied in detail. The similarities and differences between the programming languages are discussed. Some key issues that a COBOL programmer has to keep in mind when moving to Java were identified.