329 research outputs found
CS Circles: An In-Browser Python Course for Beginners
Computer Science Circles is a free programming website for beginners that is
designed to be fun, easy to use, and accessible to the broadest possible
audience. We teach Python since it is simple yet powerful, and the course
content is well-structured but written in plain language. The website has over
one hundred exercises in thirty lesson pages, plus special features to help
teachers support their students. It is available in both English and French. We
discuss the philosophy behind the course and its design, we describe how it was
implemented, and we give statistics on its use.Comment: To appear in SIGCSE 201
Practically Applicable Formal Methods
Abstract. Formal methods are considered to be highly expensive. There-fore, they are currently applied almost only in high risk software develop-ment. In this paper, we show that formal techniques can be also efficiently used in standard large-scale applications. We focus on the generation of specifications which state the termination condition of for loops in Java code (expressed as so called Java Modeling Language decreases clauses). We demonstrate that with help of relatively simple techniques it is pos-sible to successfully generate the clauses for almost 80 % of the loops in a number of widely deployed applications. Moreover, it turns out that the remaining 20 % cases contain loops which should be carefully reviewed by software quality assurance personnel. The results show that our tech-nique might be helpful in spreading the usage of formal methods onto typical business software
An overview of the ciao multiparadigm language and program development environment and its design philosophy
We describe some of the novel aspects and motivations behind
the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest levéis of optimization are used, even that of static languages, all while retaining the interactive development environment of a dynamic language. The environment also includes a powerful auto-documenter. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in the format of a paper, pointing instead to the existing literature on the system
Kevoree Modeling Framework (KMF): Efficient modeling techniques for runtime use
The creation of Domain Specific Languages(DSL) counts as one of the main
goals in the field of Model-Driven Software Engineering (MDSE). The main
purpose of these DSLs is to facilitate the manipulation of domain specific
concepts, by providing developers with specific tools for their domain of
expertise. A natural approach to create DSLs is to reuse existing modeling
standards and tools. In this area, the Eclipse Modeling Framework (EMF) has
rapidly become the defacto standard in the MDSE for building Domain Specific
Languages (DSL) and tools based on generative techniques. However, the use of
EMF generated tools in domains like Internet of Things (IoT), Cloud Computing
or Models@Runtime reaches several limitations. In this paper, we identify
several properties the generated tools must comply with to be usable in other
domains than desktop-based software systems. We then challenge EMF on these
properties and describe our approach to overcome the limitations. Our approach,
implemented in the Kevoree Modeling Framework (KMF), is finally evaluated
according to the identified properties and compared to EMF.Comment: ISBN 978-2-87971-131-7; N° TR-SnT-2014-11 (2014
SHAPES : Easy and high-level memory layouts
CPU speeds have vastly exceeded those of RAM. As such, developers who aim to achieve high
performance on modern architectures will most likely need to consider how to use CPU caches
effectively, hence they will need to consider how to place data in memory so as to exploit spatial
locality and achieve high memory bandwidth.
Performing such manual memory optimisations usually sacrifices readability, maintainability,
memory safety, and object abstraction. This is further exacerbated in managed languages, such
as Java and C#, where the runtime abstracts away the memory from the developer and such
optimisations are, therefore, almost impossible.
To that extent, we present in this thesis a language extension called SHAPES . SHAPES aims
to offer developers more fine-grained control over the placement of data, without sacrificing
memory safety or object abstraction, hence retaining the expressiveness and familiarity of OOP.
SHAPES introduces the concepts of pools and layouts; programmers group related objects into
pools, and specify how objects are laid out in these pools. Classes and types are annotated
by pool parameters, which allow placement aspects to be changed orthogonally to how the
business logic operates on the objects in the pool. These design decisions disentangle business
logic and memory concerns.
We provide a formal model of SHAPES , present its type and memory safety model, and its
translation into a low-level language. We present our reasoning as to why we can expect
SHAPES to be compiled in an efficient manner in terms of the runtime representation of objects
and the access to their fields.
Moreover, we present SHAPES -z, an implementation of SHAPES as an embeddable language,
and shapeszc , the compiler for SHAPES -z. We provide our our design and implementation
considerations for SHAPES -z and shapeszc . Finally, we evaluate the performance of SHAPES
and SHAPES -z through case studies.Open Acces
MELT - a Translated Domain Specific Language Embedded in the GCC Compiler
The GCC free compiler is a very large software, compiling source in several
languages for many targets on various systems. It can be extended by plugins,
which may take advantage of its power to provide extra specific functionality
(warnings, optimizations, source refactoring or navigation) by processing
various GCC internal representations (Gimple, Tree, ...). Writing plugins in C
is a complex and time-consuming task, but customizing GCC by using an existing
scripting language inside is impractical. We describe MELT, a specific
Lisp-like DSL which fits well into existing GCC technology and offers
high-level features (functional, object or reflexive programming, pattern
matching). MELT is translated to C fitted for GCC internals and provides
various features to facilitate this. This work shows that even huge, legacy,
software can be a posteriori extended by specifically tailored and translated
high-level DSLs.Comment: In Proceedings DSL 2011, arXiv:1109.032
Dynamically typed languages
Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features
- …