Large language models (LLMs) such as ChatGPT, Codex, and GitHub Copilot are transforming programming education by offering personalized code generation, real-time explanations, and virtual tutoring. Despite rapid adoption, their pedagogical effectiveness and limitations remain underexplored. This systematic review synthesizes findings from 25 empirical studies published between January 2022 and May 2025 to evaluate the educational settings, benefits, challenges, and learning impacts associated with LLM use in programming instruction. Our analysis reveals that LLMs are predominantly used in university-level introductory courses, with tutoring and explanation being the most common use case. Reported benefits include enhanced student engagement, improved short-term performance, and reduced instructor workload. However, challenges such as overreliance, code inaccuracy, equity gaps, and academic integrity concerns persist. While most studies report positive short-term outcomes, long-term skill development and equitable access remain uncertain. The evidence suggests that the pedagogical value of LLMs depends on thoughtful integration strategies that combine automation with human oversight. This review provides actionable insights for educators and policymakers seeking to leverage LLMs responsibly in diverse programming education contexts.

This paper proposes a hybrid access control system that integrates the usability of Web2 authentication (Google Login) with the transparency and integrity of Web3 technologies (blockchain and smart contracts). The system enables users to authenticate via their existing Google accounts without managing crypto wallets or private keys, while access permissions are securely recorded on-chain through smart contracts. To ensure cryptographic key security without relying on a centralized authority, the design incorporates Distributed Key Management (DKM). This approach addresses the challenge of balancing usability with verifiability in data access control. By embedding decentralized guarantees within a centralized web service interface, the system enables practical and transparent access control. The proposed architecture demonstrates the potential for a general-purpose, auditable module that facilitates user-consented data sharing with third parties.

Partial periodic patterns play a significant role in identifying regularities within temporal databases. However, most existing research has focused on discovering these patterns in binary datasets, overlooking the critical insights about the quantitative values associated with the items. This study utilizes the principles of fuzzy sets to propose a novel model for discovering Fuzzy Partial Periodic Frequent Patterns (FPPFPs) within a quantitative temporal database. A robust depth-first search algorithm has also been proposed to uncover all FPPFPs. The proposed algorithm incorporates a novel pruning strategy that effectively reduces the search space and the computational cost required for discovering the FPPFPs. The experimental findings on synthetic and real-world datasets demonstrate the efficiency of the proposed algorithm. Finally, a case study utilizing air pollution data is provided to showcase the practical applicability and significance of the identified patterns.

This study introduces a Preference-Based Reinforcement Learning (PbRL) approach tailored for autonomous vehicle (AV) applications within a simulated environment. Traditional RL methods often struggle with the complexities of reward function engineering, failing to perform behaviors of human desire. The proposed framework integrates human preferences directly into the training loop, our framework offers a novel methodology for enhancing the decision-making processes of autonomous system. Our results demonstrate that PbRL can refine the strategies of AVs to align more closely with human-like decision-making, highlighting the potential for increased adaptability and safety in autonomous technologies.

A less complex and more straightforward program is a crucial factor that enhances its maintainability and makes writing secure and bug-free programs easier. However, due to its heavy workload and the risks of breaking the working programs, programmers are reluctant to do code refactoring, and thus, it also causes the loss of potential learning experiences. To mitigate this, we demonstrate the application of using a large language model (LLM), GPT-3.5, to suggest less complex versions of the user-written Python program, aiming to encourage users to learn how to write better programs. We propose a method to leverage the prompting with few-shot examples of the LLM by selecting the best-suited code refactoring examples for each target programming problem based on the prior evaluation of prompting with the one-shot example. The quantitative evaluation shows that 95.68% of programs can be refactored by generating 10 candidates each, resulting in a 17.35% reduction in the average cyclomatic complexity and a 25.84% decrease in the average number of lines after filtering only generated programs that are semantically correct. Further-more, the qualitative evaluation shows outstanding capability in code formatting, while unnecessary behaviors such as deleting or translating comments are also observed.

