RST Source Code

The TPS test design process results in UUT detailed test strategy that is independent of its eventual implementation in source code or on a specific ATS. It is test strategy, not source code, that embodies the critical metrics of UUT fault detection and isolation. Source code implementation is the first step in a design chain that finally results in signal-information flow across the test interface. This SI flow is the physical realization of test design. The objective of TPS rehosting is usually preservation of proven legacy test design, but it should also seek to preserve legacy SI flow to avoid the subtle, and often difficult, problems caused by rehosting to the new ATS. These problems can be exacerbated by inability of the original source code to describe what is happening at the UUT test interface, and by the repeated and characteristic need to choose between equivalent performance of, and incidental or substantive enhancements to, the rehosted TPS.

Given a set of requirements structured as design problems, we can apply design patterns to solve each problem individually. Much of the published literature on design patterns addresses this problem—pattern association; however, there is no systematic and practical way that shows how to integrate those individual solutions together. We propose a compositional model based on design patterns by abstracting their behavioral model using role modeling constructs. This approach describes how to transform a design pattern into a role model that can be used to assemble a software application. The role model captures the behavioral relationship between participant components in the design pattern. Our approach offers a complete practical design and implementation strategies, adapted from DCI (Data, Context, and Interaction) architecture. We demonstrate our technique by presenting a simple case study complete with design and implementation code. We also present a simple to follow process that provides guidelines of what to do and how to do it.

The problem of consistency between software requirements and their implementation in source code becomes critically important as the scale and complexity of modern software systems increase, since the absence of reliable traceability links often leads to incomplete requirement implementation, complicates code maintenance, and hinders the verification of system correctness. Manual generation of traceability matrices is a labour-intensive and error-prone process, especially in large projects. The use of large language models opens up new opportunities for automating this process, as such models are capable of reflecting deep semantic relationships between text requirements and software code fragments. The article proposes a method for identifying traceability links between requirements and software code using transformer models of large language systems. The proposed approach is based on converting text artefacts into vector representations using CodeBERT, SBERT, and TF-IDF models, followed by calculating semantic similarity to automatically identify potential connections. The method covers such stages as data preparation, embedding generation, search for relevant fragments, and evaluation of the results obtained. The experiments were conducted on the MSR-2021 dataset, which contains real traceability links for several projects. The obtained results demonstrated the advantage of CodeBERT over traditional approaches (TF-IDF, SBERT): the method achieves accuracy of up to 0.85 and an F1-score of up to 0.50, depending on the search depth, which represents strong performance for automated information retrieval and ranking tasks. The study additionally confirmed the importance of considering the structural context of the code and showed the influence of the Top-K parameter on the balance between recall and precision. The results indicate that integrating LLM-based models significantly improves the level of automation, consistency, and quality of requirements traceability in modern software development environments.

An improved implementation of an N-body code for simulating collisionless cosmological dynamics is presented. TPM (tree particle-mesh) combines the PM method on large scales with a tree code to handle particle-particle interactions at small separations. After the global PM forces are calculated, spatially distinct regions above a given density contrast are located; the tree code calculates the gravitational interactions inside these denser objects at higher spatial and temporal resolution. The new implementation includes individual particle time steps within trees, an improved treatment of tidal forces on trees, new criteria for higher force resolution and choice of time step, and parallel treatment of large trees. TPM is compared to P3M and a tree code (GADGET) and is found to give equivalent results in significantly less time. The implementation is highly portable (requiring a FORTRAN compiler and MPI) and efficient on parallel machines. The source code can be found on the World Wide Web.

CEJVM is a cluster enabled Java Virtual Machine, which executes in a distributed fashion among collaborating nodes of a dedicated cluster. It extends Java's multithreading mechanism to the parallel computing paradigm by transparent migration of independent application threads modeled in master worker paradigm. The goal is to obtain improved performance for computationally-intensive multi-threaded Java programs without modifying traditional code, Java language or compiler implementation. Deploying a master worker relationship among the nodes in the cluster, CEJVM monitors, packs, transports and resurrects the Java threads on Master JVM and helper Worker JVMs. Currently, we have created a prototype that runs pure Java applications on the local Ethernet based cluster of Win2K computers. We have achieved appreciable speedup for an ANN training program written in Java (with independent threads) on CEJVM without any modification to the program's source code.

