541 |
Programování na základní škole a rozvoj algoritmického myšlení žáků / Programming in elementary school and development of students' algorithmic thinkingMilichovská, Lucie January 2020 (has links)
This thesis deals with development of algorithmic thinking and teaching programming in elementary school. It focuses on available ways and tools suitable for classes. The practical part of the thesis is focused on children's programming language Scratch, which is one of the tools designed to be used for teaching. The main goal is to create comprehensive collections of tasks that develop algorithmic thinking of pupils aged 9 - 10 years. The tasks get more complex gradually so that the pupils don't need any previous programming experience. Also they are designed so that they can be solved without the assistance of a teacher. All the tasks were checked against a set of pupils in the given age range. The collection of tasks is also made available as a web presentation for the ease of further use.
|
542 |
Language Constructs for Safe Parallel Programming on Multi-CoresÖstlund, Johan January 2016 (has links)
The last decade has seen the transition from single-core processors to multi-cores and many-cores. This move has by and large shifted the responsibility from chip manufacturers to programmers to keep up with ever-increasing expectations on performance. In the single-core era, improvements in hardware capacity could immediately be leveraged by an application: faster machine - faster program. In the age of the multi-cores, this is no longer the case. Programs must be written in specific ways to utilize available parallel hardware resources. Programming language support for concurrent and parallel programming is poor in most popular object-oriented programming languages. Shared memory, threads and locks is the most common concurrency model provided. Threads and locks are hard to understand, error-prone and inflexible; they break encapsulation - the very foundation of the object-oriented approach. This makes it hard to break large complex problems into smaller pieces which can be solved independently and composed to make a whole. Ubiquitous parallelism and object-orientation, seemingly, do not match. Actors, or active objects, have been proposed as a concurrency model better fit for object-oriented programming than threads and locks. Asynchronous message passing between actors each with a logical thread of control preserves encapsulation as objects themselves decide when messages are executed. Unfortunately most implementations of active objects do not prevent sharing of mutable objects across actors. Sharing, whether on purpose or by accident, exposes objects to multiple threads of control, destroying object encapsulation. In this thesis we show techniques for compiler-enforced isolation of active objects, while allowing sharing and zero-copy communication of mutable data in the cases where it is safe to do so. We also show how the same techniques that enforce isolation can be utilized internal to an active object to allow data race-free parallel message processing and data race-free structured parallel computations. This overcomes the coarse-grained nature of active object parallelism without compromising safety. / UPMARC
|
543 |
Extensible automated constraint modelling via refinement of abstract problem specificationsAkgün, Özgür January 2014 (has links)
Constraint Programming (CP) is a powerful technique for solving large-scale combinatorial (optimisation) problems. Constraint solving a given problem proceeds in two phases: modelling and solving. Effective modelling has an huge impact on the performance of the solving process. This thesis presents a framework in which the users are not required to make modelling decisions, concrete CP models are automatically generated from a high level problem specification. In this framework, modelling decisions are encoded as generic rewrite rules applicable to many different problems. First, modelling decisions are divided into two broad categories. This categorisation guides the automation of each kind of modelling decision and also leads us to the architecture of the automated modelling tool. Second, a domain-specific declarative rewrite rule language is introduced. Thanks to the rule language, automated modelling transformations and the core system are decoupled. The rule language greatly increases the extensibility and maintainability of the rewrite rules database. The database of rules represents the modelling knowledge acquired after analysis of expert models. This database must be easily extensible to best benefit from the active research on constraint modelling. Third, the automated modelling system Conjure is implemented as a realisation of these ideas; having an implementation enables empirical testing of the quality of generated models. The ease with which rewrite rules can be encoded to produce good models is shown. Furthermore, thanks to the generality of the system, one needs to add a very small number of rules to encode many transformations. Finally, the work is evaluated by comparing the generated models to expert models found in the literature for a wide variety of benchmark problems. This evaluation confirms the hypothesis that expert models can be automatically generated starting from high level problem specifications. An method of automatically identifying good models is also presented. In summary, this thesis presents a framework to enable the automatic generation of efficient constraint models from problem specifications. It provides a pleasant environment for both problem owners and modelling experts. Problem owners are presented with a fully automated constraint solution process, once they have a precise description of their problem. Modelling experts can now encode their precious modelling expertise as rewrite rules instead of merely modelling a single problem; resulting in reusable constraint modelling knowledge.
|
544 |
Locating Potential Aspect Interference Using Clustering AnalysisBennett, Brian Todd 01 May 2015 (has links)
Software design continues to evolve from the structured programming paradigm of the 1970s and 1980s and the object-oriented programming (OOP) paradigm of the 1980s and 1990s. The functional decomposition design methodology used in these paradigms reduced the prominence of non-functional requirements, which resulted in scattered and tangled code to address non-functional elements. Aspect-oriented programming (AOP) allowed the removal of crosscutting concerns scattered throughout class code into single modules known as aspects. Aspectization resulted in increased modularity in class code, but introduced new types of problems that did not exist in OOP. One such problem was aspect interference, in which aspects meddled with the data flow or control flow of a program. Research has developed various solutions for detecting and addressing aspect interference using formal design and specification methods, and by programming techniques that specify aspect precedence. Such explicit specifications required practitioners to have a complete understanding of possible aspect interference in an AOP system under development. However, as system size increased, understanding of possible aspect interference could decrease. Therefore, practitioners needed a way to increase their understanding of possible aspect interference within a program. This study used clustering analysis to locate potential aspect interference within an aspect-oriented program under development, using k-means partitional clustering. Vector space models, using two newly defined metrics, interference potential (IP) and interference causality potential (ICP), and an existing metric, coupling on advice execution (CAE), provided input to the clustering algorithms. Resulting clusters were analyzed via an internal strategy using the R-Squared, Dunn, Davies-Bouldin, and SD indexes. The process was evaluated on both a smaller scale AOP system (AspectTetris), and a larger scale AOP system (AJHotDraw). By seeding potential interference problems into these programs and comparing results using visualizations, this study found that clustering analysis provided a viable way for detecting interference problems in aspect-oriented software. The ICP model was best at detecting interference problems, while the IP model produced results that were more sporadic. The CAE clustering models were not effective in pinpointing potential aspect interference problems. This was the first known study to use clustering analysis techniques specifically for locating aspect interference.
|
545 |
LF : a language for reliable embedded systemsVan Riet, F. A. 11 1900 (has links)
Thesis (MSc)--University of Stellenbosch, 2001. / ENGLISH ABSTRACT: Computer-aided verification techniques, such as model checking, are often considered essential
to produce highly reliable software systems. Modern model checkers generally require models to
be written in eSP-like notations. Unfortunately, such systems are usually implemented using
conventional imperative programming languages. Translating the one paradigm into the other is
a difficult and error prone process.
If one were to program in a process-oriented language from the outset, the chasm between implementation
and model could be bridged more readily. This would lead to more accurate models
and ultimately more reliable software.
This thesis covers the definition of a process-oriented language targeted specifically towards embedded
systems and the implementation of a suitable compiler and run-time system.
The language, LF, is for the most part an extension of the language Joyce, which was defined by
Brinch Hansen. Both LF and Joyce have features which I believe make them easier to use than
other esp based languages such as occam. An example of this is a selective communication
primitive which allows for both input and output guards which is not supported in occam.
The efficiency of the implementation is important. The language was therefore designed to be
expressive, but constructs which are expensive to implement were avoided. Security, however, was
the overriding consideration in the design of the language and runtime system.
The compiler produces native code. Most other esp derived languages are either interpreted or
execute as tasks on host operating systems. Arguably this is because most implementations of
esp and derivations thereof are for academic purposes only. LF is intended to be an implementation
language.
The performance of the implementation is evaluated in terms of practical metries such as the
time needed to complete communication operations and the average time needed to service an
interrupt. / AFRIKAANSE OPSOMMING: Rekenaar ondersteunde verifikasietegnieke soos programmodellering, is onontbeerlik in die ontwikkeling
van hoogs betroubare programmatuur. In die algemeen, aanvaar programme wat modelle
toets eSP-agtige notasie as toevoer. Die meeste programme word egter in meer konvensionele
imperatiewe programmeertale ontwikkel. Die vertaling vanuit die een paradigma na die ander is
'n moelike proses, wat baie ruimte laat vir foute.
Indien daar uit die staanspoor in 'n proses gebaseerde taal geprogrammeer word, sou die verwydering
tussen model en program makliker oorbrug kon word. Dit lei tot akkurater modelle en
uiteindelik tot betroubaarder programmatuur.
Die tesis ondersoek die definisie van 'n proses gebaseerde taal, wat gemik is op ingebedde programmatuur.
Verder word die implementasie van 'n toepaslike vertaler en looptyd omgewing ook
bespreek.
Die taal, LF, is grotendeels gebaseer op Joyce, wat deur Brinch Hansen ontwikkel is. Joyce en op
sy beurt LF, is verbeterings op ander esp verwante tale soos occam. 'n Voorbeeld hiervan is 'n
selektiewe kommunikasieprimitief wat die gebruik van beide toevoer- en afvoerwagte ondersteun.
Omdat 'n effektiewe implementasie nagestreef word, is die taalontwerp om so nadruklik moontlik
te wees, sonder om strukture in te sluit wat oneffektief is om te implementeer. Sekuriteit was egter
die oorheersende oorweging in die ontwerp van die taal en looptyd omgewing.
Die vertaler lewer masjienkode, terwyl die meeste ander implementasies van eSP-agtige tale
geinterpreteer word of ondersteun word as prosesse op 'n geskikte bedryfstelsel- die meeste
eSP-agtige tale word slegs vir akademiese doeleindes aangewend. LF is by uitstek ontwerp
as implementasie taal.
Die evaluasie van die stelsel se werkverrigting is gedoen aan die hand van praktiese maatstawwe
soos die tyd wat benodig word vir kommunikasie, sowel as die gemiddelde tyd benodig vir die
hantering van onderbrekings.
|
546 |
Terminaison des systèmes de réécriture d'ordre supérieur basée sur la notion de clôture de calculabilitéBlanqui, Frédéric 13 July 2012 (has links) (PDF)
Dans ce document, nous montrons comment la notion de calculabilité introduite par W. W. Tait et étendue par Girard aux types polymorphes peut être utilisée et facilement étendue pour montrer la terminaison de différents types de relations de réécriture, y compris avec filtrage sur des symboles définis, filtrage d'ordre supérieur ou réécriture de classe modulo certaines théories équationnelles. Nous montrons également que la notion de clôture de calculabilité donne lieu a une relation bien fondée incluant l'extension à l'ordre supérieur par J.-P. Jouannaud et A. Rubio de l'ordre récursif sur les chemins de N. Dershowitz.
|
547 |
Vers une méthodologie dédiée à l'orchestration d'entités communicantesDrey, Zoé 22 September 2010 (has links) (PDF)
Les technologies omniprésentes dans notre environnement intègrent des éléments logiciels facilitant leur utilisation. Ces technologies offrent un vaste laboratoire d'expérimentation pour la recherche et en particulier pour l'informatique appliquée. Ces technologies sont un support évident pour rendre des services aux personnes dans leur vie quotidienne. Ces services concernent divers champs d'applications, chacun servant des objectifs spécifiques : confort, sécurité, accès à l'information ou encore assistance à la personne. Puisque les applications offrant ces services sont intimement liées aux besoins des utilisateurs, il est indispensable qu'elles s'adaptent facilement à leurs besoins. Une manière de répondre à ce défi est de proposer à l'utilisateur des outils pour programmer lui-même ses applications. Notre contribution consiste non seulement à définir un tel outil, sous la forme d'un langage visuel paramétré par un champ d'applications, mais aussi à proposer une méthodologie dont l'objectif est de guider un utilisateur dans la programmation d'applications à l'aide de ce langage. Cette méthodologie est dédiée à l'orchestration d'entités communicantes : elles représentent les technologies déployées dans nos environnements. Notre approche, associant une méthodologie à un langage, est accessible à un programmeur novice et suffisamment expressive pour traiter divers champs d'applications. Afin d'augmenter la confiance de l'utilisateur dans le développement de ses applications, nous étendons la méthodologie en proposant une approche de développement dirigée par la vérification de quelques propriétés. Cette vérification est permise par la sémantique du langage, formellement définie.
|
548 |
Semantic Database Model Language (SDML): grammar specification and parserLane, Richard Vernon. January 1986 (has links)
Call number: LD2668 .T4 1986 L364 / Master of Science / Computing and Information Sciences
|
549 |
Reaper – Toward Automating Mobile Cloud CommunicationWard, Daniel R 06 August 2013 (has links)
Mobile devices connected to cloud based services are becoming a mainstream method of delivery up-to-date and context aware information to users. Connecting mobile applications to cloud service require significant developer effort. Yet this communication code usually follows certain patterns, varying accordingly to the specific type of data sent and received from the server. By analyzing the causes of theses variations, we can create a system that can automate the code creation for communication from a mobile device to a cloud server. To automate code creation, a general pattern must extracted. This general solution can then be applied to any database configuration. Automating this process frees up valuable development time, allowing developers to make other parts of the application and/or backend service a better experience for the end user.
|
550 |
[en] A STUDY N APIS FOR SCRIPTING LANGUAGES / [pt] ESTUDO SOBRE APIS DE LINGUAGENS DE SCRIPTHISHAM HASHEM MUHAMMAD 26 January 2007 (has links)
[pt] Um cenário comum atualmente é o de aplicações
desenvolvidas usando duas
linguagens de programação a fim de otimizar partes onde o
desempenho é
crítico e permitir extensibilidade através de scripts
escritos pelo usuário.
Há várias formas de se obter esse tipo de
interoperabilidade; idealmente,
entretanto, uma linguagem deve prover uma interface de
acesso externo
(foreign language interface, FLI) que permita ao
programador receber e
enviar tanto chamadas como dados para outra linguagem.
Este trabalho discute as principais questões envolvendo o
projeto de APIs
para integração de ambientes de execução de linguagens em
aplicações C.
Apresentamos os principais problemas enfrentados na
interação entre código
executando em um ambiente com características
inerentemente dinâmicas
como o de uma linguagem de script com código C. Comparamos
aqui as
abordagens empregadas por cinco linguagens no tratamento
da comunicação
entre os espaços de dados de C e do ambiente de execução
embutido e as
conseqüências destas abordagens no gerenciamento de
memória, bem como
no compartilhamento de código entre a aplicação C e o da
linguagem de
script.
Ilustramos as diferenças das APIs destas linguagens e o
impacto destas
no código resultante de uma aplicação C através de um
estudo de caso.
Diferentes linguagens de script são embutidas como plugins
de uma mesma
biblioteca, que por sua vez expõe a aplicações clientes
uma API genérica de
scripting. Assim, o código de cada plugin permite observar
de forma clara
e isolada os procedimentos adotados em cada linguagem para
chamada de
funções, registro de funçoes C e conversão de dados entre
os ambientes. / [en] Applications written in two programming languages, in
order to optimize
parts where performance is critical or to obtain
extensibility through userwritten
scripts, are commonplace nowadays. There are several ways
to
obtain this kind of interoperability; ideally, however, a
language should
provide a foreign language interface (FLI), allowing the
programmer to send
and receive both data and function calls to the external
language.
This work discusses the main issues involving the design
of APIs for the
integration of language environments within C
applications. We present the
main problems faced in the interaction between code
executed in an environment
with inherently dynamic characteristics such as a
scripting language
and C code. We compare the approaches employed by five
languages when
handling communication between the data spaces of C and
the embedded
runtime environment and the consequences of these
approaches in memory
management, as well as sharing of code between the C
application and that
from the scripting language.
We illustrate the differences of the APIs of those
languages and their impact
in the resulting code of a C application through a case
study. Different
scripting languages were embedded as plugins for a
library, which on its turn
exposes to client applications a generic scripting API.
This way, the code of
each plugin allows us to observe in a clear and isolated
way the procedures
adopted by each language for function calls, registration
of C functions and
conversion of data between the environments.
|
Page generated in 0.0478 seconds