Journal of Computer Languages最新文献

Context:

MATLAB is a programming language vastly used in scientific and engineering domains by engineers, scientists, and researchers. Still, MATLAB seems to be perceived as being used mainly by non-professional programmers, not taking full advantage of MATLAB’s features (e.g., OOP-support). The current state of the art does not seem to verify these assumptions.

Objectives:

Our goal was to fill the gap in the characteristics of the MATLAB community and its users, how proficient they are with the MATLAB, and what is their satisfaction level.

Methods:

We performed a survey with 212 valid responses, aiming to characterize the community of MATLAB users and clone languages. The survey was published on several platforms, including Reddit, Linkedin, and MATLAB Central.

Results:

There is a balanced distribution across different levels of experience in the community. (12.74%) of our sample uses MATLAB only through the command window. The more users expect other people to use their programs, the more effort they will put into making the code easy to understand, maintain and reuse. The use of OOP is not widespread (22%). The majority of MATLAB users are satisfied with its modularity support.

Conclusions:

Our study provides insights into MATLAB’s use patterns that are potentially useful for entities responsible for MATLAB’s future evolution.

Stream processing applications have seen an increasing demand with the raised availability of sensors, IoT devices, and user data. Modern systems can generate millions of data items per day that require to be processed timely. To deal with this demand, application programmers must consider parallelism to exploit the maximum performance of the underlying hardware resources. In this work, we introduce improvements to stream processing applications by exploiting fine-grained data parallelism (via Map and MapReduce) inside coarse-grained stream parallelism stages. The improvements are including techniques for identifying data parallelism in sequential codes, a new language, semantic analysis, and a set of definition and transformation rules to perform source-to-source parallel code generation. Moreover, we investigate the feasibility of employing higher-level programming abstractions to support the proposed optimizations. For that, we elect SPar programming model as a use case, and extend it by adding two new attributes to its language and implementing our optimizations as a new algorithm in the SPar compiler. We conduct a set of experiments in representative stream processing and data-parallel applications. The results showed that our new compiler algorithm is efficient and that performance improved by up to 108.4x in data-parallel applications. Furthermore, experiments evaluating stream processing applications towards the composition of stream and data parallelism revealed new insights. The results showed that such composition may improve latencies by up to an order of magnitude. Also, it enables programmers to exploit different degrees of stream and data parallelism to accomplish a balance between throughput and latency according to their necessity.

Dynamically-typed programming languages are often implemented using interpreters, which offer several advantages in terms of portability and flexibility of the implementation. However, as a language matures and its programs get bigger, programmers may seek compilers, to avoid the interpretation overhead.

In this study, we present LuaAOT, a simple ahead-of-time compiler for Lua derived from the reference Lua interpreter. We describe two alternative compilation strategies. The first one exemplifies an old idea of using partial evaluation to produce a compiler based on an existing interpreter. Its contribution is to apply this idea to a well-established programming language. We show that with a quite modest effort it is possible to implement an efficient compiler that covers the entirety of Lua, including coroutines and tail calls. The whole implementation required less than 500 lines of new code. For this effort, we reduced the running time of our benchmarks from 20% to 60%.

The second compilation strategy is based on function “outlining”, where each bytecode is implemented by a small subroutine. This strategy reduces executable sizes and compilation times, at the cost of not speeding up the running times as much as the first compilation method.

The large-scale adoption of systems that automate classifications using Machine Learning (ML) algorithms raises pressing challenges as they support or make decisions with profound consequences for human beings. It is important to understand how users’ trust is affected by ML models’ suggestions, even when those models are wrong. Many research efforts have focused on the user’s ability to interpret what a model has learned. In this paper, we seek to understand another aspect of ML interpretability: whether and how the presence of classification probabilities and their different distributions are related to users’ trust in model outcomes, especially in ambiguous instances. To this end, we conducted two online surveys in which we asked participants to evaluate their agreement with image classifications of pictures of animals made by an ML model. In the first, we analyze their trust before and after presenting them the model classification probabilities. In the second, we investigate the relationships between class probability distributions and users’ trust in the model. We found that, in some cases, the additional information is correlated with undue trust in the model’s classifications. However, in others, they are associated with inappropriate skepticism.

Access policies specify what are the actions that different actors can perform on available resources. Access policies are a core notion in multiuser environments, such as operating systems and distributed databases. Currently, most of these systems use general data specification languages, such as JSON, XML and YAML to describe access policies. Yet, domain-specific languages are also available for this task. One of such languages is Legalease, from Microsoft. This paper presents a new version of Legalease, called Hapi. Hapi replaces Legalease’s notion of a lattice with a partially ordered set (poset). Posets improve the expressivity of Legalease, at the expenses of a more expensive verification algorithm. This poset-based representation generalizes the notion of actors, actions and resources to user-defined entities. Hapi is publicly available. Its distribution includes a policy visualizer and a code-compression tool to efficiently store specifications.

We propose a novel framework to automatically design and generate exquisite color mandala patterns. First, we summarize pre-requirements for generating reasonable and applicable mandala patterns followed by introducing COOM (Curve, Object, Operation and Model), the fundamental framework of mandala pattern generator. The framework defines how to effectively create visually pleasing mandala sketches. Then we propose a color transfer-based method to colorize the mandala sketch, in which all similar regions will share the same color. Currently, the automatically generated mandala patterns have been used in a mobile game with 3 million DAU (Daily Active Users). The experiments show that our mandala generator is quite effective and comparable with professional artists.