The music industry is facing challenges in engaging fans and providing transparency, feedback, and rewards. Blockchain technology presents a potential solution by enabling new forms of fan engagement and participation. This paper proposes a blockchain-based music platform that leverages Ethereum’s decentralized platform and smart contract functionality. Ethereum’s Proof of Stake (PoS) consensus algorithm makes it more energy-efficient than the Proof of Work (PoW) algorithm used by Bitcoin. The platform could facilitate investment in up-and-coming artists, feedback mechanisms, and rewards for fans. The scalability and decentralization of Ethereum make it an attractive choice for building a platform that can accommodate a large number of users and transactions without compromising performance. The proposed platform offers a secure, scalable, and decentralized solution that provides novel ways for fans to engage and participate in the music industry while being energy-efficient, sustainable, and accessible to everyone with a stake in the system.

Abstract In software, an algorithm is a well-organized sequence of actions that provides the optimal way to complete a task. Algorithmic thinking is also essential to break-down a problem and conceptualize solutions in some steps. The proper selection of an algorithm is pivotal to improve computational performance and software productivity as well as to programming learning. That is, determining a suitable algorithm from a given code is widely relevant in software engineering and programming education. However, both humans and machines find it difficult to identify algorithms from code without any meta-information. This study aims to propose a program code classification model that uses a convolutional neural network (CNN) to classify codes based on the algorithm. First, program codes are transformed into a sequence of structural features (SFs). Second, SFs are transformed into a one-hot binary matrix using several procedures. Third, different structures and hyperparameters of the CNN model are fine-tuned to identify the best model for the code classification task. To do so, 61,614 real-world program codes of different types of algorithms collected from an online judge system are used to train, validate, and evaluate the model. Finally, the experimental results show that the proposed model can identify algorithms and classify program codes with a high percentage of accuracy. The average precision, recall, and F-measure scores of the best CNN model are 95.65%, 95.85%, and 95.70%, respectively, indicating that it outperforms other baseline models.

Periodic-frequent pattern mining is a vital knowledge discovery technique that aims to find all regularly occurring patterns in a temporal database. Previous studies focused on developing CPU-centric algorithms by disregarding the speedups offered by the GPUs. Furthermore, existing GPU-based frequent pattern mining algorithms cannot be employed to find periodic-frequent patterns because they ignore the items' temporal occurrence information in the database, and the multi-threaded sum-reduction technique cannot be employed to determine the periodicity of a pattern in a database. With this motivation, this paper proposes an efficient GPU-accelerated depth-first search algorithm, GPU Periodic Frequent-Miner (gPF-Miner), to find the desired patterns. Our algorithm employs a novel flattened array structure to effectively record the temporal occurrence information of every item in a database. Our algorithm also introduces a new multi-threaded parallelization technique to calculate the support and periodicity of a pattern in a GPU. This technique’s best and worst-case time complexities are O(1) and O(n), where n represents the data size. Experimental results demonstrate that gPF-Miner outperforms the existing CPU-based and naive GPU-based algorithms by a vast margin.

A geo-referenced time series database represents the data generated by a set of fixed locations (or spatial items) observing a particular phenomenon over time. This data hides valuable information that can help users progress in their social and economic lives. This paper presents a new model of Geo-referenced Periodic-Frequent Patterns (GPFPs) that might be in these databases. A GPFP is a set of frequently occurring items close to each other and seen in a database at regular intervals. Three constraints have been used to figure out how interesting a pattern is in a geo-referenced time series database: maximum distance (maxDist), minimum support (minSup), and maximum periodicity (maxPer). The maxDist controls how far apart the items in a pattern can be. The minimum number of times a pattern must appear in the data is controlled by the minSup. Lastly, the maxPer variable specifies how many times a pattern must repeat before it is considered periodic in the data. Each pattern that satisfies these three requirements will be returned. An effective method known as the Geo-referenced Periodic-Frequent Pattern-Miner (GPFP-Miner) has been proposed to discover all GPFPs included inside a geo-referenced time series database. GPFP-Miner uses an innovative, smart depth-first search approach to uncover required patterns efficiently. The findings of the experiments support the contention that the proposed algorithm is effective. In addition, we present two case studies in which we utilise our methodology to extract meaningful information from databases pertaining to air pollution and traffic congestion.

