Desarrollo de un sistema de gestión de tutorías a través de una aplicación móvil

RESUMEN Con la irrupción y el auge de las tecnologías móviles en estos últimos años, se ha hecho patente que los procesos de gestión tienden a ser controlados a través de estas tecnologías, permitiendo al usuario centralizar todos los servicios que le sea posible en un dispositivo de uso tan común como el teléfono móvil, así como acceder a ellos de forma rápida y cómoda. El sistema de tutorías de la Universidad Politécnica de Madrid no es la excepción. Desde su creación, el Grupo de Innovación Educativa Tutorial Action (GIETA) [1] ha trabajado en la modernización del proceso de gestión que conlleva el sistema de tutorías, buscando las deficiencias del sistema tradicional que pudiesen resolverse utilizando la tecnología. Este Trabajo de Fin de Grado (TFG) ha tenido como objetivo apoyar la labor iniciada por el GIETA, desarrollando un sistema de gestión de tutorías mediante una aplicación móvil. Para lograr este objetivo, inicialmente se realizó un proceso de reflexión sobre, entre otras cuestiones, la razón de ser de la aplicación a desarrollar, las ventajas que aportaría al usuario final, aquellos riesgos que podían amenazar al proyecto, etc. Este proceso se englobó dentro de la herramienta Agile Inception Deck. Tras este proceso de reflexión, se estructuró el proyecto en fases o sprints de desarrollo, en las que se llevó a cabo la implementación del resultado final de este TFG, una aplicación móvil para el sistema operativo Android, que aporta funcionalidad que resuelve todos los requisitos asociados a las distintas historias de usuario definidas para el proyecto. ABSTRACT With the rise of mobile technologies in recent years, it has become clear that management processes tend to be controlled through these technologies, allowing users to centralize all services as possible, using a device as common as the mobile phone, and access them quickly and easily. The tutorial system at the Technical University of Madrid is not an exception. Since it’s creation, the Group of Educational Innovation Tutorial Action has worked on the modernization of the management process that involves the tutorial system, looking for weaknesses of the traditional system that could be solved using technology. This TFG has aimed to support the work initiated by the GIETA, developing a tutorship management system through a mobile application. To achieve this goal, initially a process of reflection was held about, inter alia, the rationale for the application to be developed, the advantages it would bring to the final user, the risks that could threaten the project, etc. This process is encompassed within the Agile Inception Deck tool. After this process of reflection, the project was divided into phases or sprints, in which took place the implementation of the outcome of the TFG, a mobile application for the Android operating system, which provides functionality that meets all the requirements associated with the different user stories defined for the project.

Integrated program debugging, verification, and optimization using abstract interpretation (and the Ciao system preprocessor)

The technique of Abstract Interpretation has allowed the development of very sophisticated global program analyses which are at the same time provably correct and practical. We present in a tutorial fashion a novel program development framework which uses abstract interpretation as a fundamental tool. The framework uses modular, incremental abstract interpretation to obtain information about the program. This information is used to validate programs, to detect bugs with respect to partial specifications written using assertions (in the program itself and/or in system libraries), to generate and simplify run-time tests, and to perform high-level program transformations such as multiple abstract specialization, parallelization, and resource usage control, all in a provably correct way. In the case of validation and debugging, the assertions can refer to a variety of program points such as procedure entry, procedure exit, points within procedures, or global computations. The system can reason with much richer information than, for example, traditional types. This includes data structure shape (including pointer sharing), bounds on data structure sizes, and other operational variable instantiation properties, as well as procedure-level properties such as determinacy, termination, nonfailure, and bounds on resource consumption (time or space cost). CiaoPP, the preprocessor of the Ciao multi-paradigm programming system, which implements the described functionality, will be used to illustrate the fundamental ideas.

Some techniques for automated, resource-aware distributed and mobile computing in a multi-paradigm programming system

