The topic of the thesis are domain-specific languages (DSL) and their use in software development. The target audience are developers interested in learning more about this progressive area of software development. It starts with a necessary theoretical introduction to programming languages. Then, a classification of DSLs is given and software development methodologies based on DSLs are described, notably Language Oriented Programming and Intentional Programming. Another important piece in construction of domain-specific langauges -- the language workbench is also described. In the next chapter, several important tools for DSL creation are presented, described and compared. Each of the tools represents a different possible approach to designing DSLs -- textual, projectional or graphical. The last chapter of the thesis contains a practical example of a DSL implementation in the Meta Programming System by Jet- Brains and Xtext from Eclipse. A domain-specific language for the description of questionnaires is designed from scratch and a code generator for that language is created. A comparison of the DSL based technique to traditional software development techniques is given and the tools used are compared.

Diploma thesis is focused on elaboration of database solution for saving measured data. In theory part analyses database query language and database management system Microsoft SQL Server 2017. Further in theory part is focused on programming environment for application development using C# .NET. Thesis includes database solution for saving measured data, service console application for saving data into the database and user application for creating new measuring, representation of data and user administration.

The work is solving the design and implementation of application for presentation measured data and control of A2000 device trought web interface. For connecting to internet is used a module LanReach by company Connectone. Measured values are displayed on the website or send via e-mail messages and saved on FTP server.

This thesis describes a conceptual design of touchless fingerprint sensor and design, implementation and testing of its firmware, which is a composition of hardware implemented in VHDL and a program implemented in C. Result of this thesis can be used as the first step of building an industrial solution.