A geo-referenced time series database represents the data generated by a set of fixed locations (or items) observing a particular phenomenon over time. Useful information that can facilitate the users to achieve socio-economic development lies hidden in this data. This paper introduces a novel model of Fuzzy Geo-referenced Periodic-Frequent Patterns (FGPFPs) that may exist in these databases. An FGPFP represents a set of frequently occurring neighboring items observed at regular intervals in a database. For example, an FGPFP in a traffic congestion database represents a set of neighboring road segments where people have regularly faced congestion problems. A novel pruning technique has been presented to effectively reduce the search space and the computational cost of finding the desired patterns. We have also proposed an efficient depth-first search algorithm to find all the desired patterns. Experimental results demonstrate that the proposed algorithm is efficient. Finally, we demonstrate our model’s usefulness by performing traffic congestion analytics.

Despite the incredible adoption of cryptocurrencies, blockchain-based cryptocurrencies have likewise raised some concerns. The scalability problem is the major one among them. An off-blockchain payment channel network (PCN) has been introduced to solve this issue. PCN can fundamentally reduce blockchain scalability by constructing a number of payment channels between the nodes and without committing every single transaction to the blockchain. But as a matter of fact, there has an unwanted assumption in PCN that channel participants must remain online and follow blockchain updates, for the synchronization with blockchain to protect the channel against deception. To mitigate this issue “Watchtower” concept has been proposed. Watchtower is a watching service and always stays online that a channel participant can hire it by offering incentives for monitoring the channel and checking blockchain updates consistently to prevent fraud on behalf of the hiring party. However, watchtower may be more beneficial by cooperating with the cheating counterparty and neglecting to perform the watching service properly. The efficiency drawback can occur for that. In this work, we have been motivated by this issue and tried to find out an effective and reliable watchtower for the channel watching service from multiple watchtower nodes or candidates in the PCN. In particular, we have been approached by using the distributed Peterson Leader-Election Algorithm to find the best watchtower among multiple of them where the more successfully performed work node or candidate will be selected for the channel monitoring job. We also have provided a detailed step-by-step process of the algorithm including experiments and illustrations for employing watchtower among multiple of them.

Efficient path planning and minimization of path movement costs for collision-free faster robot movement are very important in the field of robot automation. Several path planning algorithms have been explored to fulfill these requirements. Among them, the A-star (A*) algorithm performs better than others because of its heuristic search guidance. However, the performance, effectiveness, and searching time complexity of this algorithm mostly depends on the robot motion block to search for the goal by avoiding obstacles. With this challenge kept in mind, this paper proposes an efficient robot motion block with different block sizes for the A* path planning algorithm. The proposed approach reduces robots’ path cost and time complexity to find the goal position as well as avoid obstacles. In this proposed approach, grid-based maps are used where the robot’s next move is decided by searching eight directions among the surrounding grid points. However, the proposed robot motion blocks size has a significant effect on path cost and time complexity of the A* path planning algorithm. For the experiment and to validate the efficiency of the proposed approach, an online benchmarked dataset is used. The proposed approach is applied on thousands of different grid maps with various obstacles, starting, and goal positions. The obtained results from the experiment show that the presented robot motion blocks reduce the robot’s pathfinding time complexity and number of search nodes by maintaining a minimum path cost towards the goal position.

Recent breakthroughs in computer vision have led to the invention of several intelligent systems in different sectors. In transportation, this advancement led to the possibility of proposing autonomous vehicles. This recent technology relies heavily on wireless sensors and Deep learning. For an autonomous vehicle to navigate safely on highways, the vehicle needs equipment to aid with detecting road anomalies such as potholes ahead of time. The massive improvement in computer vision models such as Deep Convolutional Neural networks (DCNN) or vision transformers (ViT) resulted in many success stories and tremendous breakthroughs in object detection tasks; this enabled the use of such models in different application areas. But many of the reported results are theoretical and unrealistic in real-life. Usually, the nature of these models is extensive; they are trained on High-performance computers or cloud computing environments with GPUs, which challenge their usage on edge devices. However, to come up with a light model that can fit into embedded devices, the model size has to be reduced significantly so that the performance will not be affected. Therefore, this paper proposes a lightweight model of pothole detection for an embedded device. The model achieved a state-of-the-art accuracy of 98%, with the number of parameters reduced to more than 70% compared with a deep CNN model; the model can be trained and deployed on embedded devices such as smartphones efficiently.

