1,312 research outputs found
Overcoming Language Dichotomies: Toward Effective Program Comprehension for Mobile App Development
Mobile devices and platforms have become an established target for modern
software developers due to performant hardware and a large and growing user
base numbering in the billions. Despite their popularity, the software
development process for mobile apps comes with a set of unique, domain-specific
challenges rooted in program comprehension. Many of these challenges stem from
developer difficulties in reasoning about different representations of a
program, a phenomenon we define as a "language dichotomy". In this paper, we
reflect upon the various language dichotomies that contribute to open problems
in program comprehension and development for mobile apps. Furthermore, to help
guide the research community towards effective solutions for these problems, we
provide a roadmap of directions for future work.Comment: Invited Keynote Paper for the 26th IEEE/ACM International Conference
on Program Comprehension (ICPC'18
In the Age of Web: Typed Functional-First Programming Revisited
Most programming languages were designed before the age of web. This matters
because the web changes many assumptions that typed functional language
designers take for granted. For example, programs do not run in a closed world,
but must instead interact with (changing and likely unreliable) services and
data sources, communication is often asynchronous or event-driven, and programs
need to interoperate with untyped environments.
In this paper, we present how the F# language and libraries face the
challenges posed by the web. Technically, this comprises using type providers
for integration with external information sources and for integration with
untyped programming environments, using lightweight meta-programming for
targeting JavaScript and computation expressions for writing asynchronous code.
In this inquiry, the holistic perspective is more important than each of the
features in isolation. We use a practical case study as a starting point and
look at how F# language and libraries approach the challenges posed by the web.
The specific lessons learned are perhaps less interesting than our attempt to
uncover hidden assumptions that no longer hold in the age of web.Comment: In Proceedings ML/OCaml 2014, arXiv:1512.0143
DEPENDENCY-BASED REACTIVE CHANGE PROPAGATION DESIGN PATTERN APPLIED TO ENVIRONMENTS WITH HIGH UNPREDICTABILITY
Transitional turbulence is a period of chaotic or unreliable variation in the state of a software system that results from changes in the system’s interconnected components. During these periods of instability, an external observer of the system’s state may “see” erroneous results. This is a problem that can affect visual user interfaces such as those in virtual and augmented reality applications and desktop or Web GUIs. In this research, we study two different reactive applications developed in C# on .NET. We reduce the transitional turbulence by augmenting the base applications with a dependency-graph-based event scheduling approach. The first study investigates desktop and Web GUIs. The second study investigates virtual and augmented reality applications built on the Unity3D game engine. The two studies use similar approaches, but both are somewhat embedded in the details of their applications and implementation platforms. In addition to presenting the two augmented applications, this dissertation characterizes the problem and its solution in a more general way. To do so, we use a design pattern to state the general problem-solution pair and enable it to be reused in similar contexts. We examine the two studies to identify their commonalities. We then unify the approaches by writing a new design pattern named Dynamically Coalescing Reactive Chains (DCRC). This dissertation both presents the new design pattern and records the systematic process we used to write it. To evaluate the design pattern and its usage, we apply it to the application in the first study as if we were approaching the application anew. The DCRC pattern facilitates the use of our approach for other applications and technologies and lays the foundation for further research on transitional turbulence and related software architecture issues
User friendly knowledge acquisition system for medical devices actuation
Dissertação para obtenção do Grau de Mestre em
Engenharia BiomédicaInternet provides a new environment to develop a variety of applications. Hence,
large amounts of data, increasing every day, are stored and transferred through the internet.
These data are normally weakly structured making information disperse, uncorrelated,
non-transparent and difficult to access and share. Semantic Web, proposed by
theWorldWideWeb Consortium (W3C), addresses this problem by promoting semantic
structured data, like ontologies, enabling machines to perform more work involved in
finding, combining, and acting upon information on theWeb.
Pursuing this vision, a Knowledge Acquisition System (KAS) was created, written
in JavaScript using JavaScript Object Notation (JSON) as the data structure and JSON
Schema to define that structure. It grants new ways to acquire and store knowledge
semantically structured and human readable. Plus, structuring data with a Schema generates
a software robust and error – free.
A novel Human Computer Interaction (HCI) framework was constructed employing
this KAS, allowing the end user to configure and control medical devices. To demonstrate
the potential of this tool, we present the configuration and control of an electrostimulator.
Nowadays, most of the software for Electrostimulation is made with specific purposes,
and in some cases they have complicated user interfaces and large, bulky designs
that deter usability and acceptability. The HCI concedes the opportunity to configure
and control an electrostimulator that surpasses the specific use of several electrostimulator
software. In the configuration the user is able to compile different types of electrical
impulses (modes) in a temporal session, automating the control, making it simple and
user-friendly
Future of Functional Reactive Programming in Real-Time Systems
The evolution of programming paradigms and the development of new programming languages are driven by the needs of problem domains. Functional reactive programming (FRP) combines functional programming (FP) and reactive programming (RP) concepts that leverage asynchronous dataflow from reactive programming and higher-level abstractions building blocks from functional programming to enable developers to define data flows and transformations declaratively. Declarative programming allows developers to concentrate more on the problem to be solved rather than the implementation details, resulting in efficient and concise code. Over the years, various FRP designs have been proposed in real-time application areas. Still, it remains unclear how FRP-based solutions compare with traditional methods for implementing these applications.
In this survey, we studied the usefulness of FRP in some real-time applications, such as game development, animation, graphical user interface(GUI), and embedded system. We conducted a qualitative comparison for game development and studied various applications in animation, GUI, and embedded systems. We found that using FRP in these applications is quite difficult because of insufficient libraries and tools. Additionally, due to high learning curves and a need for experienced developers, the development process in FRP takes time and effort. Our examination of two well-known games: Asteroid and Pong, in three programming paradigms: imperative programming using the Unity game engine, FP in Haskell, and FRP in the Yampa library, showed that imperative programming is effective in terms of performance and usability. The other two paradigms for developing games from scratch are inefficient and challenging. Despite the fact that FRP was designed for animation, the majority of its applications are underperforming. FRP is more successful for GUI applications, where libraries like RxJS have been used in many web interfaces. FRP is also applied in developing embedded system applications for its effective memory management, maintainability, and predictability.
Developing efficient solutions from scratch is not suitable in FRP due to several factors, such as poor performance compared to other programming paradigms, programming complexity, and a steep learning curve. Instead, developers can be benefited from utilizing FRP-supported modular platforms to build robust and scalable real-time applications
- …