835 research outputs found
Declarative Ajax Web Applications through SQL++ on a Unified Application State
Implementing even a conceptually simple web application requires an
inordinate amount of time. FORWARD addresses three problems that reduce
developer productivity: (a) Impedance mismatch across the multiple languages
used at different tiers of the application architecture. (b) Distributed data
access across the multiple data sources of the application (SQL database, user
input of the browser page, session data in the application server, etc). (c)
Asynchronous, incremental modification of the pages, as performed by Ajax
actions.
FORWARD belongs to a novel family of web application frameworks that attack
impedance mismatch by offering a single unifying language. FORWARD's language
is SQL++, a minimally extended SQL. FORWARD's architecture is based on two
novel cornerstones: (a) A Unified Application State (UAS), which is a virtual
database over the multiple data sources. The UAS is accessed via distributed
SQL++ queries, therefore resolving the distributed data access problem. (b)
Declarative page specifications, which treat the data displayed by pages as
rendered SQL++ page queries. The resulting pages are automatically
incrementally modified by FORWARD. User input on the page becomes part of the
UAS.
We show that SQL++ captures the semi-structured nature of web pages and
subsumes the data models of two important data sources of the UAS: SQL
databases and JavaScript components. We show that simple markup is sufficient
for creating Ajax displays and for modeling user input on the page as UAS data
sources. Finally, we discuss the page specification syntax and semantics that
are needed in order to avoid race conditions and conflicts between the user
input and the automated Ajax page modifications.
FORWARD has been used in the development of eight commercial and academic
applications. An alpha-release web-based IDE (itself built in FORWARD) enables
development in the cloud.Comment: Proceedings of the 14th International Symposium on Database
Programming Languages (DBPL 2013), August 30, 2013, Riva del Garda, Trento,
Ital
Recommended from our members
Righting Web Development
The web browser is the most important application runtime today, encompassing all types of applications on practically every Internet-connected device. Browsers power complete office suites, media players, games, and augmented and virtual reality experiences, and they integrate with cameras, microphones, GPSes, and other sensors available on computing devices. Many apparently native mobile and desktop applications are secretly hybrid apps that contain a mix of native and browser code. History has shown that when new devices, sensors, and experiences appear on the market, the browser will evolve to support them.
Despite the browser\u27s importance, developing web applications is exceedingly difficult. Web browsers organically evolved from a document viewer into a ubiquitous program runtime. The browser\u27s scripting language for web designers, JavaScript, has grown into the only universally supported programming language in the browser. Unfortunately, JavaScript is notoriously difficult to write and debug. The browser\u27s high-level and event-driven I/O interfaces make it easy to add simple interactions to webpages, but these same interfaces lead to nondeterministic bugs and performance issues in larger applications. These bugs are challenging for developers to reason about and fix.
This dissertation revisits web development and provides developers with a complete set of development tools with full support for the browser environment. McFly is the first time-traveling debugger for the browser, and lets developers debug web applications and their visual state during time-travel; components of this work shipped in Microsoft\u27s ChakraCore JavaScript engine. BLeak is the first system for automatically debugging memory leaks in web applications, and provides developers with a ranked list of memory leaks along with the source code responsible for them. BCause constructs a causal graph of a web application\u27s events, which helps developers understand their code\u27s behavior. Doppio lets developers run code written in conventional languages in the browser, and Browsix brings Unix into the browser to enable unmodified programs expecting a Unix-like environment to run directly in the browser. Together, these five systems form a solid foundation for web development
Serverless computing
Serverless computing has emerged as a new mindset when it comes to cloud computing,
promising efficient resource utilization, automatic scaling, and cost optimization for a wide
range of applications. This thesis explores the adoption, performance, and cost considera tions of deploying applications that use intend to use serverless functions, one of the leading
Serverless types.
This thesis starts by providing an overview of Serverless computing, including its key advan tages and disadvantages and the rising adoption it has gained throughout the recent years.
It presents a comprehensive comparison of various Serverless platforms and discusses the
unique features offered by each.
After this context phase, this thesis presents a design section composed by a migration guide
that allows developers to transition from a traditional application to one that takes advan tage of serverless benefits. The guide outlines best practices and step-by-step instructions,
facilitating the adoption of Serverless computing in real-world scenarios.
Using the previously created guide, the next section carries out a practical use case: the mi gration of complex computational logic from a traditional Java application to AWS Lambda
functions. Performance evaluations are conducted, considering metrics such as the execution
duration and the amount of concurrent executions.
These findings are then evaluated next to the costs associated with deploying and running
Java applications in a virtual machine or with a Serverless architecture.
While Serverless computing is quite promising, networking issues often arise in practice,
affecting the overall efficiency of Serverless applications. This thesis addresses these chal lenges, identifying the installation and migration difficulties, how to overcome them, and
what are the expected limitations, while proposing potential solutions.
In summary, this thesis offers valuable insights into the adoption, performance, and cost opti mization of Serverless computing for Java applications. It provides a roadmap for developers
looking to take advantage of the benefits of Serverless computing in their projects
Applying big data paradigms to a large scale scientific workflow: lessons learned and future directions
The increasing amounts of data related to the execution of scientific workflows has raised awareness of their shift towards parallel data-intensive problems. In this paper, we deliver our experience combining the traditional high-performance computing and grid-based approaches with Big Data analytics paradigms, in the context of scientific ensemble workflows. Our goal was to assess and discuss the suitability of such data-oriented mechanisms for production-ready workflows, especially in terms of scalability. We focused on two key elements in the Big Data ecosystem: the data-centric programming model, and the underlying infrastructure that integrates storage and computation in each node. We experimented with a representative MPI-based iterative workflow from the hydrology domain, EnKF-HGS, which we re-implemented using the Spark data analysis framework. We conducted experiments on a local cluster, a private cloud running OpenNebula, and the Amazon Elastic Compute Cloud (AmazonEC2). The results we obtained were analysed to synthesize the lessons we learned from this experience, while discussing promising directions for further research.This work was supported by the Spanish Ministry of Economics and Competitiveness grant TIN-2013-41350-P, the IC1305 COST Action “Network for Sustainable Ultrascale Computing Platforms” (NESUS), and the FPU Training Program for Academic and Teaching Staff Grant FPU15/00422 by the Spanish Ministry of Education
Extension of a task-based model to functional programming
Recently, efforts have been made to bring together the areas of high-performance computing (HPC) and massive data processing (Big Data). Traditional HPC frameworks, like COMPSs, are mostly task-based, while popular big-data environments, like Spark, are based on functional programming principles. The earlier are know for their good performance for regular, matrix-based computations; on the other hand, for fine-grained, data-parallel workloads, the later has often been considered more successful. In this paper we present our experience with the integration of some dataflow techniques into COMPSs, a task-based framework, in an effort to bring together the best aspects of both worlds. We present our API, called DDF, which provides a new data abstraction that addresses the challenges of integrating Big Data application scenarios into COMPSs. DDF has a functional-based interface, similar to many Data Science tools, that allows us to use dynamic evaluation to adapt the task execution in runtime. Besides the performance optimization it provides, the API facilitates the development of applications by experts in the application domain. In this paper we evaluate DDF's effectiveness by comparing the resulting programs to their original versions in COMPSs and Spark. The results show that DDF can improve COMPSs execution time and even outperform Spark in many use cases.This work was partially supported by CAPES, CNPq, Fapemig and NIC.BR, and by projects Atmosphere (H2020-EU.2.1.1 777154) and INCT-Cyber.Peer ReviewedPostprint (author's final draft
ITSS: Interactive Web-Based Authoring and Playback Integrated Environment for Programming Tutorials
Video-based programming tutorials are a popular form of tutorial used by
authors to guide learners to code. Still, the interactivity of these videos is
limited primarily to control video flow. There are existing works with
increased interactivity that are shown to improve the learning experience.
Still, these solutions require setting up a custom recording environment and
are not well-integrated with the playback environment. This paper describes our
integrated ITSS environment and evaluates the ease of authoring and playback of
our interactive programming tutorials. Our environment is designed to run
within the browser sandbox and is less intrusive to record interactivity
actions. We develop a recording approach that tracks the author's interactivity
actions (e.g., typing code, highlighting words, scrolling panels) on the
browser and stored in text and audio formats. We replay these actions using the
recorded artefacts for learners to have a more interactive, integrated and
realistic playback of the author's actions instead of watching video frames.
Our design goals are 1) efficient recording and playback, 2) extensible
interactivity features to help students learn better, and 3) a scalable
web-based environment. Our first user study of 20 participants who carry out
the author tasks agree that it is efficient and easy to author interactive
videos in our environment with no additional software needed. Our second user
study of 84 students using the environment agrees that the increased
interactivity can help them learn better over a video-based tutorial. Our
performance test shows that the environment can scale to support up to 500
concurrent users. We hope our open-source environment enable more educators to
create interactive programming tutorials
- …