AFOL: Towards a New Intelligent Interactive Programming Language for Children

Improving students' understanding of basic programming concepts through visual programming language: The role of self-efficacy

Background. Programming is widely known to be a cognitively demanding field. Learning programming can be a strenuous task without the proper guidance and methodology. Students often face difficulties in understanding even the most basic and fundamental concepts of programming, leading to their confusion and disappointment. Serious games for programming have the potential to alleviate students’ difficulties with programming. Aim. This article introduces a new serious game named jAVANT-GARDE which aims to educate the player on the basic concepts of programming and object-oriented programming through Java. By design, the game is suitable for everyone, even for players with no previous knowledge of programming. This article aims to present important information regarding the design, implementation and pilot evaluation of jAVANT-GARDE. Method. The game was evaluated by 42 high school students (age 16-17) in terms of perceived player experience and short-term learning. The participants played the game for one hour in the school lab and then answered a questionnaire based on the MEEGA+ framework. Results. Students evaluated positively the game in terms of its usability, confidence in playing the game, challenge, satisfaction, fun, focused attention and relevance. Moreover, the majority of students stated that would prefer learning programming with this game to learning through other teaching methods. Conclusions. The results of the pilot study and students’ replies in the questionnaire are rather positive. This gives us the initiative to proceed with studying the effect of the game in long-term learning of programming concepts.

The interest of children in learning to program computers has increased dramatically in recent years with the adaptation of new programming languages such as Scratch or game-based approaches. That being so, it is still unclear how best to teach programming concepts to young children. There is a gap in the literature on how to introduce basic programming concepts to children at the primary school level, while taking factors such as the grade level and approach used into account. This paper explores the best approach for introducing basic programming concepts to school children in the 4th, 5th and 6th grades as well as the effects of the approaches on students’ learning gains (per concept). The concepts addressed here are those used in a traditional Introduction to Programming course, such as programs, memory and variables, inputs and outputs, conditionals and loops. The paper presents the resulting improvements achieved by the 4th, 5th and 6th graders in a multigroup pretest-posttest design, with a control group (the use of a blackboard as an unplugged approach) and two experimental groups (the use of a visual execution environment (VEE) with a mouse and the use of the VEE with Makey Makey). We present the results exploring the interaction between the grade and approach factors for the 144 children (9-12 years old) enrolled in primary education. The results provide statistically significant data indicating how the children succeeded in learning basic programming concepts according to their grade, the type of approach used, and the programming concept under study.

Background. Learning programming is a cognitively demanding field of study accompanied with various difficulties. Although there is a high demand in the market for programmers, software analysts and engineers, a high dropout rate is recorded in relevant fields of study. Serious games are a promising means of engaging students in learning programming by giving them more incentives and making the process of learning programming concepts and languages more entertaining. Aim. This article introduces a new serious game called PY-RATE ADVENTURES, which aims to assist young students in their introduction to the basic programming concepts using Python. The game does not have any prerequisites and is suitable for players with no previous knowledge of programming. This article aims to present important information regarding the analysis, design and pilot evaluation of PY-RATE ADVENTURES. Method. The game was evaluated by 31 people that had recently graduated or were students of an Interdepartmental Programme of Postgraduate Studies in Information Systems. The participants voluntarily played the game and answered a questionnaire based on the MEEGA+ model, after their hands on experience with the game. This questionnaire’s purpose was to evaluate PY-RATE ADVENTURES in terms of perceived player experience and short-term learning. Results. The participants positively evaluated the game almost in all the elements of player experience. Furthermore, the majority of the users consider that the game helped them to learn basic programming concepts in Python and stated that they would prefer to learn programming with this game rather than other teaching methods. Conclusion. The positive results of the pilot evaluation give us the motivation to proceed and evaluate the game with students in secondary education, in order to extract stronger and generalisable conclusions regarding the impact of the game as an educational tool for learning programming concepts.

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

The 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized. In the past fifteen years, new data models, both for data storage and for data exchange have appeared with depressing regularity and with each such model, the inevitable query language. Does programming language research have anything to contribute to these new languages? Should we take the time to to worry about embedding these models in conventional languages? Over the same period, some interesting new connections between databases and programming languages have emerged, notably in the areas of scientific databases, annotation and provenance. Will this provide new opportunities for cross-fertilization?

