JavaScript Runtime Research Articles (Page 1)

To improve solid oxide electrolysis cell (SOEC) system designs and fabrication quality, endurance testing of SOEC systems provides a proving ground on which real-world usage can be simulated, and quality assurance issues can be identified early on. A test facility at Idaho National Laboratory (INL) was designed, built, and operated to facilitate endurance testing of a reversible system by Oxeon Energy. Designated Emerald, the test facility is currently the only test facility at INL designed to allow both SOEC and solid oxide fuel cell (SOFC) testing of the same module. To safely operate a reversible SOEC test facility, several safety features are required, and a hazard and operability analysis is of Emerald is discussed here. Design challenges due to differences in the endothermic SOEC and exothermic SOFC reactions were addressed in the process recuperators. Controls for the Emerald test facility were built in an open-source JavaScript runtime environment, Node.js and executed on a Linux-based industrial controller. The Oxeon Energy module has been successfully brought up to SOEC ready conditions. Initial operations of the Emerald test facility are being improved to eventually achieve non-stop operations and thousands of hours of testing of both SOEC and SOFC.

Node.js is a JavaScript runtime environment that allows you to run JavaScript code outside of a web browser. It works by using a single thread to handle multiple requests using a callback-based event loop. This means that Node.js operates in an event-driven, non-blocking I/O model. One potential weak point of Node.js is that it is designed to be a single-threaded runtime environment, which means that it may not be the best choice for applications that require a high degree of parallelism or multi-threading. While Node.js can handle multiple I/O operations simultaneously through its event-driven architecture, it can struggle with CPU-bound tasks that require heavy computation. This academic article investigates the concept of "offloading" the main thread in Node.js, which refers to the process of delegating heavy computational tasks to worker threads to improve the overall performance and responsiveness Node. js application. The article provides a comprehensive analysis of different techniques for offloading the main thread, such as using worker threads, child processes, and cluster modules. It also explores the potential trade-offs and performance implications of each technique, and provides recommendations for selecting the most suitable approach for different use cases. The article highlights the importance of optimizing the use of CPU resources and avoiding blocking the event loop, which can lead to degraded performance and poor user experience. It also emphasizes the need for careful monitoring and profiling of Node.js applications to identify performance bottlenecks and optimize the use of available resources. Overall, this article provides valuable insights and practical recommendations for developers and system architects who want to improve the performance and scalability of their Node.js applications by unloading the main thread.

Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal "square-root" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage.

Despite the increasing availability of biodiversity data, determing the quality of data and informing would-be data consumers and users remains a significant issue. In order for data users and data owners to perform a satisfactory assessment and management of data fitness for use, they require a Data Quality (DQ) report, which presents a set of relevant DQ measures, validations, and amendments assigned to data. Determining the meaning of "fitness for use" is essential to best manage and assess DQ. To tackle the problem, the TDWG Biodiversity Data Quality (BDQ) - Interest Group (IG) (https://github.com/tdwg/bdq) has proposed a conceptual framework that defines the necessary components to describe Data DQ needs, DQ solutions, and DQ reports (Fig. 1). It supports, in a global and collaborative environment, a consistent description of: (1) the meaning of data fitness for use in specific contexts, using the concept of a DQ profile; (2) DQ solutions, using the concepts of specifications and mechanisms; and (3) the status of quality of data according to a DQ profile, using the concept of a DQ report (Veiga 2016, Veiga et al. 2017). Based on this this conceptual framework, we implemented a prototype of a Fitness for Use Backbone (FFUB) as a Node.js module (https://nodejs.org/api/modules.html) for registering and retrieving instances of the framework concepts. This prototype was built using Node.js, an asynchronous event-driven JavaScript runtime, which uses a non-blocking I/O model that makes it lightweight and efficient to build scalable network applications (https://nodejs.org). We registered our module in the npm package manager (https://www.npmjs.com) in order to facilitate its reuse and we made our source code available in GitHub (https://github.com) in order to foster collaborative development. To test the module, we developed a simple mechanism for measuring, validating and amending the quality of datasets and records, called BDQ-Toolkit, available in the FFUB module. The source code of the FFUB module can be found at https://github.com/BioComp-USP/ffub. Installing and using the module requires Node.js version 6 or higher. Instructions for installing and using the FFUB module can be found at https://www.npmjs.com/package/ffub (Veiga and Saraiva 2017). Using the FFUB module we defined a simple DQ profile describing the meaning of data fitness for use in a specific context by registering a hypothetical use case. Then, we registered a set of valuable information elements for the context of the use case. For measuring the quality of each valuable information elements, we registered a set of DQ dimensions. To validate if the DQ measures are good enough, a set of DQ criteria was defined and registered. Lastly, a set of DQ enhancements for amending the quality in the use case context was also defined and registered. In order to describe the DQ solution used to meet those DQ needs, we registered the BDQ-Toolkit mechanism and all the specifications implemented by it. Using these specifications and mechanism, we generated and assigned to a dataset and its records a set of DQ assertions, according to the DQ dimensions, criteria and enhancements defined in the DQ profile. Based on those assertions we can build DQ reports by composing all the assertions assigned to the dataset or to a specific record. This DQ report describes the status of DQ of a dataset or record according to the context of the DQ profile. This module provides an interface to use the proposed conceptual framework, which allows others to register instances of its concepts. Future work will include creating a RESTful API using sophisticated methods of data retrieval.