Rozprawy doktorskie na temat „Programming languages”
Kliknij ten link, aby zobaczyć inne rodzaje publikacji na ten temat: Programming languages.
Utwórz poprawne odniesienie w stylach APA, MLA, Chicago, Harvard i wielu innych
Sprawdź 50 najlepszych rozpraw doktorskich naukowych na temat „Programming languages”.
Przycisk „Dodaj do bibliografii” jest dostępny obok każdej pracy w bibliografii. Użyj go – a my automatycznie utworzymy odniesienie bibliograficzne do wybranej pracy w stylu cytowania, którego potrzebujesz: APA, MLA, Harvard, Chicago, Vancouver itp.
Możesz również pobrać pełny tekst publikacji naukowej w formacie „.pdf” i przeczytać adnotację do pracy online, jeśli odpowiednie parametry są dostępne w metadanych.
Przeglądaj rozprawy doktorskie z różnych dziedzin i twórz odpowiednie bibliografie.
1
Cook, Jonathan J. "Language interoperability and logic programming languages". Thesis, University of Edinburgh, 2005. http://hdl.handle.net/1842/725.
Pełny tekst źródłaStreszczenie:
We discuss P#, our implementation of a tool which allows interoperation between a concurrent superset of the Prolog programming language and C#. This enables Prolog to be used as a native implementation language for Microsoft's .NET platform. P# compiles a linear logic extension of Prolog to C# source code. We can thus create C# objects from Prolog and use C#'s graphical, networking and other libraries. P# was developed from a modified port of the Prolog to Java translator, Prolog Cafe. We add language constructs on the Prolog side which allow concurrent Prolog code to be written. We add a primitive predicate which evaluates a Prolog structure on a newly forked thread. Communication between threads is based on the unification of variables contained in such a structure. It is also possible for threads to communicate through a globally accessible table. All of the new features are available to the programmer through new built-in Prolog predicates. We present three case studies. The first is an application which allows several users to modify a database. The users are able to disconnect from the database and to modify their own copies of the data before reconnecting. On reconnecting, conflicts must be resolved. The second is an object-oriented assistant, which allows the user to query the contents of a C# namespace or Java package. The third is a tool which allows a user to interact with a graphical display of the inheritance tree. Finally, we optimize P#'s runtime speed by translating some Prolog predicates into more idiomatic C# code than is produced by a naive port of Prolog Cafe. This is achieved by observing that semi-deterministic predicates (being those which always either fail or succeed with exactly one solution) that only call other semi-deterministic predicates enjoy relatively simple control flow. We make use of the fact that Prolog programs often contain predicates which operate as functions, and that such predicates are usually semi-deterministic.
2
Samsonenko, L. U., i M. O. Sasyuk. "Different programming languages". Thesis, Сумський державний університет, 2013. http://essuir.sumdu.edu.ua/handle/123456789/33800.
Pełny tekst źródłaStreszczenie:
The rise of BASIC is very much a phenomenon of the mid 70’s and early 80’s. It comes as something of a surprise to discover that it was actually born in the 60’s. BASIC was designed by John Kemeny and Thomas Kurtz at Dartmouth College, in the USA.
When you are citing the document, use the following link http://essuir.sumdu.edu.ua/handle/123456789/33800
3
Kennedy, Andrew John. "Programming languages and dimensions". Thesis, University of Cambridge, 1995. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.242978.
Pełny tekst źródła
4
Stryzhachenko, К. О., i M. Y. Tykhomirova. "The esoteric programming languages". Thesis, Сумський державний університет, 2013. http://essuir.sumdu.edu.ua/handle/123456789/33872.
Pełny tekst źródłaStreszczenie:
An esoteric programming language is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, or as a joke, for example:
Lolcode is designed to resemble the speech of lolcats. The following is the “hello world” example: in all lolcode programs, hai (“Hi!”) introduces the program. In many programming languages, one of the first statements will be a library inclusion for common functions such as input and output.
When you are citing the document, use the following link http://essuir.sumdu.edu.ua/handle/123456789/33872
5
Warth, Alessandro. "Experimenting with programming languages". Diss., Restricted to subscribing institutions, 2009. http://proquest.umi.com/pqdweb?did=1723135581&sid=1&Fmt=2&clientId=1564&RQT=309&VName=PQD.
Pełny tekst źródła
6
BASTOS, JOAO ANTONIO DUTRA MARCONDES. "SUPPORT FOR COMPUTATIONAL THINKING KNOWLEDGE TRANSFER FROM VISUAL PROGRAMMING LANGUAGES TO TEXTUAL PROGRAMMING LANGUAGES". PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2015. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=25694@1.
Pełny tekst źródłaStreszczenie:
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIROCOORDENAÇÃO DE APERFEIÇOAMENTO DO PESSOAL DE ENSINO SUPERIOR
PROGRAMA DE EXCELENCIA ACADEMICA
Produzir tecnologia tem se mostrado uma habilidade cada vez mais indispensável na sociedade moderna. Os usuários estão deixando de ser simples consumidores e passando a ser produtores, usando a tecnologia para expressarem suas ideias. Nesse contexto, o aprendizado do chamado raciocínio computacional deve ser tão importante quanto o de disciplinas básicas, como a leitura, a escrita e a aritmética. Ao desenvolver tal habilidade o aluno vai conseguir se expressar através do software. Diversos projetos ao redor do mundo têm suas tecnologias e didáticas próprias a fim de auxiliar o aluno a desenvolver tal capacidade. Porém, sabemos que em um contexto que está em constante evolução como é o caso da informática, não podemos deixar que o aluno fique preso a uma única ferramenta ou meio de se expressar. Ferramentas podem ficar obsoletas e ele perderia seu poder de produtor de tecnologia. Pensando nisso, foi elaborado um modelo de transferência do aprendizado do raciocínio computacional a ser incorporado a sistemas de documentação ativa que apoiam o ensino-aprendizado desta habilidade. O modelo auxiliará o designer na criação de um artefato tecnológico que seja capaz de ajudar alunos e professores a aprenderem uma nova linguagem de programação. O modelo, que é baseado na Engenharia Semiótica, é a principal contribuição científica dessa dissertação de mestrado.
Producing technology has been an increasingly essential ability in modern society. The users are no longer simple consumers but actually, also, technology producers, using technology to express their ideas. In this context, the learning of the so-called computational thinking should be as important as learning basic disciplines such as reading, writing and arithmetic. As long as the student can develop this ability, he will be able to express himself or herself through the software. Many projects around the world have their own technologies and pedagogy to help the student develop such capacity. However, we know that in a context that is constantly evolving as is the case of informatics, we cannot allow the student to be attached to a single tool or means. Tools may become obsolete and students would lose their technology producer status. With this in mind, we designed a learning transfer model of computational thinking, which will assist the designer in the creation of a technological artifact to help students and teachers learn a new programming language. The model, which is based on the Semiotic Engineering, is the main scientific contribution of this master s dissertation.
7
Tonchev, Ognyan, i Mohammed Salih. "High-level programming languages translator". Thesis, Blekinge Tekniska Högskola, Avdelningen för för interaktion och systemdesign, 2008. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-2560.
Pełny tekst źródłaStreszczenie:
This paper discusses a high level language translator. If we divide translators of programming languages in two types: those working for two specific languages and universal translators that can be used for translation between different programming languages, the solution that will be presented in this work can be classified as both, specific language oriented and an universal translator. For the purpose of the research it was limited to translate only from Java to C++, but it can easily be extended to translate between any other high level languages. For simplifying the process of translation the project uses an intermediate step. All programs in the input language are first compiled to an abstract XML language and then to the desired output language. That way it is not necessary to translate directly from one programming language to another which is a very tricky and difficult task and could make the solution difficult to be maintained and extended. Hence the translator can also be used to translate from any high level language to XML. That gives another advantage to our solution: an XML representation of a computer program is valuable information by itself. We describe the design and implementation of the solution, demonstrate how it works and also give information on how it can be extended to work for any other programming language.This paper discusses a high level language translator. If we divide translators of programming languages in two types: those working for two specific languages and universal translators that can be used for translation between different programming languages, the solution that will be presented in this work can be classified as both, specific language oriented and an universal translator. For the purpose of the research it was limited to translate only from Java to C++, but it can easily be extended to translate between any other high level languages. For simplifying the process of translation the project uses an intermediate step. All programs in the input language are first compiled to an abstract XML language and then to the desired output language. That way it is not necessary to translate directly from one programming language to another which is a very tricky and difficult task and could make the solution difficult to be maintained and extended. Hence the translator can also be used to translate from any high level language to XML. That gives another advantage to our solution: an XML representation of a computer program is valuable information by itself. We describe the design and implementation of the solution, demonstrate how it works and also give information on how it can be extended to work for any other programming language.
8
Roe, Paul. "Parallel programming using functional languages". Thesis, Connect to e-thesis, 1991. http://theses.gla.ac.uk/1052.
Pełny tekst źródła
9
Vacchi, E. "PROGRAMMING LANGUAGES À LA CARTE". Doctoral thesis, Università degli Studi di Milano, 2015. http://hdl.handle.net/2434/263620.
Pełny tekst źródłaStreszczenie:
Code reuse in computer language development is an open research problem. Feature-oriented programming is a vision of computer programming in which features can be implemented separately, and then combined to build a variety of software products; the idea of combining feature orientation and language development is relatively recent. Many frameworks for modular language development have been proposed during the years, but, although there is a strong connection between modularity and feature-orientation development, only few of these frameworks provide primitives to combine these two concepts. This work presents a model of modular language development that is directed towards feature orientation. We describe its implementation in the Neverlang framework. The model has been evaluated through several experiences: among the others, we present a code generator for a state machine language, that we use as a means to compare to other state-of-the-art frameworks, and a JavaScript interpreter implementation that further illustrates the capabilities of our solution.
10
Michlowitz, Jason Lawrence. "A methodology for mapping programming languages to programming problems /". View online, 2006. http://ecommons.txstate.edu/cscitad/2.
Pełny tekst źródła
11
Petre, Marian. "Findings a basis for matching programming languages to programming tasks". Thesis, University College London (University of London), 1989. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.252003.
Pełny tekst źródła
12
Brandis, Marc Brandis Marc Michael. "Optimizing compilers for structured programming languages /". [S.l.] : [s.n.], 1995. http://e-collection.ethbib.ethz.ch/show?type=diss&nr=11024.
Pełny tekst źródła
13
Stenman, Erik. "Efficient Implementation of Concurrent Programming Languages". Doctoral thesis, Uppsala University, Department of Information Technology, 2002. http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-2688.
Pełny tekst źródłaStreszczenie:
Dissertation in Computer Science to be publicly examined in Häggsalen, Ångströmlaboratoriet, Uppsala University, on Friday, November 1, 2002 at 1:00 pm for the degree of doctor of philosophy. The examination will be conducted in English.
This thesis proposes and experimentally evaluates techniques for efficient implementation of languages designed for high availability concurrent systems. This experimental evaluation has been done while developing the High Performance Erlang (HiPE) system, a native code compiler for SPARC and x86. The two main goals of the HiPE system are to provide efficient execution of Erlang programs, and to provide a research vehicle for evaluating implementation techniques for concurrent functional programming languages.
The focus of the thesis is the evaluation of two techniques that enable inter-process optimization through dynamic compilation. The first technique is a fast register allocator called linear scan, and the second is a memory architecture where processes share memory.
The main contributions of the thesis are:
An evaluation of linear scan register allocation in a different language setting. In addition the performance of linear scan on the register poor x86 architecture is evaluated for the first time.
A description of three different heap architectures (private heaps, shared heap, and a hybrid of the two), with a systematic investigation of implementation aspects and an extensive discussion on the associated performance trade-offs of the heap architectures. The description is accompanied by an experimental evaluation of the private vs. the shared heap setting.
A novel approach to optimizing a concurrent program, by merging code from a sender with code from a receiver, is presented together with other methods for reducing the overhead of context switching.
A description of the implementation aspects of a complete and robust native code Erlang system, which makes it possible to test compiler optimizations on real world programs.
14
Hague, R. G. "End-user programming in multiple languages". Thesis, University of Cambridge, 2005. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.599833.
Pełny tekst źródłaStreszczenie:
Advances in user interface technology have removed the need for the majority of users to program, but they do not allow the automation of repetitive or indirect tasks. End-user programming facilities solve this problem without requiring users to learn and use a conventional programming language, but must be tailored to specific types of end user. In situations where the user population is particularly diverse, this presents a problem. In addition, studies have shown that the performance of tasks based on the manipulation and interpretation of data depends on the way in which the data is represented. Different representations may facilitate different tasks, and there is not necessarily a single, optimal representation that is best for all tasks. In many cases, the choice of representation is also constrained by other factors, such as display size. It would be advantageous for an end-user programming system to provide multiple, interchangeable representations of programs. This dissertation describes an architecture for providing end-user programming facilities in the networked home, a context with a diverse user population, and a wide variety of input and output devices. The Media Cubes language, a novel end-user programming language, is introduced as the context that lead to the development of the architecture. A framework for translation between languages via a common intermediate form is then described, with particular attention paid to the requirements of mappings between languages and the intermediate form. The implementation of Lingua Franca, a system realizing this framework in the given context, is described. Finally, the system is evaluated by considering several end-user programming languages implemented within this system. It is concluded that translation between programming languages, via a common intermediate form, is viable for systems within a limited domain, and discuss the wider applicability of the technique.
15
Bagiokou, Maria. "The syntactic evolution of programming languages". Thesis, University of Nottingham, 1999. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.285679.
Pełny tekst źródła
16
Bowers, Antony Francis. "Effective meta-programming in declarative languages". Thesis, University of Bristol, 1998. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.263891.
Pełny tekst źródła
17
Wren, Alisdair Stuart. "Relationships for object-oriented programming languages". Thesis, University of Cambridge, 2007. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.613369.
Pełny tekst źródła
18
Stoughton, Allen. "Fully abstract models of programming languages". Thesis, University of Edinburgh, 1986. http://hdl.handle.net/1842/14496.
Pełny tekst źródła
19
Palmkvist, Viktor. "Building Programming Languages, Construction by Construction". Thesis, KTH, Skolan för elektroteknik och datavetenskap (EECS), 2018. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-231960.
Pełny tekst źródłaStreszczenie:
The task of implementing a programming language is a task that entails a great deal of work. Yet much of this work is similar for different programming languages: most languages require, e.g., parsing, name resolution, type-checking, and optimization. When implementing domain-specific languages (DSLs) the reimplementation of these largely similar tasks seems especially redundant. A number of approaches exist to alleviate this issue, including embedded DSLs, macro-rewriting systems, and more general systems intended for language implementation. However, these tend to have at least one of the following limitations: They present a leaky abstraction, e.g., error messages do not refer to the DSL but rather some other programming language, namely the one used to implement the DSL. They limit the flexibility of the DSL, either to the constructs present in another language, or merely to the syntax of some other language. They see an entire language as the unit of composition. Complete languages are extended with other complete language extensions. Instead, this thesis introduces the concept of a syntax construction, which represents a smaller unit of composition. A syntax construction defines a single language feature, e.g., an if-statement, an anonymous function, or addition. Each syntax construction specifies its own syntax, binding semantics, and runtime semantics, independent of the rest of the language. The runtime semantics are defined using a translation into another target language, similarly to macros. These translations can then be checked to ensure that they preserve binding semantics and introduce no binding errors. This checking ensures that binding errors can be presented in terms of code the programmer wrote, rather than generated code in some underlying language. During evaluation several limitations are encountered. Removing or minimizing these limitations appears possible, but is left for future workAtt implementera ett programmeringsspråk är ett mycket arbetstungt åtagande. Detta trots att mycket av det som behöver göras inte skiljer sig särskilt mycket mellan olika språk, de flesta behöver exempelvis parsning, namnupplösning, typcheckning och optimering. För ett domänspecifikt programmeringsspråk (DSL) är denna upprepning ännu mer tydlig. Det finns ett antal olika metoder för att hantera detta, exempelvis embeddade DSLer, macro-system, och mer generella system för programspråksimplementation. Dessa tenderar dock att ha en eller flera av följande begränsningar: De abstraktioner som introduceras "läcker", felmeddelanden kan exempelvis referera till abstraktioner i ett annat programmeringsspråk, nämligen det som användes för att implementera DSLet. DSLet som implementeras blir begränsat, antingen till vad som finns i implementationsspråket, eller till implementationsspråkets syntax. Ett DSL ses som den minsta hela beståndsdelen i systemet. Om delar av språket ska återanvändas eller inkluderas i ett annat måste hela språket följa med. Denna avhandling introducerar istället syntaxkonstruktioner som minsta beståndsdel. En syntaxkonstruktion representerar en enskild del av ett språk, exempelvis en if-sats, en anonym funktion, eller addition. Varje syntaxkonstruktion definierar sin egen syntax, bindningssemantik och exekveringssemantik, utan referenser till språket som helhet. Exekveringssemantiken liknar en macro, den uttrycks som en översättning till ett implementationsspråk. Tack vare att bindningssemantiken är specifierad kan vi sedan kontrollera översättningen så att den inte kan introducera bindningsfel. Detta medför att felmeddelanden kan referera enbart till kod som programmeraren faktiskt skrev, istället för genererad kod i implementationsspråket. Evalueringen påvisar flera begränsningar med systemet. Begränsningarna tycks lösbara, men detta arbete lämnas till framtiden.
20
Tamarit, Muñoz Salvador. "Analysis Techniques for Concurrent Programming Languages". Doctoral thesis, Universitat Politècnica de València, 2013. http://hdl.handle.net/10251/31651.
Pełny tekst źródłaStreszczenie:
Los lenguajes concurrentes est an cada d a m as presentes en nuestra sociedad,
tanto en las nuevas tecnolog as como en los sistemas utilizados de manera cotidiana. M as a un, dada la actual distribuci on de los sistemas y su arquitectura interna,
cabe esperar que este hecho siga siendo una realidad en los pr oximos a~nos. En
este contexto, el desarrollo de herramientas de apoyo al desarrollo de programas
concurrentes se vuelve esencial. Adem as, el comportamiento de los sistemas concurrentes es especialmente dif cil de analizar, por lo que cualquier herramienta que
ayude en esta tarea, a un cuando sea limitada, ser a de gran utilidad. Por ejemplo, podemos encontrar herramientas para la depuraci on, an alisis, comprobaci on,
optimizaci on, o simpli caci on de programas. Muchas de ellas son ampliamente
utilizadas por los programadores hoy en d a.
El prop osito de esta tesis es introducir, a trav es de diferentes lenguajes de
programaci on concurrentes, t ecnicas de an alisis que puedan ayudar a mejorar la
experiencia del desarrollo y publicaci on de software para modelos concurrentes.
En esta tesis se introducen tanto an alisis est aticos (aproximando todas las posibles ejecuciones) como din amicos (considerando una ejecuci on en concreto). Los
trabajos aqu propuestos di eren lo su ciente entre s para constituir ideas totalmente independientes, pero manteniendo un nexo com un: el hecho de ser un
an alisis para un lenguaje concurrente. Todos los an alisis presentados han sido
de nidos formalmente y se ha probado su correcci on, asegurando que los resultados obtenidos tendr an el grado de abilidad necesario en sistemas que lo requieran,
como por ejemplo, en sistemas cr ticos. Adem as, se incluye la descripci on de las
herramientas software que implementan las diferentes ideas propuestas. Esto le da
al trabajo una utilidad m as all a del marco te orico, permitiendo poner en pr actica
y probar con ejemplos reales los diferentes an alisis.
Todas las ideas aqu presentadas constituyen, por s mismas, propuestas aplicables en multitud de contextos y problemas actuales. Adem as, individualmente sirven de punto de partida para otros an alisis derivados, as como para la adaptaci on
a otros lenguajes de la misma familia. Esto le da un valor a~nadido a este trabajo,
como bien atestiguan algunos trabajos posteriores que ya se est an bene ciando de
los resultados obtenidos en esta tesis.Concurrent languages are increasingly present in our society, both in new technologies and in the systems used on a daily basis. Moreover, given the current systems distribution and their internal architecture, one can expect that this remains so in the coming years. In this context, the development of tools to support the implementation of concurrent programs becomes essential. Futhermore, the behavior of concurrent systems is particularly difficult to analyse, so that any tool that helps in this task, even if in a limited way, will be very useful. For example, one can find tools for debugging, analysis, testing, optimisation, or simplification of programs, which are widely used by programmers nowadays. The purpose of this thesis is to introduce, through various concurrent programming languages, some analysis techniques that can help to improve the experience of the software development and release for concurrent models. This thesis introduces both static (approximating all possible executions) and dynamic (considering a specific execution) analysis. The topics considered here differ enough from each other to be fully independent. Nevertheless, they have a common link: they can be used to analyse properties of a concurrent programming language. All the analyses presented here have been formally defined and their correctness have been proved, ensuring that the results will have the reliability degree which is needed for some systems (for instance, for critical systems). It also includes a description of the software tools that implement the different ideas proposed. This gives the work a usefulness well beyond the theoretical aspect, allowing us to put it in practice and to test the different analyses with real-world examples All the ideas here presented are, by themselves, approaches that can be applied in many current contexts and problems. Moreover, individually they serve as a starting point for other derived analysis, as well as for the adaptation to other languages of the same family. This gives an added value to this work, a fact confirmed by some later works that are already benefiting from the results obtained in this thesis.
Tamarit Muñoz, S. (2013). Analysis Techniques for Concurrent Programming Languages [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/31651
TESIS
21
Das, Barman Kuntal. "Type theoretic semantics for programming languages". Nice, 2004. http://www.theses.fr/2004NICE4029.
Pełny tekst źródłaStreszczenie:
La sémantique des langages de programmation donne la signification des constructions de programme. Les sémantiques opérationnelle et dénotationelle sont les deux principales approches pour la sémantique de langage de programmation. La sémantique opérationnelle est habituellement donnée par des relations inductives. La sémantique dénotationelle est donnée par des fonctions partielles. Mettre en application la sémantique dénotationelle à l’intérieur de la théorie des types est difficile car cette théorie ne supporte que les fonctions totales. Dans cette thèse nous développons une sémantique fonctionnelle pour un petit langage impératif à l’intérieur de la théorie des types et montrons son équivalence avec la sémantique opérationnelle. Nous exploitons ensuite cette sémantique fonctionnelle pour obtenir un outil plus direct de recherche de preuve, tout en développant une manière de décrire et manipuler des expressions inconnues dans le calcul symbolique des programmes pour le développement formel de preuve. Dans une troisième partie, nous adressons le problème de coder des programmes complexes à l’intérieur de la théorie des types et nous montrons comment éviter les limitations des conditions de garde telle qu’elles sont employées dans le calcul des constructions inductivesSemantics of programming languages gives the meaning of program constructs. Operational and denotational semantics are two main approaches for programming languages semantics. Operational semantics is usually given by inductive relations. Denotational semantics is given by partial functions. Implementing the denotational semantics inside type theory is difficult as the type theory expects total functions. In this dissertation we develop a functional semantics for a small imperative language inside type theory and show its equivalence with operational semantics. We then exploit this functional semantics to obtain a more direct proof search tool, while developing a way to describer and manipulate unknown expressions, in the symbolic computation of programs for formal proof development. In a third part, we address the problem of encoding complex programs inside type theory and we show how to circumvent the limitations of guardedness conditions as the are used in the Calculus of Inductive Constructions
22
Lee, Dongho. "Formal Methods for Quantum Programming Languages". Electronic Thesis or Diss., université Paris-Saclay, 2022. http://www.theses.fr/2022UPASG059.
Pełny tekst źródłaStreszczenie:
Le modèle Qram est un modèle de calcul quantique pratique composé d’un ordinateur classique et un processus quantique qui communiquent entre eux. Le programme est exécuté sur l’ordinateur classique. Il envoie les instructions correspondant aux opérateurs quantiques sur le co-processeur, et reçoit le résultat de l’observation de l’état quantique. Ce modèle est considéré comme un modèle standard et plusieurs langages de programmation ont été conçus en basant sur ce modèle. Alors que les programmes dans ce modèle sont capables de réaliser tout calcul quantique grâce à l’usage de la mémoire quantique, il est difficile de les analyser sans l’aide d’un autre ordinateur quantique. Ce problème suscite le besoin pour des méthodes formelles pour les langages programmations quantiques : les outils formels pour raisonner sur l’optimisation du code, pour l’analyser des ressources, et pour spécifier et prouver les propriétés des programmes quantiques. La sémantique catégorique fait partie de ces méthodes qui fait le lien entre les opérateurs quantiques et les programmes et introduit le système logique qui peut décrire les propriétés sur l’état quantique dans le système de types. Bien que plusieurs travaux proposent des sémantiques catégoriques pour les langages de description de circuits quantiques, aucun ne supporte l’usage du résultat d’une mesure au sein du processeur classique (le ”levage dynamique”). Dans cette thèse, nous formalisons le levage dynamique qui transfère le résultat d’observations sur l’état quantique à l’information classique dans un langage de programmation de description de circuit quantique. En suivant l’approche du langage Proto-Quipper, nous définissons un langage typé de description de circuit quantique où l’information quantique levée est incorporée dans la structure ramifiée. Ensuite, le levage dynamique est formalisé dans le cadre de la sémantique opérationnelle et la sémantique catégorique. Notre sémantique catégorique est basée sur le modèle de Francisco Rios et Peter Selinger pour le langage programmation Proto-Quipper- M. Pourtant, pour formaliser le levage dynamique, nous construisons une catégorie de Kleisli en capturant la mesure quantique comme un effet de bord sur une catégorie concrète pour le circuit avec la mesure quantique. Nous prouvons le théorème de correction de la sémantique catégorique par rapport à la sémantique opérationnelleThe quantum random-access machine (QRAM) model is a practical model of quantum computation composed of a classical computer and a quantum processor communicating with each other. The program is executed on the classical computer. It can send instructions corresponding to quantum operations and receive measurement outcomes from the quantum co-processor. This model is expected to be the model of quantum computation in the near future, and a group of quantum programming languages has been developed based on it. While the program in the model has the ability to simulate any quantum circuit with the help of a quantum processor, analyzing the program becomes difficult without relying on another quantum computer. This problem calls for the development of formal methods for quantum programming languages: formal tools to develop and reason on code optimization, analyze resources, and specify and prove the properties of quantum programs. One of these tools is categorical semantics, which links the actions of quantum operators to the meaning of quantum programs and embeds logical systems on quantum states to the type system of the language. Although categorical semantics for quantum programming languages is an established field, dynamic lifting —the ability to use the result of a measurement in the classical host— has so far only been considered in the context of denotational semantics based on operator algebras: a circuit in the model is not a syntactic object that can be manipulated. In this thesis, we formalize dynamic lifting in a quantum circuit-description language which allows programs to transfer the result of measuring quantum data into classical data. Following the Proto-Quipper approach, we define a typed circuit-description language called Proto- Quipper-L, where the lifted data is encoded in the branching structure. Dynamic lifting is then formalized within the operational and categorical semantics. Our categorical semantics is based on the model from Rios&Selinger for Proto-Quipper- M. However, to formalize dynamic lifting, we construct, on top of a concrete category of circuits with measurements, a Kleisli category, capturing the measurement as a side effect. We show the soundness of this semantics with regard to the operational semantics
23
Muff, Urs C. "Backtracking model languages /". Access author, 2000.
Znajdź pełny tekst źródła
24
Wu, James. "A comparison of programming languages for real-time, safety-critical programming". Thesis, National Library of Canada = Bibliothèque nationale du Canada, 2000. http://www.collectionscanada.ca/obj/s4/f2/dsk1/tape3/PQDD_0035/MQ64483.pdf.
Pełny tekst źródła
25
Wu, James 1975. "A comparison of programming languages for real-time, safety-critical programming /". Thesis, McGill University, 1999. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=30772.
Pełny tekst źródłaStreszczenie:
As the number of applications of computers controlling safety-critical operations increases, the need to ensure the safety and reliability of the software that controls those computers increases proportionally. Ultimately, such software properties are the result of appropriate design and implementation. However, certain characteristics of the language in which the software is written can have an impact on how that language facilitates both design and implementation, and how it encourages safety and reliability in the resulting software.This paper explores the language characteristics that can impact the safety and reliability of the software produced. The goal is to provide a set of criteria that can be used for the selection of an appropriate language for real-time, safety-critical development. It proposes a set of characteristics that can affect the suitability of a language to such development, and compares a selection of common programming languages, including Ada, C, C++ and Java, against this framework.
26
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.
Pełny tekst źródłaStreszczenie:
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.
27
Chronaki, Catherine Eleftherios. "Parallelism in declarative languages /". Online version of thesis, 1990. http://hdl.handle.net/1850/10793.
Pełny tekst źródła
28
Carpenter, Steven M. "Visual meta-programming language graphical user interface for generative programming". Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 2002. http://library.nps.navy.mil/uhtbin/hyperion-image/02sep%5FCarpenter.pdf.
Pełny tekst źródłaStreszczenie:
Thesis (M.S. in Computer Science)--Naval Postgraduate School, September 2002.Thesis advisor(s): Mikhail Auguston, Richard Riehle. Includes bibliographical references (p. 89). Also available online.
29
Munden, Gilliad E. "Concurrency Issues in Programmable Brick Languages". Fogler Library, University of Maine, 2000. http://www.library.umaine.edu/theses/pdf/MundenGE2000.pdf.
Pełny tekst źródła
30
Deng, Zhenyue. "Practical secure information flow in programming languages". FIU Digital Commons, 2005. http://digitalcommons.fiu.edu/etd/2771.
Pełny tekst źródłaStreszczenie:
If we classify variables in a program into various security levels, then a secure information flow analysis aims to verify statically that information in a program can flow only in ways consistent with the specified security levels. One well-studied approach is to formulate the rules of the secure information flow analysis as a type system. A major trend of recent research focuses on how to accommodate various sophisticated modern language features. However, this approach often leads to overly complicated and restrictive type systems, . making them unfit for practical use. Also, problems essential to practical use, such as type inference and error reporting, have received little attention. This dissertation identified and solved major theoretical and practical hurdles to the application of secure information flow.
We adopted a minimalist approach to designing our language to ensure a simple lenient type system. We started out with a small simple imperative language and only added features that we deemed most important for practical use. One language feature we addressed is arrays. Due to the various leaking channels associated with array operations, arrays have received complicated and restrictive typing rules in other secure languages. We presented a novel approach for lenient array operations, which lead to simple and lenient typing of arrays.
Type inference is necessary because usually a user is only concerned with the security types for input/output variables of a program and would like to have all types for auxiliary variables inferred automatically. We presented a type inference algorithm B and proved its soundness and completeness. Moreover, algorithm B stays close to the program and the type system and therefore facilitates informative error reporting that is generated in a cascading fashion. Algorithm Band error reporting have been implemented and tested.
Lastly, we presented a novel framework for developing applications that ensure user information privacy. In this framework, core computations are defined as code modules that involve input/output data from multiple parties. Incrementally, secure flow policies are refined based on feedback from the type checking/inference. Core computations only interact with code modules from involved parties through well-defined interfaces. All code modules are digitally signed to ensure their authenticity and integrity.
31
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.
Pełny tekst źródła
32
Clark, Anthony Neil. "Semantic primitives for object-oriented programming languages". Thesis, Queen Mary, University of London, 1996. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.363089.
Pełny tekst źródła
33
SKYRME, ALEXANDRE RUPERT ARPINI. "SAFE RECORD SHARING IN DYNAMIC PROGRAMMING LANGUAGES". PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2015. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=25871@1.
Pełny tekst źródłaStreszczenie:
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIROCOORDENAÇÃO DE APERFEIÇOAMENTO DO PESSOAL DE ENSINO SUPERIOR
PROGRAMA DE EXCELENCIA ACADEMICA
Linguagens de programação dinâmicas estão cada vez mais populares e já foram utilizadas para desenvolver uma ampla gama de aplicações. Enquanto isso, processadores multi-núcleo se tornaram padrão, mesmo em computadores pessoais e dispositivos móveis. Dessa forma, os programadores precisam recorrer ao paralelismo para aprimorar o desempenho de seus programas. Entretanto, a programação concorrente permanece difícil. Adicionalmente, a despeito de avanços em linguagens estáticas, avaliamos que linguagens dinâmicas ainda carecem de suporte adequado à concorrência. Nesta tese argumentamos que o principal problema da programação concorrente é a imprevisibilidade - comportamentos inesperados de programas, tais como retornar valores descabidos. Observamos que a imprevisibilidade é mais provável quando memória compartilhada é utilizada. Consequentemente, propomos um modelo de comunicação para concorrência que visa disciplinar o compartilhamento de memória em linguagens dinâmicas. O modelo é baseado nos padrões emergentes de concorrência de não compartilhar dados por padrão, imutabilidade de dados e tipos e efeitos (que transformamos em capacidades). Ele demanda a utilização de objetos compartilháveis para compartilhar dados e utiliza troca de mensagens para comunicação entre fluxos de execução. Objetos compartilháveis podem ser compartilhados apenas para leitura ou para leitura e escrita, o que permite acesso individual de escrita e acessos paralelos de leitura. Implementamos um protótipo em Lua para experimentar com o modelo na prática, bem como para conduzir uma avaliação geral de desempenho. A avaliação demonstra que há benefícios na utilização de memória compartilhada, mas ao mesmo tempo revela que os controles utilizados para assegurar a disciplina ocasionam um impacto de desempenho.
Dynamic programming languages have become increasingly popular and have been used to implement a range of applications. Meanwhile, multicore processors have become the norm, even for desktop computers and mobile devices. Therefore, programmers must turn to parallelism as a means to improve performance. However, concurrent programming remains difficult. Besides, despite improvements in static languages, we find dynamic languages are still lacking in concurrency support. In this thesis, we argue that the main problem with concurrent programming is unpredictability - unexpected program behaviors, such as returning out-of-thin-air values. We observe that unpredictability is most likely to happen when shared memory is used. Consequently, we propose a concurrency communication model to discipline shared memory in dynamic languages. The model is based on the emerging concurrency patterns of not sharing data by default, data immutability, and types and effects (which we turn into capabilities). It mandates the use of shareable objects to share data. Besides, it establishes that the only means to share a shareable object is to use message passing. Shareable objects can be shared as read-write or read-only, which allows both individual read-write access and parallel read-only access to data. We implemented a prototype in Lua, called luashare, to experiment with the model in practice, as well as to carry out a general performance evaluation. The evaluation showed us that safe data sharing makes it easier to allow for communication among threads. Besides, there are situations where copying data around is simply not an option. However, enforcing control over shareable objects has a performance cost, in particular when working with nested objects.
34
Abou-Saleh, Faris. "A coalgebraic semantics for imperative programming languages". Thesis, Imperial College London, 2014. http://hdl.handle.net/10044/1/13693.
Pełny tekst źródłaStreszczenie:
In the theory of programming languages, one often takes two complementary perspectives. In operational semantics, one defines and reasons about the behaviour of programs; and in denotational semantics, one abstracts away implementation details, and reasons about programs as mathematical objects or denotations. The denotational semantics should be compositional, meaning that denotations of programs are determined by the denotations of their parts. It should also be adequate with respect to operational equivalence: programs with the same denotation should be behaviourally indistinguishable. One often has to prove adequacy and compositionality independently for different languages, and the proofs are often laborious and repetitive. These proofs were provided systematically in the context of process algebras by the mathematical operational semantics framework of Turi and Plotkin – which represented transition systems as coalgebras, and program syntax by free algebras; operational specifications were given by distributive laws of syntax over behaviour. By framing the semantics on this abstract level, one derives denotational and operational semantics which are guaranteed to be adequate and compositional for a wide variety of examples. However, despite speculation on the possibility, it is hard to apply the framework to programming languages, because one obtains undesirably fine-grained behavioural equivalences, and unconventional notions of operational semantics. Moreover, the behaviour of these languages is often formalised in a different way – such as computational effects, which may be thought of as an interface between programs and external factors such as non-determinism or a variable store; and comodels, or transition systems which implement these effects. This thesis adapts the mathematical operational semantics framework to provide semantics for various classes of programming languages. After identifying the need for such an adaptation, we show how program behaviour may be characterised by final coalgebras in suitably order- enriched Kleisli categories. We define both operational and denotational semantics, first for languages with syntactic effects, and then for languages with effects and/or comodels given by a Lawvere theory. To ensure adequacy and compositionality, we define concrete and abstract operational rule-formats for these languages, based on the idea of evaluation-in-context; we give syntactic and then categorical proofs that those properties are guaranteed by operational specifications in these rule-formats.
35
Schweimeier, Ralf. "Categorical and graphical models of programming languages". Thesis, University of Sussex, 2001. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.366059.
Pełny tekst źródła
36
Huxford, David C. Jr. "Selection of programming languages for structural engineering". Thesis, Virginia Tech, 1987. http://hdl.handle.net/10919/45671.
Pełny tekst źródłaStreszczenie:
This thesis presents the concepts of structured programming and illustrates how they can be used to develop efficient and reliable programs and aid in language selection. Topics are presented and used to compare several languages with each other rather than with some abstract ideal.
Structured design is a set of concepts that aids the decomposition of a problem using basic block structures into manageable subproblems. Decomposition is a process whereby the large problem is decomposed into components that can be easily understood. This process is continued until the smallest component can be represented by a unit of code performing a single action. By means of the four basic building blocks the atom, concatenation, selection, and repetition one can produce a correct well structured program. In addition, the top-down approach and/or the bottom up approach can assist in producing a structured program that is easy to design, code, debug, modify, and maintain. These approaches minimize the number of bugs and the time spent in the debugging process. Various testing techniques supporting the structured programming process are presented to aid in determining a program's correctness.
The languages must support structured programming. Microsoft FORTRAN, Microsoft QuickBASIC, Turbo Pascal, and Microsoft C are analyzed and compared on the basis of syntactic style, semantic structure, data types and manipulation, application facilities, and application requirements. Example programs are presented to reinforce these concepts. Frame programs are developed in these languages and are used to assist in the language evaluation.Master of Science
37
Marenych, M. S. "Distribution of programming languages: history and trends". Thesis, Київський національний університет технологій та дизайну, 2018. https://er.knutd.edu.ua/handle/123456789/11426.
Pełny tekst źródła
38
Lewis, E. Christopher. "Achieving robust performance in parallel programming languages /". Thesis, Connect to this title online; UW restricted, 2001. http://hdl.handle.net/1773/6996.
Pełny tekst źródła
39
Kelso, Joel. "A visual programming environment for functional languages". Thesis, Kelso, Joel (2002) A visual programming environment for functional languages. PhD thesis, Murdoch University, 2002. https://researchrepository.murdoch.edu.au/id/eprint/50254/.
Pełny tekst źródłaStreszczenie:
The purported advantages of Visual Programming, as applied to general purpose programmjng languages, have remained largely unfulfilled. The essence of this thesis is that functional programming languages have at least one natural visual representation, and that a useful programming environment can be based upon this representation.
This thesis describes the implementation of a Visual Functional Programming Environment (VFPE). The programming environment has several significant features.
•The environment includes a program editor that is inherently visual and interactive: syntactic program components have a visual representation and are assembled via a graphical interface.
•The program editor incorporates a static analysis system that tracks types for the whole program, making it impossible to construct syntactically incorrect or type-incorrect programs. Type information is continually and explicitly available to the programmer.
•The environment implements an implicitly typed higher-order purely functional language without conforming exactly to any particular language with respect to syntactic structures or reduction semantics.
•Programs can be output as source code for an existing functional language.
•The visual representation allows for continued experimentation with new syntactic features. Some currently included features are algebraic data types, pattern matching, and guarded expressions.
•The environment includes a visual interpreter which allows any expression to be reduced in source form, with a choice of reduction behaviors.
Please note that this thesis was written to be read in conjunction with a set of animated examples. The examples should be present on some form of digital media accompanying this thesis: at the points indicated in the thesis text, the reader should view the associated example.
40
Jonsson, Alexander. "The Usefulness of Programming Languages Beyond Java". Thesis, Linköpings universitet, Programvara och system, 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-157413.
Pełny tekst źródłaStreszczenie:
Beyond Java, new programming languages running on the Java virtual machine (JVM) have been developed, such as Kotlin, Scala, JRuby and Clojure amongst others. Since all those languages compile to Java bytecode, they should theoretically be able to be used together in a project. This paper investigates if it is possible and what benefits it gives using those programming languages together in a project. The languages chosen to be used together were Jython, Scala and Kotlin. An experiment was conducted where in a single project, each programming language was assigned a problem to be solved. The experiment was then conducted in two iterations where in each iteration, the problems to be solved was assigned to a different programming language. From the experiment it was shown that using those languages together in a project was possible but resulted in some complications needed to be solved. It was also shown that the following division amongst the languages worked best in the present use case: Jython for graphical handling, Scala for calculating and computing and Kotlin for data-handling.
41
Eades, Harley D. III. "The semantic analysis of advanced programming languages". Diss., University of Iowa, 2014. https://ir.uiowa.edu/etd/1312.
Pełny tekst źródłaStreszczenie:
We live in a time where computing devices power essential systems of our society: our automobiles, our airplanes and even our medical services. In these safety-critical systems, bugs do not just cost money to fix; they have a potential to cause harm, even death. Therefore, software correctness is of paramount importance. Existing mainstream programming languages do not support software verification as part of their design, but rely on testing, and thus cannot completely rule out the possibility of bugs during software development. To fix this problem we must reshape the very foundation on which programming languages are based. Programming languages must support the ability to verify the correctness of the software developed in them, and this software verification must be possible using the same language the software is developed in. In the first half of this dissertation we introduce three new programming languages: Freedom of Speech, Separation of Proof from Program, and Dualized Type Theory. The Freedom of Speech language separates a logical fragment from of a general recursive programming language, but still allowing for the types of the logical fragment to depend on general recursive programs while maintaining logical consistency. Thus, obtaining the ability to verify properties of general recursion programs. Separation of Proof from Program builds on the Freedom of Speech languageby relieving several restrictions, and adding a number of extensions. Finally, Dualized Type Theory is a terminating functional programming language rich in constructive duality, and shows promise of being a logical foundation of induction and coninduction.
These languages have the ability to verify properties of software, but how can we trust this verification? To be able to put our trust in these languages requires that the language be rigorously and mathematically defined so that the programming language itself can be studied as a mathematical object. Then we must show one very important property, logical consistency of the fragment of the programming language used to verify mathematical properties of the software. In the second half of this dissertation we introduce a well-known proof technique for showing logical consistency called hereditary substitution. Hereditary substitution shows promise of being less complex than existing proof techniques like the Tait-Girard Reducibility method. However, we are unsure which programming languages can be proved terminating using hereditary substitution. Our contribution to this line of work is the application of the hereditary substitution technique to predicative polymorphic programming languages, and the first proof of termination using hereditary substitution for a classical type theory.
42
MARANHÃO, Antonio Augusto Rodrigues de Albuquerque. "Design of a modular multiparadigm programming language for teaching programming concepts". Universidade Federal de Pernambuco, 2004. https://repositorio.ufpe.br/handle/123456789/2468.
Pełny tekst źródłaStreszczenie:
Made available in DSpace on 2014-06-12T15:58:29Z (GMT). No. of bitstreams: 2
arquivo4579_1.pdf: 1011460 bytes, checksum: 01e8646fc6f336c9eb54adf769b7baf0 (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2004A criação de uma linguagem de programação pode ser comparada ao desenvolvimento de um sistema computacional. Sendo assim, o projeto e a implementação da linguagem devem atender a um conjunto de requisitos. Alguns deles estão relacionados às propriedades que a linguagem desenvolvida deve apresentar, como expressividade, capacidade de aprendizagem e produtividade. Outro grupo de requisitos compreende aqueles comuns ao desenvolvimento da maioria dos softwares, como extensibilidade, modularidade e reuso de código. Este segundo grupo de requisitos pode ser obtido através do uso de técnicas modernas de engenharia de software. Neste trabalho, apresentamos o desenvolvimento de uma linguagem multiparadigma modular que faz uso de programação Orientada a Objetos, design patterns e um paradigma de programação mais recente chamado Programação Orientada a Aspectos. A linguagem, que também pode ser vista como um conjunto de linguagens, é desenvolvida de maneira incremental, partindo de uma simples linguagem de expressões até linguagens mais complexas representando alguns dos mais representativos paradigmas de programação, finalizando com o desenvolvimento de linguagens multiparadigmas. Esta família de linguagens é criada através da integração de componentes que representam conceitos de programação. A modularidade obtida através do design proposto possibilita o reuso destes componentes na criação de diferentes linguagens, mesmo que pertencentes a diferentes paradigmas. Adicionalmente, é possível a evolução ortogonal das linguagens, já que a inclusão de novos conceitos é obtida através da simples inclusão dos componentes correspondentes, sem comprometer o funcionamento dos componentes já utilizados. A abordagem proposta para o design e implementação da linguagem também se mostrou bastante útil no ensino de conceitos de programação, já que oferece um ambiente uniforme e extensível para a prática e exploração dos conceitos pelos estudantes. Dessa forma, os estudantes não precisam lidar com diferentes notações e ambientes de desenvolvimento ao abordarem conceitos relacionados a diversos paradigmas
43
Judd, Mark. "A view of types and parameterization in programming languages /". Thesis, McGill University, 1985. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=63360.
Pełny tekst źródła
44
Santi, Andrea <1985>. "Engineering Agent-Oriented Technologies and Programming Languages for Computer Programming and Software Development". Doctoral thesis, Alma Mater Studiorum - Università di Bologna, 2013. http://amsdottorato.unibo.it/5634/1/santi_andrea_tesi.pdf.
Pełny tekst źródłaStreszczenie:
Mainstream hardware is becoming parallel, heterogeneous, and distributed on every desk, every home and in every pocket. As a consequence, in the last years software is having an epochal turn toward concurrency, distribution, interaction which is pushed by the evolution of hardware architectures and the growing of network availability. This calls for introducing further abstraction layers on top of those provided by classical mainstream programming paradigms, to tackle more effectively the new complexities that developers have to face in everyday programming. A convergence it is recognizable in the mainstream toward the adoption of the actor paradigm as a mean to unite object-oriented programming and concurrency. Nevertheless, we argue that the actor paradigm can only be considered a good starting point to provide a more comprehensive response to such a fundamental and radical change in software development. Accordingly, the main objective of this thesis is to propose Agent-Oriented Programming (AOP) as a high-level general purpose programming paradigm, natural evolution of actors and objects, introducing a further level of human-inspired concepts for programming software systems, meant to simplify the design and programming of concurrent, distributed, reactive/interactive programs. To this end, in the dissertation first we construct the required background by studying the state-of-the-art of both actor-oriented and agent-oriented programming, and then we focus on the engineering of integrated programming technologies for developing agent-based systems in their classical application domains: artificial intelligence and distributed artificial intelligence. Then, we shift the perspective moving from the development of intelligent software systems, toward general purpose software development. Using the expertise maturated during the phase of background construction, we introduce a general-purpose programming language named simpAL, which founds its roots on general principles and practices of software development, and at the same time provides an agent-oriented level of abstraction for the engineering of general purpose software systems.
45
Santi, Andrea <1985>. "Engineering Agent-Oriented Technologies and Programming Languages for Computer Programming and Software Development". Doctoral thesis, Alma Mater Studiorum - Università di Bologna, 2013. http://amsdottorato.unibo.it/5634/.
Pełny tekst źródłaStreszczenie:
Mainstream hardware is becoming parallel, heterogeneous, and distributed on every desk, every home and in every pocket. As a consequence, in the last years software is having an epochal turn toward concurrency, distribution, interaction which is pushed by the evolution of hardware architectures and the growing of network availability. This calls for introducing further abstraction layers on top of those provided by classical mainstream programming paradigms, to tackle more effectively the new complexities that developers have to face in everyday programming. A convergence it is recognizable in the mainstream toward the adoption of the actor paradigm as a mean to unite object-oriented programming and concurrency. Nevertheless, we argue that the actor paradigm can only be considered a good starting point to provide a more comprehensive response to such a fundamental and radical change in software development. Accordingly, the main objective of this thesis is to propose Agent-Oriented Programming (AOP) as a high-level general purpose programming paradigm, natural evolution of actors and objects, introducing a further level of human-inspired concepts for programming software systems, meant to simplify the design and programming of concurrent, distributed, reactive/interactive programs. To this end, in the dissertation first we construct the required background by studying the state-of-the-art of both actor-oriented and agent-oriented programming, and then we focus on the engineering of integrated programming technologies for developing agent-based systems in their classical application domains: artificial intelligence and distributed artificial intelligence. Then, we shift the perspective moving from the development of intelligent software systems, toward general purpose software development. Using the expertise maturated during the phase of background construction, we introduce a general-purpose programming language named simpAL, which founds its roots on general principles and practices of software development, and at the same time provides an agent-oriented level of abstraction for the engineering of general purpose software systems.
46
Wright, David A. "An integration of reduction and logic for programming languages". Thesis, Rhodes University, 1988. http://hdl.handle.net/10962/d1002035.
Pełny tekst źródłaStreszczenie:
A new declarative language is presented which captures the expressibility of both logic programming languages and functional languages. This is achieved by conditional graph rewriting, with full unification as the parameter passing mechanism. The syntax and semantics are described both formally and informally, and examples are offered to support the expressibility claim made above. The language design is of further interest due to its uniformity and the inclusion of a novel mechanism for type inference in the presence of derived type hierarchies
47
Mountjoy, Jon-Dean. "Static analysis of functional languages". Thesis, Rhodes University, 1994. http://hdl.handle.net/10962/d1006690.
Pełny tekst źródłaStreszczenie:
Static analysis is the name given to a number of compile time analysis techniques used to automatically generate information which can lead to improvements in the execution performance of function languages. This thesis provides an introduction to these techniques and their implementation. The abstract interpretation framework is an example of a technique used to extract information from a program by providing the program with an alternate semantics and evaluating this program over a non-standard domain. The elements of this domain represent certain properties of interest. This framework is examined in detail, as well as various extensions and variants of it. The use of binary logical relations and program logics as alternative formulations of the framework , and partial equivalence relations as an extension to it, are also looked at. The projection analysis framework determines how much of a sub-expression can be evaluated by examining the context in which the expression is to be evaluated, and provides an elegant method for finding particular types of information from data structures. This is also examined. The most costly operation in implementing an analysis is the computation of fixed points. Methods developed to make this process more efficient are looked at. This leads to the final chapter which highlights the dependencies and relationships between the different frameworks and their mathematical disciplines.KMBT_223
48
Schütz, Marko. "Analyzing demand in non-strict functional programming languages /". Frankfurt a. M, 2000. http://deposit.ddb.de/cgi-bin/dokserv?idn=979469546.
Pełny tekst źródła
49
Au, Kwok Tat Peter. "Portable implementations of nested data-parallel programming languages". Thesis, Imperial College London, 1999. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.325055.
Pełny tekst źródła
50
Millington, M. "Theories of translation correctness for concurrent programming languages". Thesis, University of Edinburgh, 1985. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.370892.
Pełny tekst źródła