68,579 research outputs found
Child programming: an adequate domain specific language for programming specific robots
Dissertação para obtenção do Grau de Mestre em
Engenharia InformáticaDue to the limited existence of dedicated robot programming solutions for children (as
well as scientific studies), this work presents the design and implementation of a visual domain specific language (DSL), using the Model-Driven Development approach(MDD), for programming robotics and automaton systems with the goal to increase productivity and simplify the software development process. The target audience for this DSL is mostly children with ages starting from 8 years old.
Our work implied to use the typical Software Language Engineering life cycle, starting
by an elaborate study of the user’s profile, based on work in cognitive sciences, and
a Domain analysis. Several visual design paradigms were considered during the design
phase of our DSL, and we have focused our studies on the Behavior Trees paradigm, a
paradigm intensively used in the gaming industry. Intuitive, simplicity and a small learning curve were the three main concerns considered during the design and development
phases.
To help validating the DSL and the proposed approach, we used a concrete robotic
product for children built with the Open Source Arduino platform as target domain. The
last part of this work was dedicated to study the adequacy of the language design choices, compared to other solutions (including commercial technologies), to the target users with different ages and different cognitive-development stages. We have also studied the benefits of the chosen paradigm to domain experts’ proficient on robot programming in different paradigms to determine the possibility to generalize the solution to different user profiles
Fortran for the nineties
Fortran has largely enjoyed prominence for the past few decades as the computer programming language of choice for numerically intensive scientific, engineering, and process control applications. Fortran's well understood static language syntax has allowed resulting parsers and compiler optimizing technologies to often generate among the most efficient and fastest run-time executables, particularly on high-end scalar and vector supercomputers. Computing architectures and paradigms have changed considerably since the last ANSI/ISO Fortran release in 1978, and while FORTRAN 77 has more than survived, it's aged features provide only partial functionality for today's demanding computing environments. The simple block procedural languages have been necessarily evolving, or giving way, to specialized supercomputing, network resource, and object-oriented paradigms. To address these new computing demands, ANSI has worked for the last 12-years with three international public reviews to deliver Fortran 90. Fortran 90 has superseded and replaced ISO FORTRAN 77 internationally as the sole Fortran standard; while in the US, Fortran 90 is expected to be adopted as the ANSI standard this summer, coexisting with ANSI FORTRAN 77 until at least 1996. The development path and current state of Fortran will be briefly described highlighting the many new Fortran 90 syntactic and semantic additions which support (among others): free form source; array syntax; new control structures; modules and interfaces; pointers; derived data types; dynamic memory; enhanced I/O; operator overloading; data abstraction; user optional arguments; new intrinsics for array, bit manipulation, and system inquiry; and enhanced portability through better generic control of underlying system arithmetic models. Examples from dynamical astronomy, signal and image processing will attempt to illustrate Fortran 90's applicability to today's general scalar, vector, and parallel scientific and engineering requirements and object oriented programming paradigms. Time permitting, current work proceeding on the future development of Fortran 2000 and collateral standards will be introduced
Diva: A Declarative and Reactive Language for In-Situ Visualization
The use of adaptive workflow management for in situ visualization and
analysis has been a growing trend in large-scale scientific simulations.
However, coordinating adaptive workflows with traditional procedural
programming languages can be difficult because system flow is determined by
unpredictable scientific phenomena, which often appear in an unknown order and
can evade event handling. This makes the implementation of adaptive workflows
tedious and error-prone. Recently, reactive and declarative programming
paradigms have been recognized as well-suited solutions to similar problems in
other domains. However, there is a dearth of research on adapting these
approaches to in situ visualization and analysis. With this paper, we present a
language design and runtime system for developing adaptive systems through a
declarative and reactive programming paradigm. We illustrate how an adaptive
workflow programming system is implemented using our approach and demonstrate
it with a use case from a combustion simulation.Comment: 11 pages, 5 figures, 6 listings, 1 table, to be published in LDAV
2020. The article has gone through 2 major revisions: Emphasized
contributions, features and examples. Addressed connections between DIVA and
FRP. In sec. 3, we fixed a design flaw and addressed it in sec. 3.3-3.4.
Re-designed sec. 5 with a more concrete example and benchmark results.
Simplified the syntax of DIV
Can Computer Algebra be Liberated from its Algebraic Yoke ?
So far, the scope of computer algebra has been needlessly restricted to exact
algebraic methods. Its possible extension to approximate analytical methods is
discussed. The entangled roles of functional analysis and symbolic programming,
especially the functional and transformational paradigms, are put forward. In
the future, algebraic algorithms could constitute the core of extended symbolic
manipulation systems including primitives for symbolic approximations.Comment: 8 pages, 2-column presentation, 2 figure
A Comparative Study of Programming Languages in Rosetta Code
Sometimes debates on programming languages are more religious than
scientific. Questions about which language is more succinct or efficient, or
makes developers more productive are discussed with fervor, and their answers
are too often based on anecdotes and unsubstantiated beliefs. In this study, we
use the largely untapped research potential of Rosetta Code, a code repository
of solutions to common programming tasks in various languages, to draw a fair
and well-founded comparison. Rosetta Code offers a large data set for analysis.
Our study is based on 7087 solution programs corresponding to 745 tasks in 8
widely used languages representing the major programming paradigms (procedural:
C and Go; object-oriented: C# and Java; functional: F# and Haskell; scripting:
Python and Ruby). Our statistical analysis reveals, most notably, that:
functional and scripting languages are more concise than procedural and
object-oriented languages; C is hard to beat when it comes to raw speed on
large inputs, but performance differences over inputs of moderate size are less
pronounced and allow even interpreted languages to be competitive; compiled
strongly-typed languages, where more defects can be caught at compile time, are
less prone to runtime failures than interpreted or weakly-typed languages. We
discuss implications of these results for developers, language designers, and
educators
Lisp, Jazz, Aikido -- Three Expressions of a Single Essence
The relation between Science (what we can explain) and Art (what we can't)
has long been acknowledged and while every science contains an artistic part,
every art form also needs a bit of science. Among all scientific disciplines,
programming holds a special place for two reasons. First, the artistic part is
not only undeniable but also essential. Second, and much like in a purely
artistic discipline, the act of programming is driven partly by the notion of
aesthetics: the pleasure we have in creating beautiful things. Even though the
importance of aesthetics in the act of programming is now unquestioned, more
could still be written on the subject. The field called "psychology of
programming" focuses on the cognitive aspects of the activity, with the goal of
improving the productivity of programmers. While many scientists have
emphasized their concern for aesthetics and the impact it has on their
activity, few computer scientists have actually written about their thought
process while programming. What makes us like or dislike such and such language
or paradigm? Why do we shape our programs the way we do? By answering these
questions from the angle of aesthetics, we may be able to shed some new light
on the art of programming. Starting from the assumption that aesthetics is an
inherently transversal dimension, it should be possible for every programmer to
find the same aesthetic driving force in every creative activity they
undertake, not just programming, and in doing so, get deeper insight on why and
how they do things the way they do. On the other hand, because our aesthetic
sensitivities are so personal, all we can really do is relate our own
experiences and share it with others, in the hope that it will inspire them to
do the same. My personal life has been revolving around three major creative
activities, of equal importance: programming in Lisp, playing Jazz music, and
practicing Aikido. But why so many of them, why so different ones, and why
these specifically? By introspecting my personal aesthetic sensitivities, I
eventually realized that my tastes in the scientific, artistic, and physical
domains are all motivated by the same driving forces, hence unifying Lisp,
Jazz, and Aikido as three expressions of a single essence, not so different
after all. Lisp, Jazz, and Aikido are governed by a limited set of rules which
remain simple and unobtrusive. Conforming to them is a pleasure. Because Lisp,
Jazz, and Aikido are inherently introspective disciplines, they also invite you
to transgress the rules in order to find your own. Breaking the rules is fun.
Finally, if Lisp, Jazz, and Aikido unify so many paradigms, styles, or
techniques, it is not by mere accumulation but because they live at the
meta-level and let you reinvent them. Working at the meta-level is an
enlightening experience. Understand your aesthetic sensitivities and you may
gain considerable insight on your own psychology of programming. Mine is
perhaps common to most lispers. Perhaps also common to other programming
communities, but that, is for the reader to decide..
- …