Using the Web Workers API

SummaryJavaScript web applications are improving performance mainly thanks to the inclusion of new standards by HTML5. Among others, web workers API allows multithreaded JavaScript web apps to exploit parallel processors. However, developers have difficulties to determine the minimum number of web workers that provide the highest performance. But even if developers found out this optimal number, it is a static value configured at the beginning of the execution. Because users tend to execute other applications in background, the estimated number of web workers could be non‐optimal, because it may overload or underutilize the system. In this paper, we propose a solution for highly parallel web apps to dynamically adapt the number of running web workers to the actual available resources, avoiding the hassle to estimate a static optimal number of threads. The solution consists in the inclusion of a web worker pool and a simple management algorithm in the web app. Even though there are co‐running applications, the results show our approach dynamically enables a number of web workers close to the optimal. Our proposal, which is independent of the web browser, overcomes the lack of knowledge of the underlying processor architecture as well as dynamic resources availability changes. Copyright © 2015 John Wiley & Sons, Ltd.

Software evolution analysis can shed light on various aspects of software development and maintenance. Up to date, there is little empirical evidence on the evolution of JavaScript (JS) applications in terms of maintainability and changeability, even though JavaScript is among the most popular scripting languages for front-end web applications, including IoT applications. In this study, we investigate JS applications’ quality and changeability trends over time by examining the relevant Laws of Lehman. We analyzed over 7,500 releases of JS applications and reached some interesting conclusions. The results show that JS applications continuously change and grow, there are no clear signs of quality degradation while the complexity remains the same over time, despite the fact that the understandability of the code deteriorates.

Web Workers is a specification that defines an API which allows Web application developers to use background workers running scripts in parallel. Web Workers is used with JavaScript and is platform-independent. Hence, Web applications written in JavaScript can be used for a wide variety of purposes. There are many Web applications and some of them, for instance Internet election campaign and real-time broadcasting, need secure communications. We can include digital signatures with such Web applications to guarantee their security of communications. In this demonstration proposal, we assess the performance of parallel implementations of public key cryptosystems on several Web browsers (Internet Explorer, Google Chrome, Opera, and Firefox). With our implementation, it is possible to verify a message in 1.03 milliseconds on a Windows PC and 5.49 milliseconds on an Android tablet (Nexus 7). We also propose cryptography applications for Web browsers.

In this paper, we describe a load distribution technique that employs web workers. We have been implementing a web-based MORPG as an interactive, real-time web application; previously, the web server alone was responsible for manipulating the behavior of all the game characters. As more users logged in, the workload on the server was increased. Hence, we have implemented a technique whereby the CPU load of the server is distributed among the clients; a performance evaluation reveals that our technique plays a role in decreasing the CGI latency of low-end servers and can decrease the CPU load of high-end servers when many users are logged in.

One of the greatest challenges of FPGA is the crave for a platform, which runs a system, handles a software and co-ordinates exchange with peripherals. To explore this advantage on FPGA with energy efficiency, this work aims at developing multithreading on ARM cortex dual core A9 processor present in Zedboard FPGA. To enhance the speed of execution on this processor and to allow concurrency, multithreading is developed using intel thread building blocks(TBB) library which aids in creating task based parallelism on FPGA being the first of its kind. In the first step towards this process, the processor is booted with Ubuntu 12.04 linux operating system making it as a standalone processor. This system is enabled with graphical user interface using xillinux IP library FPGA code kit. To test the efficiency of multihreading on the processing system of Zedboard, an application known as 2D - raytracer is developed using the parallel-for loop scheduling method which aids in running all the iteration loops in the code into chunks and runs each chunk as a separate thread under intel TBB. In this application an image was parallelized by speculating each pixel running in parallel resulting in excellent speedup. The newly implemented multithreading achieves a speedup of 53% compared to sequential execution on the same processor. This method explores the flexibility of parallel processing on FPGA.

Code clone detection is an active field of study in computer science. Despite its rich history, it lacks focus on web scripting languages. Due to the expansion of web applications and web development amongst developers of varying education and experience levels, they inevitably resort to cloning through out the web. The spread of code clones is further increased by websites like StackOverflow and GitHub. In this paper, we will be focusing on clone detection research done to target clones in JavaScript code and discuss its areas of concern. Also, we will summarize language independent research done and possibility of its application on JavaScript and web applications.