A popular language model that can solve introductory programming problems, OpenAI’s Codex, has drawn much attention not only in the natural language processing field but also in the software engineering field. It supports programmers by suggesting the next tokens to write, and it can even generate a whole function definition from a document string. We focus on its capability of automatically solving programming problems through code generation from problem descriptions. We investigate the model’s sensitivity to problem descriptions by formatting and modifying them. The experimental results show that the more explicitly formatted problem description enhances the code generation performance from 30.9% (raw) to 39.9% (formatted). Additionally, we observe that code generation relies on information specified in the problem description, such as variable names and constant values, as anonymizing them reduces the performance significantly. Moreover, statistical biases in code generation are identified, such as the generated programs ignoring the problem modification and answering the exact opposite problem. The changes in accuracy across formats suggest that the model does not correctly understand the natural language explaining the problem specification even if the model could solve the programming problems with high accuracy.

In this paper, we propose a visual interface for manipulating relational databases (RDBs). This interface, unlike structured query language (SQL), describes queries in a procedural language with graphs. This helps inexperienced users to interact with RDBs, and also helps experienced users to express nontrivial queries properly. It also supports SQL-DML (SELECT, INSERT, UPDATE, DELETE), ensuring there is no missing functionality in database manipulation. It also introduces the system architecture and algorithms for the inter-conversion between SQL and the Visual Query Interface. This architecture can support various RDBMSs.

The development and operation of Online Judge System (OJS), which is used to evaluate the correctness of programs, is a nontrivial and difficult task due to the various functional and non-functional requirements. However, although many OJSs have been developed and operated, and their usefulness reported, the theory for constructing OJSs has not been sufficiently discussed. In this paper, we present the functional and nonfunctional requirements oriented to OJS as well as demonstrate the internal components and software architecture of an OJS, which has been in operation for over a decade and has evaluated over six million solutions. We also present real-world experiences and challenges encountered during this long journey of our OJS.

Partial periodic pattern mining is an important model in data mining with many real-world applications. However, this model’s successful industrial application was hindered by the problem of combinatorial explosion of patterns, which involves generating too many patterns, most of which might be redundant or uninteresting to the user. Furthermore, the problem of combinatorial explosion increases the memory, runtime, and the energy requirements of a mining algorithm. This paper aims to tackle this challenging problem by proposing a novel model of maximal partial periodic pattern that may exist in a database. We also present a new tree structure and a pattern-growth algorithm, called Maximal Partial Periodic Pattern-growth (max3P-growth), to find all desired patterns effectively. Experimental results demonstrate that the proposed model prunes many redundant patterns, and the max3P-growth is efficient and scalable. Finally, we show the usefulness of our model with a case study on traffic congestion analytics.

Time series classification is an important model in data mining. It involves assigning a class label to a test instance based on the training data with known class labels. Most previous studies developed time series classifiers by disregarding the fuzzy nature of events (i.e., events with similar values may belong to different classes) within the data. Consequently, these studies suffered from performance issues, including decreased accuracy and increased memory, runtime, and energy requirements. With this motivation, this paper proposes a novel fuzzy nearest neighbor classifier for time series data. The basic idea of our classifier is to transform the very large training data into a relatively small representative training data and use it to label a test instance by employing a new fuzzy distance measure known as Ravi. Experimental results on real world benchmark datasets demonstrate that the proposed classifier outperforms the current parameter-free time series classifiers and also the popular deep learning techniques.