In the past, the use of tangible programming languages has shown several advantages compared to screenbased graphical programming languages. Especially when presented to novices, such interfaces may represent a more intuitive and straightforward alternative to teach basic computer science and programming concepts. Previous studies have reported increased interest and improved collaboration when tangible programming languages were used. However, additional financial expenses have often hindered the use of such interfaces in formal education settings. This work therefore presents a low-cost and customizable solution of a tangible programming language for Thymio, an educational robot widely used in primary and secondary schools. Using a computer vision algorithm, graphical icons printed on paper are captured by a camera, and subsequently interpreted and sent to the robot for execution. Two user studies with in total 77 university students showed promising results, indicating that the devised interface can elicit more interest and a higher level of collaboration within groups.

Artificial Intelligence in the American Healthcare Industry: Looking Forward to 2030

I will discuss the design of Ct, an API for nested data parallel programming in C++. Ct uses meta-programming and functional language ideas to essentially embed a pure functional programming language in impure and unsafe languages, like C++. I will discuss the evolution of the design into functional programming ideas, how this was received in the corporate world, and how we plan to proliferate the technology in the next year.Ct is a deterministic parallel programming model integrating the nested data parallelism ideas of Blelloch and bulk synchronous processing ideas of Valiant. That is, data races are not possible in Ct. Moreover, performance in Ct is relatively predictable. At its inception, Ct was conceived as a simple library implementation behind C++ template magic. However, performance issues quickly forced us to consider some form of compilation. Using template programming was highly undesirable for this purpose as it would have been difficult and overly specific to C++ idiosyncrasies. Moreover, once compilation for performance was considered, we began to consider a language semantics that would enable powerful optimizations like calculational fusion, synchronization barrier elimination, and so on. The end result of this deliberation is an API that exposes a value-oriented, purely functional vector processing language. Additional benefits of this approach are numerous, including the important ability to co-exist within legacy threading programming models (because of the data isolation inherent in the model). We will show how the model applies to a wide range of important (at least by cycle count) applications. Ct targets both shipping multi-core architectures from Intel as well as future announced architectures.The corporate reception to this approach has (pleasantly) surprised us. In the desktop and high-performance computing space, where C, C++, Java, and Fortran are the only programming models people talk about, we have made serious inroads into advocating advanced programming language technologies. The desperate need for productive, scalable, and safe programming languages for multi-core architectures has provided an opening for functional, type-safe languages. We will discuss the struggles of multi-core manufacturers (i.e. Intel) and their software vendors that have created this opening.For Intel, Ct heralds its first serious effort to champion a technology that borrows functional programming technologies from the research community. Though it is a compromise that accommodates the pure in the impure and safe in the unsafe, this is an important opportunity to demonstrate the power of functional programming to the unconverted. We plan to share the technology selectively with partners and collaborators, and will have a fully functional and parallelizing implementation by year's end. At CUFP, we will be prepared to discuss our long term plans in detail.

This paper was inspired by [FBW 94]. An arbitrary upper bound on the size of some program for the target function suffices for the learning of some program for this function. In [FBW 94] it was discovered that if “learning” is understood as “identification in the limit,” then in some programming languages it is possible to learn a program of size not exceeding the bound, while in some other programming languages this is not possible.We have studied three other learning types, namely, “finite identification,” “co-learning” and “confidence-learning.” These three types are very different. Co-learning with the considered additional information in the form “an arbitrary upper bound for the size of the minimal program” allows the learning of the class of all recursive functions. “Finite identification” does not allow this. “Confidence-learning” is strong enough to learn the class of all recursive functions even without the additional information. However, the results of our paper show exactly the opposite rating for the capabilities of learning programs not exceeding the size given by the bound.For finite identification it is still possible to identify small programs with additional information in some programming languages but not in all of them. For co-learning it is not possible in any programming language. These results contrast to the result in [FKS 94] showing that an arbitrary class of recursive functions is co-learnable if and only if it is identifiable in the limit. Finally, for confidence-learning it is in general not possible to identify small programs with additional information.KeywordsProgramming LanguageTarget FunctionRecursive FunctionInductive InferenceIdentification TypeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This thesis presents a refinement calculus for transforming highly abstract specifications into programs written in a functional programming language. Refinement calculi allow the derivation of a program from a formal specification by a sequence of correctness-preserving transformation steps. Most refinement calculi target imperative programming languages. Functional programming languages are often more expressive than imperative programming languages. This expressive power leads to a reduced gap between the concepts used to express a problem (as a specification) and the concepts used to express its solution (as a program). Thus, a refinement calculus which targets a functional programming language can lead to a simpler development process which produces a final product more quickly. We build a refinement calculus for functional programs by adding specification constructs to a functional language and examining transformations over the resulting language.This thesis complements other work in the area in two major ways. Firstly, we investigate the addition of truly-nondeterministic, rather than underdetermined, choice constructs to a functional language. These constructs allow specifications which are more abstract and which admit more implementations. Secondly, most refinement calculi for functional programs add erratic choice constructs to a functional language. We investigate the addition of both demonic and angelic nondeterminism to a functional language. Demonic and erratic choice are similar: given a number of alternatives, they choose any one. In contrast, given a number of alternatives angelic choice always makes the correct choice, if one exists. Angelic choice is difficult to reason about, but allows the concise specification of powerful parallel constructs.