Parallel hardware is today's reality and parallel programming models exist for most mainstream languages. Surprisingly JavaScript, the mother tongue of the web, is still stuck in its sequential past. JavaScript's unique programming model, the web's safety and security requirements, and the expectations of its programmers for determinism have impeded parallelization until now.Parallel JavaScript (code named River Trail) is a set of JavaScript extensions and an API that provides safe, deterministic parallelism to web applications while fitting within the event-driven, security oriented world of JavaScript applications. River Trail allows programmers to utilize available hardware parallelism on client machines - from SIMD units to multiple cores, using high-level parallel programming patterns.In this paper we describe River Trail, show how it can be used to provide a gentle introduction to parallelism using our selfcontained hands-on tutorial. At the end of the tutorial the student will have mastered the basic concepts of parallel programming and use this knowledge to build a realistic parallel HTML5 web application in River Trail.

This article compares two methods of employing novice Web workers to author descriptions of science, technology, engineering, and mathematics images to make them accessible to individuals with visual and print-reading disabilities. The goal is to identify methods of creating image descriptions that are inexpensive, effective, and follow established accessibility guidelines. The first method explicitly presented the guidelines to the worker, then the worker constructed the image description in an empty text box and table. The second method queried the worker for image information and then used responses to construct a template-based description according to established guidelines. The descriptions generated through queried image description (QID) were more likely to include information on the image category, title, caption, and units. They were also more similar to one another, based on Jaccard distances of q-grams, indicating that their word usage and structure were more standardized. Last, the workers preferred describing images using QID and found the task easier. Therefore, explicit instruction on image-description guidelines is not sufficient to produce quality image descriptions when using novice Web workers. Instead, it is better to provide information about images, then generate descriptions from responses using templates.

With the advent of the HTML5 standard, JavaScript is increasingly processing computationally intensive, data-parallel workloads. Thus, the enhancement of JavaScript performance has been emphasized because the performance gap between JavaScript and native applications is still substantial. Despite this urgency, conventional JavaScript compilers do not exploit much of parallelism even from data-parallel JavaScript applications, despite contemporary mobile devices being equipped with expensive parallel hardware platforms, such as multicore processors and GPGPUs. In this article, we propose an automatically parallelizing JavaScript compiler that targets emerging, data-parallel HTML5 applications by leveraging the mature affine loop analysis of conventional static compilers. We identify that the most critical issues when parallelizing JavaScript with a conventional static analysis are ensuring correct parallelization, minimizing compilation overhead, and conducting low-cost recovery when there is a speculation failure during parallel execution. We propose a mechanism for safely handling the failure at a low cost, based on compiler techniques and the property of idempotence. Our experiment shows that the proposed JavaScript parallelizing compiler detects most affine parallel loops. Also, we achieved a maximum speedup of 3.22 times on a quad-core system, while incurring negligible compilation and recovery overheads with various sets of data-parallel HTML5 applications.

JavaScript is a popular sequential language for implementing Web applications. To enable concurrent execution of JavaScript code, modern JavaScript engines support the Web Workers API. Using this API, developers can spawn concurrent background workers from a distinguished main worker. These workers, which run on the same machine (e.g., to exploit multicore), interact via message-passing.