Efficient knowledge sharing, computation load minimization, and collision-free movement are very important issues in the field of multi-robot automation. Several cloud robot architectures have been investigated to fulfill these requirements. However, the performance of the cloud-robot architectures created to date are suboptimal due to the lack of efficient data management for multi-robotic systems. With this point in mind, this paper proposes an efficient cloud multi-robot framework with cloud database model for mobile robot applications to facilitate multi-robot management, communication, and resource sharing. In this proposed architecture, the cloud framework is comprised with cloud data analysis, cloud database management, and cloud service management. The data analysis serves different data processing and decision-making tasks for generating the next robot action based on robot sensors’ data with the help of a data access components layer. A multistage cloud database model distributes, stores, and accesses different categories of data related to robot sensors and environments. And cloud service facilitates multi-robot management, communication, and resource sharing in the cloud framework. Additionally, as a use case, a cloud-based convolutional neural network (CNN) model is introduced for learning and recognizing robot application data. The obtained results of our tests indicate that the proposed cloud-robot architecture provides efficient computation power, communications, and knowledge sharing for managing multi-mobile robot systems.

Computation offloading for cloud robotics is receiving considerable attention in academic and industrial communities. However, current solutions face challenges: 1) traditional approaches do not consider the characteristics of networked cloud robotics (NCR) (e.g., heterogeneity and robotic cooperation); 2) they fail to capture the characteristics of tasks in a robotic streaming workflow (RSW) (e.g., strict latency requirements and varying task semantics); and 3) they do not consider quality-of-service (QoS) issues for cloud robotics. In this paper, we address these issues by proposing a QoS-aware RSW allocation algorithm for NCR with joint optimization of latency, energy efficiency, and cost, while considering the characteristics of both RSW and NCR. We first propose a novel framework that combines individual robots, robot clusters, and a remote cloud for computation offloading. We then formulate the joint QoS optimization problem for RSW allocation in NCR while considering latency, energy consumption, and operating cost, and show that the problem is NP-hard. Next, we construct a data flow graph based on the characteristics of RSW and NCR, and transform the RSW allocation problem into a mixed-integer linear programming problem. To obtain a near-optimal solution in reasonable time, we also develop a heuristic algorithm. Experiments comparing our approach with others demonstrate significant performance gains, with improved QoS and reduced execution times.

Finding Spatial High Utility Itemsets (SHUIs) in a spatiotemporal database is a challenging problem of great importance in many real-world applications. Most previous works focused on the sequential discovery of SHUIs in a database running on a single machine. Consequently, these works are not suitable for big data (or cloud-based) applications as they suffer from the scalability and fault tolerant problems. This paper proposes several novel pruning techniques to reduce the search space and present a more flexible distributed algorithm to find all desired itemsets from the database using Spark in-memory computing architecture. Our algorithm inherits several advantages of Spark, including low communication cost, fault tolerance, and high scalability. Experimental results demonstrate that the proposed algorithm has good scalability and performance on very large databases. Finally, we present a real-world navigation application in which SHUIs generated from the traffic congestion data have been employed to recommend alternative routes to the users.

Periodic-frequent pattern mining (PFPM) is an important data mining model having many real-world applications. However, the successful industrial application of this model has been hindered by the problem of combinatorial explosion of patterns, that is the generation of too many redundant patterns, most of which may be useless to the user. To address this problem, this paper proposes a novel model of maximal periodic- frequent pattern that may exist in a temporal database. A new pattern-growth algorithm, called Maximum Periodic-Frequent Pattern-growth (maxPFP-growth), has also been introduced to efficiently find all desired patterns in the data. Experimental results demonstrate that maxPFP-growth is not only memory and runtime efficient, but also highly scalable as well. The usefulness of our model has also been demonstrated with a case study on traffic congestion analytics.

Logical errors in source code can be detected by probabilities obtained from a language model trained by the recurrent neural network (RNN). Using the probabilities and determining thresholds, places that are likely to be logic errors can be enumerated. However, when the threshold is set inappropriately, user may miss true logical errors because of passive extraction or unnecessary elements obtained from excessive extraction. Moreover, the probabilities of output from the language model are different for each task, so the threshold should be selected properly. In this paper, we propose a logic error detection algorithm using an RNN and an automatic threshold determination method. The proposed method selects thresholds using incorrect codes and can enhance the detection performance of the trained language model. For evaluating the proposed method, experiments with data from an online judge system, which is one of the educational systems that provide the automated judge for many programming tasks, are conducted. The experimental results show that the selected thresholds can be used to improve the logic error detection performance of the trained language model.