Distributed parallel execution systems speed up applications by splitting tasks into processes whose execution is assigned to different receiving nodes in a high-bandwidth network. On the distributing side, a fundamental problem is grouping and scheduling such tasks such that each one involves sufñcient computational cost when compared to the task creation and communication costs and other such practical overheads. On the receiving side, an important issue is to have some assurance of the correctness and characteristics of the code received and also of the kind of load the particular task is going to pose, which can be specified by means of certificates. In this paper we present in a tutorial way a number of general solutions to these problems, and illustrate them through their implementation in the Ciao multi-paradigm language and program development environment. This system includes facilities for parallel and distributed execution, an assertion language for specifying complex programs properties (including safety and resource-related properties), and compile-time and run-time tools for performing automated parallelization and resource control, as well as certification of programs with resource consumption assurances and efñcient checking of such certificates.

Program development using abstract interpretation (and the ciao system preprocessor)

The technique of Abstract Interpretation has allowed the development of very sophisticated global program analyses which are at the same time provably correct and practical. We present in a tutorial fashion a novel program development framework which uses abstract interpretation as a fundamental tool. The framework uses modular, incremental abstract interpretation to obtain information about the program. This information is used to validate programs, to detect bugs with respect to partial specifications written using assertions (in the program itself and/or in system librarles), to genérate and simplify run-time tests, and to perform high-level program transformations such as múltiple abstract specialization, parallelization, and resource usage control, all in a provably correct way. In the case of validation and debugging, the assertions can refer to a variety of program points such as procedure entry, procedure exit, points within procedures, or global computations. The system can reason with much richer information than, for example, traditional types. This includes data structure shape (including pointer sharing), bounds on data structure sizes, and other operational variable instantiation properties, as well as procedure-level properties such as determinacy, termination, non-failure, and bounds on resource consumption (time or space cost). CiaoPP, the preprocessor of the Ciao multi-paradigm programming system, which implements the described functionality, will be used to illustrate the fundamental ideas.

Program analysis, debugging and optimization using the ciao system preprocessor

We present a tutorial overview of Ciaopp, the Ciao system preprocessor. Ciao is a public-domain, next-generation logic programming system, which subsumes ISO-Prolog and is specifically designed to a) be highly extensible via librarles and b) support modular program analysis, debugging, and optimization. The latter tasks are performed in an integrated fashion by Ciaopp. Ciaopp uses modular, incremental abstract interpretation to infer properties of program predicates and literals, including types, variable instantiation properties (including modes), non-failure, determinacy, bounds on computational cost, bounds on sizes of terms in the program, etc. Using such analysis information, Ciaopp can find errors at compile-time in programs and/or perform partial verification. Ciaopp checks how programs cali system librarles and also any assertions present in the program or in other modules used by the program. These assertions are also used to genérate documentation automatically. Ciaopp also uses analysis information to perform program transformations and optimizations such as múltiple abstract specialization, parallelization (including granularity control), and optimization of run-time tests for properties which cannot be checked completely at compile-time. We illustrate "hands-on" the use of Ciaopp in all these tasks. By design, Ciaopp is a generic tool, which can be easily tailored to perform these and other tasks for different LP and CLP dialects.

A tutorial on program development and optimization using the Ciao preprocessor

We present in a tutorial fashion CiaoPP, the preprocessor of the Ciao multi-paradigm programming system, which implements a novel program development framework which uses abstract interpretation as a fundamental tool. The framework uses modular, incremental abstract interpretation to obtain information about the program. This information is used to validate programs, to detect bugs with respect to partial specifications written using assertions (in the program itself and/or in system libraries), to generate and simplify run-time tests, and to perform high-level program transformations such as multiple abstract specialization, parallelization, and resource usage control, all in a provably correct way. In the case of validation and debugging, the assertions can refer to a variety of program points such as procedure entry, procedure exit, points within procedures, or global computations. The system can reason with much richer information than, for example, traditional types. This includes data structure shape (including pointer sharing), bounds on data structure sizes, and other operational variable instantiation properties, as well as procedure-level properties such as determinacy, termination, non-failure, and bounds on resource consumption (time or space cost).