Falafel, a functional programming language with first-class arrays, is being developed at the University of Saskatchewan. It is an experimental vehicle for work in language definition and implementation. This paper discusses some of the fundamental design decisions that underlie the language and its implementations. Falafel has drawn ideas from array-based programming languages (APL [Iverson] and Nial [Jenkins]_[More]), functional programming languages (Miranda™ [Turner] and Haskell [Haskell]), and dataflow programming languages (Id [Nikhil]_and Sisal [Sisal]). This paper discusses the nature of Falafel’s value space, the structure of arrays, the role of strong polymorphic typing, the use of lazy evaluation, and a means of partial definition of arrays. A full definition of Falafel is to be published separately.

Object-oriented programming languages are suitable for describing real-world objects, functional programming languages for algebraic values. In this paper we propose an object-oriented functional programming language, called TOFL, which combines many desired properties of the two paradigms. In particular, TOFL unifies object classes, inheritance, (method) redefinitions and late binding as in object-oriented languages, algebraic data types, higher-order functions, type classes and type inference (without type reconstruction in this paper) as in functional languages. We translate TOFL into a stratified and explicitly typed λ-calculus T with overloaded functions, where redefinitions and late binding become late binding of overloaded functions. The operational semantics of T gives a semantics and a simple prototyping implementation of TOFL.

Nowadays, when algorithms are combined with programming languages, great technological works are emerging. Examples of these works continue to differentiate and increase in military and police systems, agricultural applications, image processing applications, data engineering field, language processing works, and cyber security applications. With the differentiation of the areas of use of algorithms, the programming languages used on these platforms are also changing. Python is an object-oriented and functional modern programming language. It is ideal for beginners due to its readability and ease of use. C# is a simple, modern, object-oriented, and type-safe programming language that combines the high productivity of application development languages with the raw power of C and C++. The Java programming language, on the other hand, shares many features that are common to most programming languages used today. Since it is designed with the structures of C and C++, where their languages are similar, the language is familiar to C and C++ programmers (Lerdorf, 2002; Hejlsberg, 2003; Arnold, 2005; Deitel, 2004; Kelly, 2016; Gavrilović, 2018; Pala, 2019; Chollet, 2021; Chen, 2023).

With the rapid development of artificial intelligence, human-computer interaction, pattern recognition and other technologies, emotion recognition has become a hot topic in this field. Traditional emotional recognition studies mostly use voice features and facial expression image features for recognition, but the external expression features of these emotions are easily subject to subjective control of the human body. However, physiological information is closely related to the cerebral cortex and nerve center of human body, which is objective and authentic. In this paper, four kinds of chaotic characteristic parameters were extracted from ECG(Electrocardiogram), SC(Skin Conductance) and RSP(Respiration), including complexity, box dimension, approximate entropy and information entropy. Three kinds of emotions (Joy, Anger and Sadness) were identified by C4.5 decision tree algorithm. The results of the study show that this method is feasible for emotion recognition. Using C# programming language, Visual Studio integrated development environment (IDE), SQL Server database and other tools, a emotional recognition platform based on multi-physiological information was established, which can extract 12 chaotic characteristic parameters from the collected ECG, SC and RSP. Joy, anger and sadness were recognized through the C4.5 decision tree classifier algorithm, and finally save the information to the local database. This platform includes user login, volunteer management, administrator management, data center and other functional modules to ensure the security and information integrity of the platform. The verification experiment was carried out on the completed platform(In this paper, omit), which proved the effectiveness and practicability of the platform.