Programming in pictures is an approach where pictures and moving pictures are used as super-characters to represent the features of computational algorithms and data structures, as well as for explaining the models and application methods involved. *AIDA is a computer language that supports programming in pictures. This language and its environment have been developed and promoted as a testbed for various innovations in information technology (IT) research and implementation, including exploring the compactness of the programs and their adaptive software systems, and obtaining better understanding of information resources. In this paper, new features of the environment and methods of their implementation are presented. They are considered within a case study of a large-scale module of a nuclear safety analysis system to demonstrate that *AIDA language is appropriate for developing efficient codes of serious applications and for providing support, based on folding/unfolding techniques, enhancing the readability, maintainability and algorithmic transparency of programs. Features of this support and the code efficiency are presented through the results of a computational comparison with a FORTRAN equivalent.

In recent years, vast amounts of unstructured data have been and are being produced from multiple sources around the world. In the field of data mining, clustering is the most efficient technique for grouping such unstructured or unsupervised data. In its basic form, data clustering is an unsupervised method that groups or cluster objects so that all objects within the same cluster are very similar to each other, whereas objects grouped similarly in the different clusters are quite distinct. However, due to the exponential growth of data amounts available in a wide variety of scientific fields, it has become increasingly difficult to manipulate and analyze such information. In addition, it is becoming progressively more cumbersome to extract hidden features from the resulting huge unstructured and unsupervised datasets. This study reports on an improved general k-means clustering algorithm that was created by modifying its initial centroid selection process and adding a new outlier detection and filtering algorithm. Under normal conditions, most algorithms select initial centroids randomly, which often leads to poor initial cluster quality. Additionally, most existing outlier detection techniques are inadequate due to their poor accuracy levels, high computational complexity, and inability to identify outlier data. In contrast, after an analysis of comprehensive experiments performed to validate our approach via comparisons against existing techniques and benchmark performance values, we found that our proposed approach performs better than existing methods in terms of initial centroid selection, outlier detection, and other related matters.

Debugging a program is always an obstacle to programmers and learners. In particular, novice programmers waste a lot of time finding bugs, so a feedback system to support debugging is required. Although existing editors and IDEs support finding syntax errors, their functions for detecting logical errors are limited. In the present paper, we present bug detection methods for the feedback system of an online judge system which contains many programming problems and accumulates numerous lines of solution source code. The proposed method uses the solutions and a language model based on long short-term memory (LSTM) networks for bug detection. In addition, since LSTM networks have some hyperparameters, we investigate the best model for bug detection in terms of perplexity and training time. The results of experiments show that models trained by solutions can detect bugs in a compiled code based on the static structure of a program.

Most keyword searches target precision for finding the most relevant document. However some target recall, finding all relevant documents. Our system supports high recall searches that return hundreds or thousands of relevant results. In particular, it provides a visualization that shows the distribution of search results relative to the distribution of items for the entire corpus. Such relative distributional features include over and under representation, clusters and outliers. The contribution of this paper is efficient visualisation, that is, how to provide the best relative distribution view for a given data cube size. This requirement is translated to: for which limited size meta-data summary cube are search results disambiguated the most in our relative distribution view. We identify metrics and several algorithms for such a summary cube selection.

*AIDA is a language supporting programming in pictures. Programming in pictures is an approach whereby pictures and animation are used as super-characters for representing features of computational algorithms and data structures, as well as for explaining models and application methods involved. In this paper, some features of *AIDA programs are discussed and how these features can be applied for educational goals oriented to users with little programming experience. Special attention is paid to algorithmic dynamics explanations based on animations and to template programs supporting the implementation of this dynamics.

Programming in pictures is an approach whereby pictures and moving pictures are used as super-characters to represent features of computational algorithms and data structures, as well as to explain models and application methods involved. ∗AIDA is a language supporting programming in pictures. In this paper, a fluid dynamics problem is considered and an example of a ∗AIDA program for fluid flow simulation is provided. The program is presented as a set of information resources oriented not only to the executable code generation, but also to an explanation of the problem and its application algorithm. Various features of the ∗AIDA program are discussed and some comparisons with a Fortran equivalent are performed.