BackgroundAs of July 17, 2020, the COVID-19 pandemic has affected over 14 million people worldwide, with over 3.68 million cases in the United States. As the number of COVID-19 cases increased in Massachusetts, the Massachusetts Department of Public Health mandated that all health care workers be screened for symptoms daily prior to entering any hospital or health care facility. We rapidly created a digital COVID-19 symptom screening tool to enable this screening for a large, academic, integrated health care delivery system, Partners HealthCare, in Boston, Massachusetts.ObjectiveThe aim of this study is to describe the design and development of the COVID Pass COVID-19 symptom screening application and report aggregate usage data from the first three months of its use across the organization.MethodsUsing agile principles, we designed, tested, and implemented a solution over the span of one week using progressively customized development approaches as the requirements and use case become more solidified. We developed the minimum viable product (MVP) of a mobile-responsive, web-based, self-service application using research electronic data capture (REDCap). For employees without access to a computer or mobile device to use the self-service application, we established a manual process where in-person, socially distanced screeners asked employees entering the site if they have symptoms and then manually recorded the responses in an Office 365 Form. A custom .NET Framework application solution was developed as COVID Pass was scaled. We collected log data from the .NET application, REDCap, and Microsoft Office 365 from the first three months of enterprise deployment (March 30 to June 30, 2020). Aggregate descriptive statistics, including overall employee attestations by day and site, employee attestations by application method (COVID Pass automatic screening vs manual screening), employee attestations by time of day, and percentage of employees reporting COVID-19 symptoms, were obtained.ResultsWe rapidly created the MVP and gradually deployed it across the hospitals in our organization. By the end of the first week, the screening application was being used by over 25,000 employees each weekday. After three months, 2,169,406 attestations were recorded with COVID Pass. Over this period, 1865/160,159 employees (1.2%) reported positive symptoms. 1,976,379 of the 2,169,406 attestations (91.1%) were generated from the self-service screening application. The remainder were generated either from manual attestation processes (174,865/2,169,406, 8.1%) or COVID Pass kiosks (25,133/2,169,406, 1.2%). Hospital staff continued to work 24 hours per day, with staff attestations peaking around shift changes between 7 and 8 AM, 2 and 3 PM, 4 and 6 PM, and 11 PM and midnight.ConclusionsUsing rapid, agile development, we quickly created and deployed a dedicated employee attestation application that gained widespread adoption and use within our health system. Further, we identified 1865 symptomatic employees who otherwise may have come to work, potentially putting others at risk. We share the story of our implementation, lessons learned, and source code (via GitHub) for other institutions who may want to implement similar solutions.

<i>The Parmenidean Ascent</i>

We present a practical algorithm for the homophonic coding of a message source, as required for cryptographic purposes. The purpose of homophonic coding is to transform the output of a non-uniformly distributed message source into a random, uniformly distributed source sequence. This is achieved by mapping each source symbol into one of a set of homophones in a random way. The selected homophones are then encoded by means of arithmetic coding. In this paper a new arithmetic coding algorithm is introduced, which relies on the fact that the homophones are chosen be dyadic. This leads to particularly simple implementation of homophonic coding, requiring no multiplications but only shifts and additions. The operation of the algorithm is demonstrated by the homophonic encoding of an ASCII file. The results show that homophonic does increase the entropy by less than 2 bits per symbol, and also provides source encoding (data compression) of the original file.

In this chapter, we will provide some implementation of some basic functions of Rough Set Theory. Implementation of RST functions can be found in other libraries as well. The major aspect here is that source code is also provided with each and every line explained. The explanation in this way will help the research community to not only easily use the code but also they can modify as per their own research requirements.