Cette thèse porte sur l'analyse statique de code par typage dans le but de détecter les erreurs dans les programmes avant leur exécution. Plus précisément, nous nous intéressons ici au domaine du sous-typage, dans lequel les propriétés du code sont représentées par des ensemble de contraintes de la forme (t1 <= t2). Nos mécanismes de vérification sont alors basés sur l'agrégation de contraintes de sous-typage et la vérification de leur compatibilité par saturation. Le langage de base sur lequel nous travaillons est un ML étendu, muni de variants et d'un mécanisme de filtrage de motifs. Nous commençons par définir un formalisme nous permettant d'exprimer nos systèmes de types sous forme de règles d'inférences. Ce formalisme présente l'avantage d'être suffisamment souple pour nous permettre de prouver les propriétés de validité et de terminaison de nos systèmes, et suffisamment précis pour nous permettre d'en dériver une implémentation de manière systématique. Après avoir défini un système de types de base pour notre langage, nous en présentons trois extensions originales : * Une amélioration du typage du filtrage de motifs basée en particulier sur l'ajout d'un opérateur de disjonction entre les contraintes de sous-typage. Cet opérateur permet alors d'exprimer, pour chaque cas de filtrage, le lien entre le filtre et les contraintes extraites du typage de l'expression correspondante. Ceci nous permet en particulier de représenter beaucoup plus finement le type de certaines fonctions et ainsi d'accepter plus de programmes valides. * Une alternative au mécanisme classique de généralisation permettant de distinguer les contraintes associées aux différents usages des paramètres des fonctions. Un tel mécanisme rend en particulier la construction de langage "let" de ML obsolète. Mixé avec la première extension, nous obtenons un système permettant d'encoder dans le langage lui même (c'est à dire sans ajouter de construction supplémentaire), un modèle objet intéressant. * Une formalisation des GADT basée sur une implantation originale des variables de type existentielles. En plus d'être compatible avec le sous-typage, cette variante des GADT présente une amélioration notable par rapport aux GADT standards par le fait qu'elle étend les possibilités d'inférence. Les annotations de type, habituellement obligatoires en présence de GADT, deviennent ici presque toutes facultatives. Bien qu'il soit possible de dériver directement une implémentation de ces systèmes, ce qui est principalement utile pour leur compréhension et leur prototypage, les performances des typeurs obtenus de la sorte ne sont pas suffisantes pour analyser des programmes de taille réelle. Ceci est principalement dû aux différentes extensions que nous apportons au langage des contraintes, en particulier les opérateurs de disjonction et de négation. Nous présentons alors les différentes techniques que nous avons mises en place pour l'implémentation de nos systèmes permettant à nos analyses de passer à l'échelle en pratique. / This PHD thesis focuses on static analysis of programs by type inference in order to detect program errors before their execution. More precisely, we focus hear in the field of sub-typing, where program properties are described by sets of constraints of the form (t1 <= t2). Our verification mechanisms are based on the aggregation of sub-typing constraints and checking of their compatibility by saturation. The base language on which we define our type systems is an ML-like language provided with variants and pattern matching. We starts by defining a formalism to express our type systems thanks to inference rules. This formalism has the advantage to be sufficiently flexible to allow proving validity and termination properties of our systems, and sufficiently precise to allow a systematic derivation of our inference rules into a runnable typer. After the definition of a base type system for our language, we present three novel extensions: * An improvement of type inference for the pattern matching based on the addition of the "or" operator between sub-typing constraints. This operator allow to express a link, in each cases of a match, between the pattern and the constraints generated at typing time of the case expression. This allows us to refine the type of some functions, and then to accept more valid programs. * A new implementation of the generalization mechanism. This allows to distinguish constraints associated to the different occurrences of a function parameter in its body. Thanks to this mechanism, the "let" construction from ML is in particular obsolete. By mixing this extension with the first one, we obtain a type system able to encode "objects" without any additional language construction. * A formalization of GADT based on an novel implementation of existential type variables. In addition to be compatible with the sub-typing context of this thesis, this alternative to GADT has the advantage to improve type inference. As a consequence, most of type annotations, usually required in the presence of GADT, are now optional. Despite the fact that it is possible to directly derive an implementation of our type systems from their rules, that is principally interesting for their comprehension and prototyping, the effectiveness of such typer is insufficient to analyze real world programs. This is principally due to the extensions we provide to the language of constraints, and in particular to the "or" and "not" operators. At then end, we present multiple techniques we used in our implementation to extend the scalability of our analysis.

M. Tech. (Department of Information and Communication Technology, Faculty of Applied and Computer Sciences), Vaal University of Technology. / There are many software development methodologies that are used to control the process of developing a software system. However, no exact system has been found which could help software engineers in selecting the best software development methodology (SDM). The increasing complexity of software development today has led to complex management of software systems. This complexity increases the challenges faced by professionals in selecting the most appropriate SDM to adopt in a project. This is important because the wrong choice of methodology is costly for the organization as it may impact on deliveries, maintenance costs, budget projects and reliability. In this study we propose a decision support framework to assist professionals in the selection of appropriate software development methodologies that would fit each organisation and project setting. The case based reasoning (CBR) methodology was implemented in this study. This methodology focuses on problem solving that centres on the reutilization of past experiences. The CBR methodology was implemented using the SQL programming language. We tested the precision of the decision support framework by comparing the recommended methodology to the actual software methodology that was adopted for the project. The DS framework recorded an 80% precision result. In addition, the findings contribute to reducing the software crisis faced by today’s professionals. Therefore the framework can be adopted as a reliable tool for methodology selection in software development projects.

In recent years, many sectors such as insurance, banking, retail, etc. have adopted Big Data architectures to boost their business activities. Such tools not only suppose a greater profit for thesecompanies but also allow them to gain a better understanding of their customers and their needs.These techniques are rapidly being adopted, this also being the case of sports and team sportsfor tasks such as injury prediction and prevention, performance improvement, or fan engagement.The aim of this project is to analyze the implications of data-driven decisions focusing on theiractual and future use in sports. Finally, a player scouting and team tailoring application would bedesigned and deployed to help the technical staff decision-making process which will also supposea budget optimization. For doing so, “Python” programming language and “Rapidminer” will beused, implementing “fuzzy logic” techniques for player scouting and “knapsack problem” algorithms for budget optimization plus an additional price prediction algorithm. The outcome wouldbe the application which given certain player needs (e.g., a midfielder with a high pass accuracyand a high ball recovery and a goalkeeper with a big number of saves and many minutes played)and the available budget will suggest the best possible combination of players given the availablebudget and the algorithm capable of predicting prices. This project also intends to study how thisapplication could be deployed in a real case situation by estimating the work team and budget todo so.

No description available.

No description available.

High-level action programming languages such as Golog have successfully been used to model the behavior of autonomous agents. In addition to a logic-based action formalism for describing the environment and the effects of basic actions, they enable the construction of complex actions using typical programming language constructs. To ensure that the execution of such complex actions leads to the desired behavior of the agent, one needs to specify the required properties in a formal way, and then verify that these requirements are met by any execution of the program. Due to the expressiveness of the action formalism underlying Golog (situation calculus), the verification problem for Golog programs is in general undecidable. Action formalisms based on Description Logic (DL) try to achieve decidability of inference problems such as the projection problem by restricting the expressiveness of the underlying base logic. However, until now these formalisms have not been used within Golog programs. In the present paper, we introduce a variant of Golog where basic actions are defined using such a DL-based formalism, and show that the verification problem for such programs is decidable. This improves on our previous work on verifying properties of infinite sequences of DL actions in that it considers (finite and infinite) sequences of DL actions that correspond to (terminating and non-terminating) runs of a Golog program rather than just infinite sequences accepted by a Büchi automaton abstracting the program.