To see the other types of publications on this topic, follow the link: Functional computer language.
Dissertations / Theses on the topic 'Functional computer language'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Functional computer language.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Grattage, Jonathan James. "A functional quantum programming language." Thesis, University of Nottingham, 2006. http://eprints.nottingham.ac.uk/10250/.
Full textAbstract:
This thesis introduces the language QML, a functional language for quantum computations on finite types. QML exhibits quantum data and control structures, and integrates reversible and irreversible quantum computations. The design of QML is guided by the categorical semantics: QML programs are interpreted by morphisms in the category FQC of finite quantum computations, which provides a constructive operational semantics of irreversible quantum computations, realisable as quantum circuits. The quantum circuit model is also given a formal categorical definition via the category FQC. QML integrates reversible and irreversible quantum computations in one language, using first order strict linear logic to make weakenings, which may lead to the collapse of the quantum wavefunction, explicit. Strict programs are free from measurement, and hence preserve superpositions and entanglement. A denotational semantics of QML programs is presented, which maps QML terms into superoperators, via the operational semantics, made precise by the category Q. Extensional equality for QML programs is also presented, via a mapping from FQC morphisms into the category Q.
2
Svallfors, Hugo. "Sard: An Object-Functional Programming Language." Thesis, Umeå universitet, Institutionen för datavetenskap, 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:umu:diva-51276.
Full textAbstract:
This bachelor's degree concerns the specification of a new programming language. This language, called Sard, is a backwards-incompatible new version of the existing language Scala. Sard, like Scala, is a high-level object-functional language. Unlike Scala, it is not very closely tied to the JVM or Java, eliminating some constraints on the language's design. Since this necessitates breaking backwards compatibility with Scala, the opportunity to disregard it is used to x some of the author's irritations with the language. This degree mostly focuses on deciding on the exact changes to Scala, and on the overall design, rather than on implementing a compiler for the language. A reason for this is that the bachelor's degree provides insuficient time to properly implement´and debug a compiler. Another is the desirability of pushing changes to the language as early into the design process as possible. Preferably, almost all changes to the language should occur before any compiler code has been written. The design eventually produced gets rid of some known issues stemming from the JVM, like null pointers, non-reified generics and single inheritance. Several features of Scala, like self-type annotations and in x syntax for methods are scrapped. Others, like pattern matching, are generalized. Some changes to the syntax are also made, particularly in the areas of closures, pattern matching and object construction. As of yet, this language has no implementation, and in future work, this must be rectified. Sard also requires calling compatibility with another programming language, but this remains to be specified. Nevertheless, Sard constitutes a promising refinement of an already great programming language, and it is hoped that Sard will x the few remaining issues with Scala's design.
3
Green, Alexander S. "Towards a formally verified functional quantum programming language." Thesis, University of Nottingham, 2010. http://eprints.nottingham.ac.uk/11457/.
Full textAbstract:
This thesis looks at the development of a framework for a functional quantum programming language. The framework is first developed in Haskell, looking at how a monadic structure can be used to explicitly deal with the side-effects inherent in the measurement of quantum systems, and goes on to look at how a dependently-typed reimplementation in Agda gives us the basis for a formally verified quantum programming language. The two implementations are not in themselves fully developed quantum programming languages, as they are embedded in their respective parent languages, but are a major step towards the development of a full formally verified, functional quantum programming language. Dubbed the “Quantum IO Monad”, this framework is designed following a structural approach as given by a categorical model of quantum computation.
4
Finnie, Sigbjorn O. "Composing graphical user interfaces in a purely functional language." Thesis, University of Glasgow, 1998. http://theses.gla.ac.uk/1597/.
Full textAbstract:
This thesis is about building interactive graphical user interfaces in a compositional manner. Graphical user interface application hold out the promise of providing users with an interactive, graphical medium by which they can carry out tasks more effectively and conveniently. The application aids the user to solve some task. Conceptually, the user is in charge of the graphical medium, controlling the order and the rate at which individual actions are performed. This user-centred nature of graphical user interfaces has considerable ramifications for how software is structured. Since the application now services the user rather than the other way around, it has to be capable of responding to the user's actions when and in whatever order they might occur. This transfer of overall control towards the user places heavy burden on programming systems, a burden that many systems don't support too well. Why? Because the application now has to be structured so that it is responsive to whatever action the user may perform at any time. The main contribution of this thesis is to present a compositional approach to constructing graphical user interface applications in a purely functional programming language The thesis is concerned with the software techniques used to program graphical user interface applications, and not directly with their design. A starting point for the work presented here was to examine whether an approach based on functional programming could improve how graphical user interfaces are built. Functional programming languages, and Haskell in particular, contain a number of distinctive features such as higher-order functions, polymorphic type systems, lazy evaluation, and systematic overloading, that together pack quite a punch, at least according to proponents of these languages. A secondary contribution of this thesis is to present a compositional user interface framework called Haggis, which makes good use of current functional programming techniques. The thesis evaluates the properties of this framework by comparing it to existing systems.
5
Germain, Renaud. "Implementation of a dependently typed functional programming language." Thesis, McGill University, 2010. http://digitool.Library.McGill.CA:8881/R/?func=dbin-jump-full&object_id=92350.
Full text
6
Lee, Jinho. "Architecture for a low-level functional specification language supporting multimodeling and simulation." [Gainesville, Fla.] : University of Florida, 2005. http://purl.fcla.edu/fcla/etd/UFE0011609.
Full text
7
Junaidu, Sahalu B. "A parallel functional language compiler for message-passing multicomputers." Thesis, University of St Andrews, 1998. http://hdl.handle.net/10023/13450.
Full textAbstract:
The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's 7r-calculus which achieves asynchronous communication. We present the first working implementation of this scheme on distributed-memory message-passing multicomputers with split-phase transactions. Simulated assessment of the generated parallel code indicates good parallel behaviour. Parallelism is introduced using explicit, advisory user annotations in the source' program and there are two major aspects of the use of annotations in the compiler. First, the front end of the compiler is parallelised so as to improve its efficiency at compilation time when it is compiling input programs. Secondly, the input programs to the compiler can themselves contain annotations based on which the compiler generates the multi-threaded parallel code. These, therefore, make Naira, unusually and uniquely, both a parallel and a parallelising compiler. We adopt a medium-grained approach to granularity where function applications form the unit of parallelism and load distribution. We have experimented with two different task distribution strategies, deterministic and random, and have also experimented with thread-based and quantum- based scheduling policies. Our experiments show that there is little efficiency difference for regular programs but the quantum-based scheduler is the best in programs with irregular parallelism. The compiler has been successfully built, parallelised and assessed using both idealised and realistic measurement tools: we obtained significant compilation speed-ups on a variety of simulated parallel architectures. The simulated results are supported by the best results obtained on real hardware for such a large program: we measured an absolute speedup of 2.5 on a network of 5 SUN workstations. The compiler has also been shown to have good parallelising potential, based on popular test programs. Results of assessing Naira's generated unoptimised parallel code are comparable to those produced by other successful parallel implementation projects.
8
Valiron, Benoit. "A functional programming language for quantum computation with classical control." Thesis, University of Ottawa (Canada), 2004. http://hdl.handle.net/10393/26790.
Full textAbstract:
The objective of this thesis is to develop a functional programming language for quantum computers based on the QRAM model, following the work of P. Selinger (2004) on quantum flow-charts. We construct a lambda-calculus without side-effects to deal with quantum bits. We equip this calculus with a probabilistic call-by-value operational semantics. Since quantum information cannot be duplicated due to the no-cloning property, we need a resource-sensitive type system. We develop it based on affine intuitionistic linear logic. Unlike the quantum lambda-calculus proposed by Van Tonder (2003, 2004), the resulting lambda-calculus has only one lambda-abstraction, linear and non-linear abstractions being encoded in the type system. We also integrate classical and quantum data types within our language. The main results of this work are the subject-reduction of the language and the construction of a type inference algorithm.
9
Harrison, Dave. "Functional real-time programming : the language Ruth and its semantics." Thesis, University of Stirling, 1988. http://hdl.handle.net/1893/12116.
Full textAbstract:
Real-time systems are amongst the most safety critical systems involving computer software and the incorrect functioning of this software can cause great damage, up to and including the loss of life. If seems sensible therefore to write real-time software in a way that gives us the best chance of correctly implementing specifications. Because of the high level of functional programming languages, their semantic simplicity and their amenability to formal reasoning and correctness preserving transformation it thus seems natural to use a functional language for this task. This thesis explores the problems of applying functional programming languages to real-time by defining the real-time functional programming language Ruth. The first part of the thesis concerns the identification of the particular problems associated with programming real-time systems. These can broadly be stated as a requirement that a real-time language must be able to express facts about time, a feature we have called time expressibility. The next stage is to provide time expressibility within a purely functional framework. This is accomplished by the use of timestamps on inputs and outputs and by providing a real-time clock as an input to Ruth programs. The final major part of the work is the construction of a formal definition of the semantics of Ruth to serve as a basis for formal reasoning and transformation. The framework within which the formal semantics of a real-time language are defined requires time expressibility in the same way as the real-time language itself. This is accomplished within the framework of domain theory by the use of specialised domains for timestamped objects, called herring-bone domains. These domains could be used as the basis for the definition of the semantics of any real-time language.
10
Erkök, Levent. "Value recursion in monadic computations /." Full text open access at:, 2002. http://content.ohsu.edu/u?/etd,270.
Full text
11
Meredith, Paul Francis. "A functional programming language which integrates queries and updates for managing an entity-function database." Thesis, Birkbeck (University of London), 1999. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.313819.
Full text
12
Gaconnet, Christopher James. "Force-Directed Graph Drawing and Aesthetics Measurement in a Non-Strict Pure Functional Programming Language." Thesis, University of North Texas, 2009. https://digital.library.unt.edu/ark:/67531/metadc12125/.
Full textAbstract:
Non-strict pure functional programming often requires redesigning algorithms and data structures to work more effectively under new constraints of non-strict evaluation and immutable state. Graph drawing algorithms, while numerous and broadly studied, have no presence in the non-strict pure functional programming model. Additionally, there is currently no freely licensed standalone toolkit used to quantitatively analyze aesthetics of graph drawings. This thesis addresses two previously unexplored questions. Can a force-directed graph drawing algorithm be implemented in a non-strict functional language, such as Haskell, and still be practically usable? Can an easily extensible aesthetic measuring tool be implemented in a language such as Haskell and still be practically usable? The focus of the thesis is on implementing one of the simplest force-directed algorithms, that of Fruchterman and Reingold, and comparing its resulting aesthetics to those of a well-known C++ implementation of the same algorithm.
13
Douglas, Andrew. "A compiled functional language with a Martin-Lof type system." Thesis, University of Kent, 1996. https://kar.kent.ac.uk/21348/.
Full text
14
Gupta, Shail Aditya. "Functional encapsulation and type reconstruction in a strongly-typed, polymorphic language." Thesis, Massachusetts Institute of Technology, 1995. http://hdl.handle.net/1721.1/36950.
Full textAbstract:
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1995.Includes bibliographical references (p. 181-186).
by Shail Aditya Gupta.
Ph.D.
15
Gaconnet, Christopher James Tarau Paul. "Force-directed graph drawing and aesthetics measurement in a non-strict pure functional programming language." [Denton, Tex.] : University of North Texas, 2009. http://digital.library.unt.edu/ark:/67531/metadc12125.
Full text
16
Morris, John Garrett. "Type Classes and Instance Chains: A Relational Approach." PDXScholar, 2013. https://pdxscholar.library.pdx.edu/open_access_etds/1010.
Full textAbstract:
Type classes, first proposed during the design of the Haskell programming language, extend standard type systems to support overloaded functions. Since their introduction, type classes have been used to address a range of problems, from typing ordering and arithmetic operators to describing heterogeneous lists and limited subtyping. However, while type class programming is useful for a variety of practical problems, its wider use is limited by the inexpressiveness and hidden complexity of current mechanisms. We propose two improvements to existing class systems. First, we introduce several novel language features, instance chains and explicit failure, that increase the expressiveness of type classes while providing more direct expression of current idioms. To validate these features, we have built an implementation of these features, demonstrating their use in a practical setting and their integration with type reconstruction for a Hindley-Milner type system. Second, we define a set-based semantics for type classes that provides a sound basis for reasoning about type class systems, their implementations, and the meanings of programs that use them.
17
Cupitt, John R. G. "The design and implementation of an operating system in a functional language." Thesis, University of Kent, 1989. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.257007.
Full text
18
Shah, Hanifa Unisa. "The implementation of a functional query language front-end to a relational database system." Thesis, Aston University, 1989. http://publications.aston.ac.uk/10652/.
Full textAbstract:
Database systems have a user interface one of the components of which will normally be a query language which is based on a particular data model. Typically data models provide primitives to define, manipulate and query databases. Often these primitives are designed to form self-contained query languages. This thesis describes a prototype implementation of a system which allows users to specify queries against the database in a query language whose primitives are not those provided by the actual model on which the database system is based, but those provided by a different data model. The implementation chosen is the Functional Query Language Front End (FQLFE). This uses the Daplex functional data model and query language. Using FQLFE, users can specify the underlying database (based on the relational model) in terms of Daplex. Queries against this specified view can then be made in Daplex. FQLFE transforms these queries into the query language (Quel) of the underlying target database system (Ingres). The automation of part of the Daplex function definition phase is also described and its implementation discussed.
19
Stanley, Adrian. "Polyfun : an experimental approach to the integration of functional and logic programming." Thesis, Open University, 1989. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.329137.
Full text
20
McNamara, Brian. "Multiparadigm programming novel devices for implementing functional and logic programming constructs in C++ /." Diss., Available online, Georgia Institute of Technology, 2004:, 2004. http://etd.gatech.edu/theses/available/etd-07122004-121450/unrestricted/mcnamara%5Fbrian%5Fm%5F200407%5Fphd.pdf.
Full textAbstract:
Thesis (Ph. D.)--College of Computing, Georgia Institute of Technology, 2005. Directed by Yannis Smaragdakis.Spencer Rugaber, Committee Member ; Olin Shivers, Committee Member ; Mary Jean Harrold, Committee Member ; Yannis Smaragdakis, Committee Chair ; Philip Wadler, Committee Member. Includes bibliographical references.
21
Ahn, Ki Yung. "The Nax Language: Unifying Functional Programming and Logical Reasoning in a Language based on Mendler-style Recursion Schemes and Term-indexed Types." PDXScholar, 2014. https://pdxscholar.library.pdx.edu/open_access_etds/2088.
Full textAbstract:
Two major applications of lambda calculi in computer science are functional programming languages and mechanized reasoning systems (or, proof assistants). According to the Curry--Howard correspondence, it is possible, in principle, to design a unified language based on a typed lambda calculus for both logical reasoning and programming. However, the different requirements of programming languages and reasoning systems make it difficult to design such a unified language that provides both. Programming languages usually extend lambda calculi with programming-friendly features (e.g., recursive datatypes, general recursion) for supporting the flexibility to model various computations, while sacrificing logical consistency. Logical reasoning systems usually extend lambda calculi with logic-friendly features (e.g., induction principles, dependent types) for paradox-free inference over fine-grained properties, while being more restrictive in modeling computations.
In this dissertation, we design and implement a language called Nax that embraces benefits of both. Nax accepts all recursive datatypes, thus, allowing the same flexibility of defining recursive datatypes as in functional languages. Nax supports a number of Mendler-style recursion schemes that can express various kinds of recursive computations and also guarantee termination. Nax supports term-indexed types to support specifications of fine-grained properties. In addition, Nax supports a conservative extension of Hindley--Milner type inference.
The theoretical contributions of this dissertation include theories for Mendler-style recursion schemes and term-indexed types, which we developed to establish strong normalization and logical consistency of Nax.
22
Christensson, Ludvig. "Functional Shading Language : Kompilering av funktionsvärden, typinferens och automatisk generalisering till HLSL." Thesis, Högskolan i Skövde, Institutionen för informationsteknologi, 2018. http://urn.kb.se/resolve?urn=urn:nbn:se:his:diva-15754.
Full textAbstract:
Rapporten beskriver design, utveckling och testning av det funktionella shaderspråket FSL i syftet att avgöra om funktionell paradigm gör shaderspråk enklare att förstå och använda än den existerande imperativa paradigmen. Implementationen presenterar tekniker för att kompilera de funktionella språkkonstruktionerna typinferens, funktionsvärden och automatisk generalisering till HLSL. För jämförelse introduceras också språket PSL, en imperativ motsvarighet till FSL. Resultatet bedöms genom ett blindtest där FSL och PSL presenteras till två separata grupper och testas genom tre provuppgifter. Undersökningen visade att personer som testade det funktionella språket svarade mer negativt på språkets designbeslut, men att båda grupperna presterade lika bra på uppgifterna. Förslag på hur arbetet kan användas som grund för en djupare studie om funktionell grafikprogrammering presenteras. Till sist diskuteras olika sätt att bygga på FSLs tekniska bas för att implementera andra funktionella språkverktyg.
23
Peters, Arthur. "The Basic Scheme for the Evaluation of Functional Logic Programs." PDXScholar, 2012. https://pdxscholar.library.pdx.edu/open_access_etds/914.
Full textAbstract:
Functional logic languages provide a powerful programming paradigm combining the features of functional languages and logic languages. However, current implementations of functional logic languages are complex, slow, or both. This thesis presents a scheme, called the Basic Scheme, for compiling and executing functional logic languages based on non-deterministic graph rewriting. This thesis also describes the implementation and optimization of a prototype of the Basic Scheme. The prototype is simple and performs well compared to other current implementations.
24
Bailey, Justin George. "Using Dataflow Optimization Techniques with a Monadic Intermediate Language." PDXScholar, 2012. https://pdxscholar.library.pdx.edu/open_access_etds/508.
Full textAbstract:
Our work applies the dataflow algorithm to an area outside its traditional scope: functional languages. Our approach relies on a monadic intermediate language that provides low-level, imperative features like computed jumps and explicit allocations, while at the same time supporting high-level, functional-language features like case discrimination and partial application. We prototyped our work in Haskell using the HOOPL library and this dissertation shows numerous examples demonstrating its use. We prove the efficacy of our approach by giving a novel description of the uncurrying optimization in terms of the dataflow algorithm, as well as a complete implementation of the optimization using HOOPL.
25
Salah, Eddin Anas. "Network Construction and Graph Theoretical Analysis of Functional Language Networks in Pediatric Epilepsy." FIU Digital Commons, 2013. http://digitalcommons.fiu.edu/etd/971.
Full textAbstract:
This dissertation introduces a new approach for assessing the effects of pediatric epilepsy on the language connectome. Two novel data-driven network construction approaches are presented. These methods rely on connecting different brain regions using either extent or intensity of language related activations as identified by independent component analysis of fMRI data. An auditory description decision task (ADDT) paradigm was used to activate the language network for 29 patients and 30 controls recruited from three major pediatric hospitals. Empirical evaluations illustrated that pediatric epilepsy can cause, or is associated with, a network efficiency reduction. Patients showed a propensity to inefficiently employ the whole brain network to perform the ADDT language task; on the contrary, controls seemed to efficiently use smaller segregated network components to achieve the same task. To explain the causes of the decreased efficiency, graph theoretical analysis was carried out. The analysis revealed no substantial global network feature differences between the patient and control groups. It also showed that for both subject groups the language network exhibited small-world characteristics; however, the patient’s extent of activation network showed a tendency towards more random networks. It was also shown that the intensity of activation network displayed ipsilateral hub reorganization on the local level. The left hemispheric hubs displayed greater centrality values for patients, whereas the right hemispheric hubs displayed greater centrality values for controls. This hub hemispheric disparity was not correlated with a right atypical language laterality found in six patients. Finally it was shown that a multi-level unsupervised clustering scheme based on self-organizing maps, a type of artificial neural network, and k-means was able to fairly and blindly separate the subjects into their respective patient or control groups. The clustering was initiated using the local nodal centrality measurements only. Compared to the extent of activation network, the intensity of activation network clustering demonstrated better precision. This outcome supports the assertion that the local centrality differences presented by the intensity of activation network can be associated with focal epilepsy.
26
Moorman, Kenneth Matthew. "A functional theory of creative reading : process, knowledge, and evaluation." Diss., Georgia Institute of Technology, 1997. http://hdl.handle.net/1853/9122.
Full text
27
Ekron, Anna Cecilia. "Vocabulary : it's all about words working together : an interactive multimedia program to improve senior phase English first additional language learners’ functional vocabulary through an increased understanding of everyday authentic texts and classical and contemporary poetry." Thesis, Stellenbosch : University of Stellenbosch, 2008. http://hdl.handle.net/10019.1/1829.
Full textAbstract:
Thesis (MPhil (Modern Foreign Languages))--University of Stellenbosch, 2008.The continuing decline in Matriculation pass rates is a matter of concern for government, educators, parents and students in South African schools. According to official statistics, only 8% of South Africans are mother-tongue English speakers, yet English is the chief language of learning and teaching in South African schools. Researchers relate the poor pass rate to inadequate proficiency in English of both English First Additional Language learners and some of their teachers. Research has further revealed a significant positive correlation between reading comprehension and academic achievement. Consensus exists among researchers about the necessity of a basic vocabulary (variously estimated at 2000 to 3000 words and more) for developing the necessary reading comprehension. Theories and approaches regarding the development of vocabulary, however, are sometimes diametrically opposed to one another. Among the most conflicting theories are those which advocate the acquisition of vocabulary by guessing the meanings of words from the context as opposed to those favouring conscious and deliberate vocabulary teaching, which may include lists of words. The current study briefly investigates underlying problems, theories, methods and approaches to enhancing learners’ vocabularies. Conclusions are applied to the development of an interactive, multimedia program for improving learners’ functional vocabularies. The content of the program is based on authentic texts and simulations of situations which call for language interaction. This is supplemented with extracts from classical literary works and poetry and entertaining verses which present possibilities for use in vocabulary building.
28
Shen, Ying. "Compiling a synchronous programming language into field programmable gate arrays." Thesis, National Library of Canada = Bibliothèque nationale du Canada, 1999. http://www.collectionscanada.ca/obj/s4/f2/dsk1/tape8/PQDD_0029/MQ47476.pdf.
Full text
29
Yang, Dai Fei. "Improving Networked Learning in Higher Education: Language Functions and Design Patterns." University of Sydney, 2007. http://hdl.handle.net/2123/2465.
Full textAbstract:
Doctor of PhilosophyThe thesis of this study is that two seemingly disparate research disciplines can be coalesced to develop an effective pedagogical framework for educational design in the context of networked learning. That contention is grounded in, and inspired by, the rapid developments in educational technologies which have greatly changed the landscape in teaching and learning in higher education over the last decade. The study attempts to add to the corpus of contemporary learning theory which sees students not merely as passive recipients of knowledge, but as active participants in the learning process, having much greater control over their selection of technological learning tools, learning resources and learning methodologies. This is very much in line with the shift from the traditional focus on content design and knowledge transmission towards a more student-centred design for knowledge co-construction, a development which demands the type of new thinking about the design of learning tasks and learning resources contained in this study. Also set out are new lines of action for the fashioning of a collaborative learning environment, for community interaction and the sharing of knowledge, and for promoting good teaching and learning practice. The central argument of the study is that such pedagogical goals may be attained by juxtaposing the theories of Systemic Functional Linguistics (hereafter SFL) and pattern languages. These have not, thus far, been used in combination. SFL is a well established theory in the study of language, and is used in this thesis to help analyse and classify discourses produced and shared by teachers and students in networked learning. Pattern languages have their origin in architecture. Design patterns can be used as a means of representing and sharing important and specific empirical research results and design experiences. This new knowledge can be used to support and improve the quality of educational design. The study has two central components. The first uses the SFL theoretical framework to demonstrate how text is used as a key medium in networked learning. In other words, it is argued in this section that the quality of texts has a direct impact on the quality of learning and learning outcomes. The quality of text is assessed by means of a detailed discourse analysis of selected texts. This process involves deconstructing, identifying and capturing the linguistic resources and language strategies used in the texts. The detailed discourse analysis also illustrates and reveals how language is used in the construction of knowledge and the promotion of collaboration in teaching and learning. The second component centres on the argument that SFL provides valuable language knowledge which can be represented by using Alexander’s design patterns. New knowledge encoded in these design patterns can be used by teachers and designers as reusable and shared resources to help them improve their design work. The empirical research was carried out in three phases. The first involved a) the identification of text patterns of discourses used in networked learning based on detailed discourse analysis; b) Interviewing experienced academic staff to identify their perspectives on good online teaching practices and success factors. The second phase involved using the data which emerged from these interviews and discourse analysis to model illustrative patterns. (Here, illustrative means that due to the scope of the study, it is only possible to develop a limited number of patterns to illustrate the methods used for pattern development. It is not the intention to develop a full repository of design patterns in this study). In the third (validation) phase the patterns were reviewed by two groups of academic staff, with the aim of improving these patterns. Improved patterns were then tested on a group of educational design students for their usefulness and application. It is concluded from this research that it is possible to develop design patterns which ensure the best use of linguistic resources in both the teaching and learning process. Finally, it is argued that the combination of SFL and pattern languages provides a promising theoretical framework for the complex and demanding task of educational design. Future research could make use of such a framework to explore a fuller application of the pattern- based approach for the representation of new knowledge for educational design. Suggested additional research directions include finding new ways of capturing a new pedagogical approach to mobile learning and blended learning. Also, a promising direction could be the use of SFL Appraisal theory (Martin, 2000) for the investigation on how students construct interpersonal relationships (appraise peer work) in online joint projects. In the conclusion, it is contended that through its exploration of new ground in the use of SFL and pattern language theory in the construction of education design patterns, the study makes a significant contribution to knowledge in the field of networked learning.
30
Gokyer, Gokhan. "Identifying Architectural Concerns From Non-functional Requirements Using Support Vector Machine." Master's thesis, METU, 2008. http://etd.lib.metu.edu.tr/upload/12609964/index.pdf.
Full textAbstract:
There has been no commonsense on how to identify problem domain concerns in architectural
modeling of software systems. Even, there is no commonly accepted method for modeling the
Non-Functional Requirements (NFRs) effectively associated with the architectural aspects in
the solution domain. This thesis introduces the use of a Machine Learning (ML) method based
on Support Vector Machines to relate NFRs to classified "architectural concerns"
in an automated way. This method uses Natural Language Processing techniques to fragment the plain NFR texts under the supervision of domain experts. The contribution of this approach lies in continuously applying ML techniques against previously discovered &ldquo
NFR - architectural concerns&rdquo
associations to improve the intelligence of repositories for requirements engineering. The study illustrates a charted roadmap and demonstrates the automated requirements engineering toolset for this roadmap. It also validates the approach and effectiveness of the toolset on the snapshot of a real-life project.
31
Roe, Paul. "Parallel programming using functional languages." Thesis, Connect to e-thesis, 1991. http://theses.gla.ac.uk/1052.
Full text
32
Wikman, John. "Automatic GPU optimization through higher-order functions in functional languages." Thesis, KTH, Skolan för elektroteknik och datavetenskap (EECS), 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-283764.
Full textAbstract:
Over recent years, graphics processing units (GPUs) have become popular devices to use in procedures that exhibit data-parallelism. Due to high parallel capability, running procedures on a GPU can result in an execution time speedup ranging from a couple times faster to several orders of magnitude faster, compared to executing serially on a central processing unit (CPU). Interfaces such as CUDA and OpenCL flexibly exposes the parallel capabilities of the GPU to the programmer, while at the same time putting a lot of responsibility on the programmer to handle aspects such as thread synchronization and memory management. A different approach to GPU optimization is to enable it through higher-order functions with known data-parallelism, using the semantics of the higher-order function to determine the parallel execution. This approach has in practice been integrated into existing languages through libraries or been integrated directly into languages themselves. However, higher-order functions do not address when it is beneficial to execute on a GPU. Due to the GPU being a separate device, effects such as latency and memory transfer can cause a slowdown for small input values. In this thesis, a set of commonly used higher-order functions are GPU enabled as compiler intrinsics in a small functional language. These higher-order functions are also equipped with the option of automatically deciding at runtime if to execute on GPU or CPU. Results show that running higher-order functions on GPU yields a speedup for larger computations. However, the performance does not match existing solutions that provide additional higher-order functions for optimizing the parallelization. The selected approach for automatically deciding whether to run a higher-order function on GPU or on CPU results in the faster option a majority of cases. Though the most notable benefit of automatic decisions was for procedures that use multiple higher-order function invocations, which ran faster compared to when executing only on GPU or only on CPU.På senare år har grafikprocessorer blivit populära enheter att använda för att köra program med hög dataparallellism. Den höga parallella kapaciteten hos grafikprocessorer gör att exekveringstiden för program kan bli betydligt snabbare än om programmet exekveras seriellt på en vanlig processor. Gränssnitt som CUDA och OpenCL möjliggör flexibel parallellprogrammering för grafikprocessorer, samtidigt som de gränssnitten lägger mycket ansvar på programmeraren att hantera aspekter som trådsynkronisering och minneshantering. Ett annat tillvägagångssätt är att genom högre ordningens funktioner med dataparallella egenskaper optimera program för grafikprocessorer, där semantiken hos de funktionerna styr hur den parallella exekveringen ser ut. Den här metoden har i praktiken integrerats i existerande programmeringsspråk som bibliotek eller integrerats direkt i själva programmeringsspråken. Funktioner av högre ordning adresserar dock inte när det är lönsamt att exekvera på en grafikprocessor. Till följd av att en grafikprocessor är en separat enhet kan effekter som latens och minnesöverföringar för små indata orsaka en längre exekveringstid. I det här examensarbetet tillhandahålls en känd uppsättning funktioner av högre ordning som inbyggda funktioner i en kompilator för ett litet funktionellt språk, med stöd för att exekveras på en grafikprocessor. De här funktionerna av högre ordning har även stöd för att automatiskt under exekvering besluta om de ska exekvera på en grafikprocessor eller på en vanlig processor. Resultaten visar att funktioner av högre ordning som exekveras på en grafikprocessor har kortare exekveringstid för större beräkningar. Prestandan motsvarar dock inte den hos existerande lösningar som tillhandahåller en större uppsättning funktioner av högre ordning med stöd för parallell optimering. Det valda tillvägagångssättet för att automatiskt besluta om en högre ordningens funktion ska exekveras på en grafikprocessor eller på en vanlig processor väljer i en majoritet av fallen det snabbare alternativet. Den mest nämnvärda fördelen med det automatiska beslutstagandet var dock för program med flera användningar av funktioner av högre ordning, där exekveringstiden blev snabbare än om funktionerna exekverats enbart på en grafikprocessor eller enbart på en vanlig processor.
33
Gill, Andrew John. "Cheap deforestation for non-strict functional languages." Thesis, University of Glasgow, 1996. http://theses.gla.ac.uk/4817/.
Full textAbstract:
In functional languages intermediate data structures are often used as glue to connect separate parts of a program together. Deforestation is the process of automatically removing intermediate data structures. In this thesis we present and analyse a new approach to deforestation. This new approach is both practical and general. We analyse in detail the problem of list removal rather than the more general problem of arbitrary data structure removal. This more limited scope allows a complete evaluation of the pragmatic aspects of using our deforestation technology. We have implemented our list deforestation algorithm in the Glasgow Haskell compiler. Our implementation has allowed practical feedback. One important conclusion is that a new analysis is required to infer function arities and the linearity of lambda abstractions. This analysis renders the basic deforestation algorithm far more effective. We give a detailed assessment of our implementation of deforestation. We measure the effectiveness of our deforestation on a suite of real application programs. We also observe the costs of our deforestation algorithm.
34
Ragnehed, Mattias. "Functional Magnetic Resonance Imaging for Clinical Diagnosis : Exploring and Improving the Examination Chain." Doctoral thesis, Linköping : Department of Medical and Health Sciences, Linköping University, 2009. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-18095.
Full text
35
Németh, László. "Catamorphism-based program transformations for non-strict functional languages." Thesis, University of Glasgow, 2000. http://theses.gla.ac.uk/4612/.
Full textAbstract:
In functional languages intermediate data structures are often used as glue to connect separate parts of a program together. These intermediate data structures are useful because they allow modularity, but they are also a cause of inefficiency: each element need to be allocated, to be examined, and to be deallocated. Warm fusion is a program transformation technique which aims to eliminate intermediate data structures. Functions in a program are first transformed into the so called build-cata form, then fused via a one-step rewrite rule, the cata-build rule. In the process of the transformation to build-cata form we attempt to replace explicit recursion with a fixed pattern of recursion (catamorphism). We analyse in detail the problem of removing - possibly mutually recursive sets of - polynomial datatypes. Wehave implemented the warm fusion method in the Glasgow Haskell Compiler, which has allowed practical feedback. One important conclusion is that catamorphisms and fusion in general deserve a more prominent role in the compilation process. We give a detailed measurement of our implementation on a suite of real application programs.
36
Fritsch, Joerg. "Functional programming languages in computing clouds : practical and theoretical explorations." Thesis, Cardiff University, 2016. http://orca.cf.ac.uk/96984/.
Full textAbstract:
Cloud platforms must integrate three pillars: messaging, coordination of workers and data. This research investigates whether functional programming languages have any special merit when it comes to the implementation of cloud computing platforms. This thesis presents the lightweight message queue CMQ and the DSL CWMWL for the coordination of workers that we use as artefact to proof or disproof the special merit of functional programming languages in computing clouds. We have detailed the design and implementation with the broad aim to match the notions and the requirements of computing clouds. Our approach to evaluate these aims is based on evaluation criteria that are based on a series of comprehensive rationales and specifics that allow the FPL Haskell to be thoroughly analysed. We find that Haskell is excellent for use cases that do not require the distribution of the application across the boundaries of (physical or virtual) systems, but not appropriate as a whole for the development of distributed cloud based workloads that require communication with the far side and coordination of decoupled workloads. However, Haskell may be able to qualify as a suitable vehicle in the future with future developments of formal mechanisms that embrace non-determinism in the underlying distributed environments leading to applications that are anti-fragile rather than applications that insist on strict determinism that can only be guaranteed on the local system or via slow blocking communication mechanisms.
37
Williams, Dewi L. (Dewi Lloyd) Carleton University Dissertation Engineering Electrical. "A Functional-test specification language." Ottawa, 1988.
Find full text
38
Ben-Dyke, Andrew David. "Prototyping parallel functional intermediate languages." Thesis, University of Birmingham, 1999. http://etheses.bham.ac.uk//id/eprint/7199/.
Full textAbstract:
Non-strict higher-order functional programming languages are elegant, concise, mathematically sound and contain few environment-specific features, making them obvious candidates for harnessing high-performance architectures. The validity of this approach has been established by a number of experimental compilers. However, while there have been a number of important theoretical developments in the field of parallel functional programming, implementations have been slow to materialise. The myriad design choices and demands of specific architectures lead to protracted development times. Furthermore, the resulting systems tend to be monolithic entities, and are difficult to extend and test, ultimatly discouraging experimentation. The traditional solution to this problem is the use of a rapid prototyping framework. However, as each existing systems tends to prefer one specific platform and a particular way of expressing parallelism (including implicit specification) it is difficult to envisage a general purpose framework. Fortunately, most of these systems have at least one point of commonality: the use of an intermediate form. Typically, these abstract representations explicitly identify all parallel components but without the background noise of syntactic and (potentially arbitrary) implementation details. To this end, this thesis outlines a framework for rapidly prototyping such intermediate languages. Based on the traditional three-phase compiler model, the design process is driven by the development of various semantic descriptions of the language. Executable versions of the specifications help to both debug and informally validate these models. A number of case studies, covering the spectrum of modern implementations, demonstrate the utility of the framework.
39
Harrison, Rachel. "Pure functional languages and parallelism." Thesis, University of Southampton, 1991. https://eprints.soton.ac.uk/253169/.
Full text
40
Hammond, K. "Implementing functional languages for parallel machines." Thesis, University of East Anglia, 1988. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.314394.
Full text
41
Howson, Christopher. "A distributed graph reducer for lazy functional languages /." Thesis, McGill University, 1992. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=56681.
Full textAbstract:
This thesis describes a model for distributed graph reduction implemented on a network of transputers. The model allows variable size communications between processors, by exchanging subgraphs instead of single nodes. Functional languages with lazy semantics have graph nodes representing unevaluated arguments. These nodes require special treatment by the run time system because they must not be copied. By checking the structure of the transmitted subgraphs, it is possible to determine which unevaluated expressions have no external references to them and so may safely be included in the subgraph with no overhead. This allows large subgraphs to be exchanged while reducing the demands on the communications system. This technique raises the possibility of implementations on a wide variety of distributed computers such as networks of workstations, which hitherto has been considered impractical.
42
Shapiro, David. "Compiling Evaluable Functions in the Godel Programming Language." PDXScholar, 1996. https://pdxscholar.library.pdx.edu/open_access_etds/5101.
Full textAbstract:
We present an extension of the Godel logic programming language code generator which compiles user-defined functions. These functions may be used as arguments in predicate or goal clauses. They are defined in extended Godel as rewrite rules. A translation scheme is introduced to convert function definitions into predicate clauses for compilation. This translation scheme and the compilation of functional arguments both employ leftmost-innermost narrowing. As function declarations are indistinguishable from constructor declarations, a function detection method is implemented. The ultimate goal of this research is the implementation of extended Godel using needed narrowing. The work presented here is an intermediate step in creating a functional-logic language which expands the expressiveness of logic programming and streamlines its execution.
43
Wray, S. C. "Implementation and programming techniques for functional languages." Thesis, University of Cambridge, 1986. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.373719.
Full text
44
Reuer, Veit. "PromisD." Doctoral thesis, Humboldt-Universität zu Berlin, Philosophische Fakultät II, 2005. http://dx.doi.org/10.18452/15266.
Full textAbstract:
Gegenstand der Arbeit ist zunächst eine Analyse der didaktischen Anforderungen an Sprachlernsysteme, die sich zum Teil aus dem Fremdsprachenunterricht ergeben. Daraus ergibt sich ein Übungstyp, der vom Lerner eine frei gestaltete Eingabe erfordert und damit insbesondere die kommunikative Kompetenz fördert, der aber auch mit Hilfe computerlinguistischer Methoden realisiert werden kann. Anschließend wird zur Auswahl einer geeigneten Grammatiktheorie insbesondere die Lexical Functional Grammar (LFG) näher betrachtet. Die Theorie muss sich aus computerlinguistischer Sicht für eine Implementierung im Rahmen eines Sprachlernprogramms eignen und es ist von zusätzlichem Vorteil, wenn die verwendeten Konzepte denen in Lernergrammatiken ähneln, um so die Generierung von Rückmeldungen zu vereinfachen. Im darauf folgenden Abschnitt wird kurz das eigentliche Programm PromisD (Projekt mediengestütztes interaktives Sprachenlernen - Deutsch) vorgestellt, wie es sich auch dem Nutzer präsentiert. Schließlich wird ein so genanntes antizipationsfreies Verfahren entwickelt, bei dem weder in der Grammatik noch im Lexikon Informationen zur Fehleridentifizierung enthalten sind. Die Fehlererkennung wird dabei auf die Bereiche eingeschränkt, in denen sich in einem Lernerkorpus häufig Fehler zeigen, um einerseits wesentliche Fehlertypen abzudecken und andererseits eine größere Effizienz bei der Analyse von realen Eingaben zu erreichen. Die Vorstellung des Verfahrens unterteilt sich entsprechend den grundlegenden Struktureinheiten der LFG in zwei Bereiche: die Konstituentenstruktur mit einer modifizierten Form des Earley-Algorithmus zur Integration von Fehlerhypothesen in die Chart und die Feature-Struktur mit einer veränderten Unifikationstrategie zur Behandlung und Speicherung von sich widersprechenden Werten in F-Strukturen. Zum Abschluss erfolgt die Evaluation und es werden die Möglichkeiten zur Gestaltung einer Rückmeldung an den Lerner diskutiert.The dissertation starts with an analysis of the requirements for Intelligent Computer-Assisted Language Learning systems (ICALL), which partially depend on didactic aspects of foreign language teaching. Based on this a type of exercise can be identified, that on the one hand allows the learner to enter free formed input supporting the so called communicative competence as a major didactic goal and on the other hand may be realised with advanced computational linguistics'' methods. In the following chapter a look at grammar theories and especially Lexical Functional Grammar (LFG) is taken. The grammar theory needs to be tractable in an implementation and it is of a further advantage if the concepts of the theory are similar to the concepts in learner grammars in order to simplify the generation of feedback. Subsequently the user interface of the actual program is presented with a focus on error messages. The implementation is named PromisD, which stands for "Projekt mediengestütztes interaktives Sprachenlernen - Deutsch". Finally an anticipation-free parsing method is developed using neither information from the lexicon nor the grammar in order to identify grammar errors. The recognition is restricted to those areas where errors occur frequently in a learner corpus in order to allow for a greater efficiency parsing authentic data. Along the two structural levels in LFG the presentation of the algorithm follows: the constituent-structure with a modified Early-algorithm integrating error hypotheses into the chart and the feature-structure with a new unification-strategie storing information about clashing values in the f-structure. The dissertation closes with an evaluation and an outlook on the generation of error messages.
45
Ocakturk, Murat. "An Approach For Including Business Requirements To Soa Design." Master's thesis, METU, 2010. http://etd.lib.metu.edu.tr/upload/2/12611574/index.pdf.
Full textAbstract:
In this thesis, a service oriented decomposition approach: Use case Driven Service Oriented Architecture (UDSOA), is introduced to close the gap between business requirements and SOA (Service Oriented Architecture) design by including business use cases and system use cases into decomposition process. The approach is constructed upon Service Oriented Software Engineering (SOSE) modeling technique and aims to fill the deficits of it at the decomposition phase. Further, it aims to involve both business vision and Information Technologies concerns in the decomposition process. This approach starts with functional top-down decomposition of the domain. Then, business use cases are used for further decomposition because of their high-level view. This connects the business requirements and our SOA design. Also it raises the level of abstraction which allows us to focus on business services. Second step of the SOA approach uses system use cases to continue decomposition. System use cases help discovering technical web services and allocating them on the decomposition tree. Service oriented analysis also helps separating business and technical services in tightly coupled architecture conditions. Those two steps together bring quality in to both problem and solution domains.
46
Stoye, W. R. "The implementation of functional languages using custom hardware." Thesis, University of Cambridge, 1985. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.355864.
Full text
47
Ayers, Robert. "Enhancing the semantic power of functional database languages." Thesis, Birkbeck (University of London), 1995. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.307446.
Full text
48
Kathail, Vinod. "Optimal interpreters for lambda-calculus based functional languages." Thesis, Massachusetts Institute of Technology, 1990. http://hdl.handle.net/1721.1/14040.
Full textAbstract:
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1990.Includes bibliographical references (leaves 195-197).
by Vinod Kumar Kathail.
Ph.D.
49
Toutet, Christiana Virginia 1974. "Generating threads for non-strict functional programming languages." Thesis, Massachusetts Institute of Technology, 1998. http://hdl.handle.net/1721.1/47540.
Full textAbstract:
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science; and, Thesis (B.S.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1998.Includes bibliographical references (leaf 71).
by Christiana Virginia Toutet.
B.S.
M.Eng.
50
Barry, Bobbi J. "Needed Narrowing as the Computational Strategy of Evaluable Functions in an Extension of Goedel." PDXScholar, 1996. https://pdxscholar.library.pdx.edu/open_access_etds/4915.
Full textAbstract:
A programming language that combines the best aspects of both the functional and logic paradigms with a complete evaluation strategy has been a goal of a Portland State University project team for the last several years. I present the third in a series of modifications to the compiler of the logic programming language Goedel which reaches this goal. This enhancement of Goedel's compiler translates user-defined functions in the form of rewrite rules into code that performs evaluation of these functions by the strategy of needed narrowing. In addition, Goedel's mechanism that evaluates predicates is supplemented so that needed narrowing is still maintained as the evaluation strategy when predicates possess functional arguments.