Performance is one of the most important business requirements for web based applications. The suitability of better platform for any web based application depends on various factors attributable to processor architecture, memory, local/ global network, input/output characteristics etc. Performance testing is an important part of any distributed or web application testing plan. Inclusion of performance estimates into planning and development cycles ensures that the application delivered to the user satisfies sustained performance even at high load, availability and scalability requirements. In this paper we have thrown light on performance comparison of web applications on single and multi core servers. The tests have been carried out on single processor single core server and also on dual processor quad core Xeon based server. The performance comparison was carried out based on response time, throughput (No. of hits v/s response time) and connection pooling v/s no connection pooling. It was found that performance of Java applications running on the multi-core servers is far better than those running on single core servers. Web applications on quad-core server give better performance, high availability and scalability. Apache JMeter was used to load test the functional behaviour and measure performance based on throughput (No of hits v/s response time) for dynamic querying of data using Java servlets on Tomcat web server. Based on the analysis of performance of web server under varying load of no. of users and threads, it was found that applications on quad core server give more throughput and less response time as compared to single core server. Connection pooling increases the performance of web applications by reusing active database connections instead of creating a new connection with every request. Performance was compared by running the tests using Java servlets for connection pooling and also by acquiring connections directly from the JDBC driver without connection pooling. Based on the test results it was found that in case of quad core server, throughput i.e the number of requests served per second is much higher and reuse of connections from pool of connections showed significant improvement in application performance. This paper describes the results of tests carried out for comparing performance (based on response time) between web applications running on single core server and on quad core server. Tests have also been carried out to analyze advantage of connection pooling over no connection pooling. The test results have been shown graphically.

Web applications typically interact with a back-end database to retrieve persistent data and then present the data to the user as dynamically generated output, such as HTML web pages. However, this interaction is commonly done through a low-level API by dynamically constructing query strings within a general-purpose programming language, such as Java. This low-level interaction is ad hoc because it does not take into account the structure of the output language. Accordingly, user inputs are treated as isolated lexical entities which, if not properly sanitized, can cause the web application to generate unintended output. This is called a command injection attack , which poses a serious threat to web application security. This paper presents the first formal definition of command injection attacks in the context of web applications, and gives a sound and complete algorithm for preventing them based on context-free grammars and compiler parsing techniques. Our key observation is that, for an attack to succeed, the input that gets propagated into the database query or the output document must change the intended syntactic structure of the query or document. Our definition and algorithm are general and apply to many forms of command injection attacks. We validate our approach with SqlCheckS , an implementation for the setting of SQL command injection attacks. We evaluated SqlCheckS on real-world web applications with systematically compiled real-world attack data as input. SqlCheckS produced no false positives or false negatives, incurred low runtime overhead, and applied straightforwardly to web applications written in different languages.

Web applications typically interact with a back-end database to retrieve persistent data and then present the data to the user as dynamically generated output, such as HTML web pages. However, this interaction is commonly done through a low-level API by dynamically constructing query strings within a general-purpose programming language, such as Java. This low-level interaction is ad hoc because it does not take into account the structure of the output language. Accordingly, user inputs are treated as isolated lexical entities which, if not properly sanitized, can cause the web application to generate unintended output. This is called a command injection attack, which poses a serious threat to web application security. This paper presents the first formal definition of command injection attacks in the context of web applications, and gives a sound and complete algorithm for preventing them based on context-free grammars and compiler parsing techniques. Our key observation is that, for an attack to succeed, the input that gets propagated into the database query or the output document must change the intended syntactic structure of the query or document. Our definition and algorithm are general and apply to many forms of command injection attacks. We validate our approach with SqlCheckS, an implementation for the setting of SQL command injection attacks. We evaluated SqlCheckS on real-world web applications with systematically compiled real-world attack data as input. SqlCheckS produced no false positives or false negatives, incurred low runtime overhead, and applied straightforwardly to web applications written in different languages.

JavaScript is the main scripting language for Web browsers, and it is essential to modern Web applications. Programmers have started using it for writing complex applications, but there is still little tool support available during development. We present a static program analysis infrastructure that can infer detailed and sound type information for JavaScript programs using abstract interpretation. The analysis is designed to support the full language as defined in the ECMAScript standard, including its peculiar object model and all built-in functions. The analysis results can be used to detect common programming errors --- or rather, prove their absence, and for producing type information for program comprehension. Preliminary experiments conducted on real-life JavaScript code indicate that the approach is promising regarding analysis precision on small and medium size programs, which constitute the majority of JavaScript applications. With potential for further improvement, we propose the analysis as a foundation for building tools that can aid JavaScript programmers.

We introduce a client side triplestore library for HTML5 web applications and a personalization technology for web browsers working with this library. The triplestore enables HTML5 web applications to store semantic data into HTML5 Web Storage. The personalization technology enables web browsers to collect semantic data from the web and utilize them for enhanced user experience on web pages as users browse. We show new potentials for web browsers to provide new user experiences by personalizing with semantic web technology.