*AIDA modeling/programming language is based on algorithmic pictures and animations as super-characters for representing and explaining features of computational (or other type) algorithms. Generic pictures are used to define compound pictures and compound pictures are assembled into special series (Cyber-scenes) prepared for automatic code generation. There are super-characters related to space structures for imitating some physical regions (shapes) in 3-D space and (computational) activities in time on structure nodes, and to diagram structures for representing connections between a set of activity units and specifying a partial order of the activity execution. The sets of the super-characters are open and adding new ones is implemented as a special knowledge/experience acquisition to support various modeling techniques and applications. In this paper we focus on the diagram structures and present how new Cyber-scenes for statechart and clients-server alliances are incorporated into *AIDA language.

'AIDA is a programming/modeling language where pictures and moving pictures are used as super-characters to define computational models and algorithms. In this language, pictures related to units-of-measure can be assigned to each variable as declarations of their dimension units and as annotations which enhance user's perception of application computation and can also be used for checking consistency of formulas involved. In this paper, a set of the super-characters for these declarations/annotations, as well as an algorithm for units-of-measure analysis and its implementation within 'AIDA language are presented. The approach is based on dimensional analysis (of variables and formulas) which employs checking not only dimensions but also units of them. Some practical details of the algorithm and its implementation are presented. Special attention is paid to parsing processes of C++ expressions, which are behind the picture-based expressions, and to automatic checking the units-of-measure consistency.

Programming in pictures is an approach where pictures and moving pictures are used as an algorithmic alphabet to represent algorithms. Super-characters of this alphabet are used to represent algorithmic steps (called Algorithmic CyberFrames) which are assembled into special series to represent algorithmic features. A number of the series is assembled into an Algorithmic CyberFilm. The filmification of methods has been applied to a large variety of algorithms to test expressive features of the pictures for representing computation. In addition, cognitive aspects of programming in pictures and embedded clarity annotations supporting the approach and visual inspections by other people have also been analyzed. In this paper we focus on features of the algorithmic picture language and the filmification modeling environment which can be used for automatic and/or interactive checking of application model correctness. An overview of different sources of information about the same features of the application model is considered and concrete examples of automatic checking are provided.

“Programming in pictures,” or “filmification of methods” is an approach where pictures and moving pictures are used as super-characters for representing features of computational algorithms. A Filmification Modeling environment supporting the approach is based on a set of generic pictures and related editors/browsers allowing the development of compound pictures of algorithmic steps. The compound pictures are assembled into special series representing different views of algorithmic features. These views are employed to split the programming process into special stages and to support understandability of the programs within the framework of visual debugging or external inspection. In this paper, a brief introduction of the approach and the environment are presented to prepare a basis for the demonstration.

We demonstrate a system that integrates a novel OLAP component with a keyword search engine, to support querying over sparse and ragged corpus data. The key contribution of our system is the integration of dynamically selected point sets such as search results with OLAP querying over aggregated data. During the demonstration, participants will be able to enter a keyword search; observe the returned list of result files; observe distributional features such as outliers and clusters of results in the corpus in multiple dimension views; and select and partition corpus slices in the OLAP component to narrow search results. Participants will be able to experience not just the individual querying features of our system, but the way that they work together to facilitate smooth interaction sequences that combine OLAP and keyword search querying.

A multilevel approach to realize a self-explanatory representation of symbols, variables, language constructs and software components is considered. Some aspects related to the implementation of the approach within the concept of Filmification of methods are provided. In particular, super-symbols and constructs of Language of Integrated view and Language of Algorithmic interFaces of a cyber-Film programming environment are analyzed and examples of embedded-clarity support are presented.

A general scheme of software development process is considered and some aspects related to integrating security into this scheme are analyzed. In particular, semantic-based, defense-in-depth techniques embedded into system/component defense shields and data acquiring/monitoring kernels are considered. The defense shields are to semantically check data of every input before a software component may process them and also to check every output before sending it to other components. The kernels are to regularly perform semantic analysis of the internal status and local data of a component/system. Based on these two ideas, real-time discovery of vulnerabilities and threats is possible even when various protective measures, such as, passwords, firewalls, intrusion detection systems, access control lists, etc. have been breached. Existing programming systems and possible new methods to realize the shields and kernels are also considered.