While finding clones in source code has drawn considerable attention, there has been only very little work in finding similar fragments in binary code and intermediate languages, such as Java bytecode. Some recent studies showed that it is possible to find distinct sets of clone pairs in bytecode representation of source code, which are not always detectable at source code-level. In this paper, we present a bytecode clone detection approach, called SeByte, which exploits the benefits of compilers (the bytecode representation) for detecting a specific type of semantic clones in Java bytecode. SeByte is a hybrid metric-based approach that takes advantage of both, Semantic Web technologies and Set theory. We use a two-step analysis process: (1) Pattern matching via Semantic Web querying and reasoning, and (2) Content matching, using Jaccard coefficient for set similarity measurement. Semantic Web-based pattern matching helps us to find method blocks which share similar patterns even in case of extreme dissimilarity (e.g., numerous repetitions or large gaps). Although it leads to high recall, it gives high false positive rate. We thus use the content matching (via Jaccard) to reduce false positive rate by focusing on content semantic resemblance. Our evaluation of four Java systems and five other tools shows that SeByte can detect a large number of semantic clones that are either not detected or supported by source code based clone detectors.

Formal specifications of software systems are extremely useful because they can be rigorously analyzed, verified, and validated, giving high confidence that the specification captures the desired behavior. To transfer this confidence to the actual source code implementation, a formal link is needed between the specification and the implementation. Generating the implementation directly from the specification provides one such link. A program transformation system such as Paige's APTS can be useful in developing a source code generator. This paper describes a case study in which APTS was used to produce code generators that construct C source code from a requirements specification in the SCR (Software Cost Reduction) tabular notation. In the study, two different code generation strategies were explored. The first strategy uses rewrite rules to transform the parse tree of an SCR specification into a parse tree for the corresponding C code. The second strategy associates a relation with each node of the specification parse tree. Each member of this relation acts as an attribute, holding the C code corresponding to the tree at the associated nodes the root of the tree has the entire C program as its member of the relation. This paper describes the two code generators supported by APTS, how each was used to synthesize code for two example SCR requirements specifications, and what was learned about APTS from these implementations.

SPAN: A software power analyzer for multicore computer systems

The lack of compatibility of High‐Performance Fortran (HPF) between vender implementations has been disheartening scientific application users so as to hinder the development of portable programs. Thus parallel computing is still unpopular in the computational science community, even though parallel programming is common to the computer science community. As users would like to run the same source code on parallel machines with different architectures as fast as possible, we have investigated the compatibility of source codes for Japanese HPF compilers (NEC, Fujitsu and Hitachi) with two real‐world applications: a 3D fluid code and a 2D particle code. We have found that the source‐level compatibility between Japanese HPF compilers is almost preserved, but more effort will be needed to sustain complete compatibility. We have also evaluated parallel performance and found that HPF can achieve good performance for the 3D fluid code with almost the same source code. For the 2D particle code, good results have also been obtained with a small number of processors, but some changes in the original source code and the addition of interface blocks is required. Copyright © 2002 John Wiley &amp; Sons, Ltd.

Static timing analysis (STA) with multiple clock domains and complicated exception conditions is a complex practical problem that can dramatically increase compilation time, both for back-end analysis and during place and route. In FPGA placement, timing analysis with many constraints can dominate placement run-time.In this paper we introduce a simple binary edge-mask data structure on arcs in a timing netlist which allows for efficient timing analysis in the presence of many such constraints. The technique applies to either BFS or DFS-based timing analysis. Preliminary implementations on just the basic concept show a 59% decrease in STA run-time for multi-clock designs, indicating that significant benefit is to be gained from a complete implementation. On a set of heavily constrained designs this benefit improved to 80% run-time decrease.Further applications of the edge-mask concept are shown to efficiently deal with thru-x constraints, enumerating the k-longest paths in a timing graph, and partial/incremental timing analysis aimed at significant improvements in placement time.

Soft rough fuzzy sets and soft fuzzy rough sets