A Browser-based IDE for the MUzECS Platform

We report on a scalable, portable, and secure visual development environment for programming embedded Arduino platforms with Chromebooks in a successful secondary school computer science curriculum. Our web-based environment is part of the larger MUzECS project, an inexpensive replacement module for the Exploring Computer Science (ECS) course being widely deployed in United States high schools. Students use MUzECS to gain a deeper understanding of computing, through a set of blocks which provide appropriate abstractions for working with low-level hardware. MUzECS improves upon the existing curriculum module by reducing the hardware cost by an order of magnitude, while still preserving the key ECS pillars of computer science content, student inquiry and classroom equity. Programming with visual blocks provides a more attractive tool for introductory courses than traditional approaches, and yet enables high-impact exploration activities such as building a series of embedded musical instruments. The current work combines and modifies several existing tools to eliminate technical barriers on low-cost platforms like Chromebooks, such as the reliance on special block-based toolchains, remote compilation servers, or multi-stage transfers for student code

A visual programming language for soccer

The use of Information Technologies (IT) in high competition sports is an instrument often used. However, the majority of the performers, including technical teams, do not have skills to program those IT tools to their needs. In this paper we present the low level implementation of a visual programming language (VPL) that allows the user without programming expertise to produce relatively complex programs by drawing them on a web application. The VPL tool application is illustrated by applying it to detect programmed situations from a soccer game, using previously obtained tracking data. The tool can be applied to other collective ball sports

Design and analysis of visual programming language for microcontroller systems

Conventional methods of programming microcontrollers using textual languages are hard to learn and are daunting to novice programmers seeking to learn microcontroller programming. Visual languages have always been regarded as a useful tool in helping non-programmers and novice-programmers to write programs. However there have been limited attempts at creating a visual language for microcontroller systems and there isn't a visual language for microcontrollers that is flexible and easy to use. This thesis presents a way of addressing the issue by creating a low level visual programming language for microcontroller systems. The low level visual programming language aims to alleviate the problem by using a fine grained language to improved flexibility and providing an integrated visual language environment in which users can focus on writing programs and solving problems. A visual language environment called CoreChart was developed for this purpose. CoreChart aims to simplify the process of programming microcontrollers by providing users with a tool to construct assembly programs visually. The visual language will utilize flow chart diagramming techniques to present users with a more meaningful view of the program. This allows users to focus on writing programs to solve problems, rather than on the rules and syntax of the language. The procedure of programming micro controllers is further simplified by automating the task of compiling the program and downloading the program into the microcontroller. A survey was conducted on university and high school students to evaluate the effectiveness of CoreChart.Thesis (M.Eng.Sc.) -- University of Adelaide, School of Electrical and Electronic Engineering, 200

Learning to Program in Python – by Teaching It!

The US Bureau of Labor Statistics predicts over 8 million job openings in IT and computing, including 1 million cybersecurity postings, over the current five-year period. This paper presents lessons learned in preparing middle-school students in rural Georgia for future careers in computer science/ IT by teaching computer programming in the free, open-source programming language Python using Turtle graphics, and discusses exercises and activities with low-cost drones, bots, and 3D printers to get students interested and keep them engaged in coding. Described herein is one pair of instructors’ (one middle-school, one university) multi-year, multi-stage approach to providing engineering and technology courses, including: how to code Turtle graphics in Python; how to engage children by using short, interactive, visual programs for every age level; building cross-curricular bridges toward technology careers using 3D printing, robotics, and low-cost drones; and, how to build more advanced programming skills in Python

Integration of Visual Languages with SCS tools in the Software Development Industry

Source Control Systems (SCS), also known as Version Control Systems (VCS), help teams to organize and track changes in the software development process. These systems have become vital in the software development industry as the increased growth and geographical diversity of teams, forced them to find solutions to deal with multiple people accessing the same pieces of software concurrently. Although for a while SCS seemed to be coping well with the needs of software development, the rise of the low-code platforms and Visual Programming Languages (VPLs) brought a new challenge to version control: how to manage visual artifacts without losing SCS functionalities? The biggest cause of this challenge is the fact that SCS are mostly oriented to work with text-based programming languages. Thus text-oriented SCS are (in general) incapable of dealing with visual artifacts as well as they do with text. So, to cope with the loss of SCS functionalities in VPLs projects, teams either accept and work with this loss or are forced to come up with a solution of their own to tackle a specific version control problem. These issues can be found in the OutSystems platform, which is our case study. To solve this problem, we propose a system, termed OSGit, that acts as a man-in-themiddle between the low-code platform and the designated SCS. The proposed system will translate the requested version control operations from the low-code platform to native operations of the given SCS. In operations that require visual artifacts to be managed - like applying blames - we propose the creation of metadata files. The metadata files contain the needed information about the visual elements used to build applications in the lowcode platform. This information is thus a compacted representation of the visual elements through text. Therefore, using metadata files will allow the SCS to correctly handle the required visual artifacts while integrating this system with a low-code platform or a VPL. The produced system obtained auspicious results in the usability tests that were performed and that featured ten OutSystems developers. They showed great satisfaction when using OSGit and also gave suggestions for future improvements. OSGit bridges the gap between text-based SCS and visual artifacts, which proves the possibility of integrating these systems in the world of VPL with a high-level of user satisfaction

A visual workspace for constructing hybrid MDS algorithms and coordinating multiple views

Data can be distinguished according to volume, variable types and distribution, and each of these characteristics imposes constraints upon the choice of applicable algorithms for their visualisation. This has led to an abundance of often disparate algorithmic techniques. Previous work has shown that a hybrid algorithmic approach can be successful in addressing the impact of data volume on the feasibility of multidimensional scaling (MDS). This paper presents a system and framework in which a user can easily explore algorithms as well as their hybrid conjunctions and the data flowing through them. Visual programming and a novel algorithmic architecture let the user semi-automatically define data flows and the co-ordination of multiple views of algorithmic and visualisation components. We propose that our approach has two main benefits: significant improvements in run times of MDS algorithms can be achieved, and intermediate views of the data and the visualisation program structure can provide greater insight and control over the visualisation process

Performance evaluation and limitations of a vision system on a reconfigurable/programmable chip

This paper presents a survey of the characteristics of a vision system implemented in a reconfigurable/programmable chip (FPGA). System limitations and performance have been evaluated in order to derive specifications and constraints for further vision system synthesis. The system hereby reported has a conventional architecture. It consists in a central microprocessor (CPU) and the necessary peripheral elements for data acquisition, data storage and communications. It has been designed to stand alone, but a link to the programming and debugging tools running in a digital host (PC) is provided. In order to alleviate the computational load of the central microprocessor, we have designed a visual co-processor in charge of the low-level image processing tasks. It operates autonomously, commanded by the CPU, as another system peripheral. The complete system, without the sensor, has been implemented in a single reconfigurable chip as a SOPC. The incorporation of a dedicated visual co-processor, with specific circuitry for low-level image processing acceleration, enhances the system throughput outperforming conventional processing schemes. However, timemultiplexing of the dedicated hardware remains a limiting factor for the achievable peak computing power. We have quantified this effect and sketched possible solutions, like replication of the specific image processing hardware