sadat2307/MSciNLI huggingface dataset:
Domain: Software and its engineering
Sentence 1: All these considerations and the work reviewed here moti­vated us to look into this problem of what is a good strategyto do integration testing of classes and aspects in the con­text of a software development process.
Sentence 2: weare interested in the order of integration of classes and as­pects aiming at minimizing the need to create stubs in theline of the works of Briand et al.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We conclude that the evaluation model embodied in the CLS ma­chine is a call-by-value interpreter threading a stack of environ­ments and a stack of intermediate results with a caller-save strategy (witness the duplication of environments on the stack in the mean­ing of applications) and with a left-to-right evaluation of sub-terms.
Sentence 2: the meaning of a term is a partial endofunction over a stack of environments and a stack of intermediate results.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Drivers are used to execute the various components.
Sentence 2: we focused on performing aug­mentation as the system goes through three iterations of evolution, from versions v0 to v1, v1 to v2,and v2 to v3.we augmented the test suite for v1 using the suite for v0, augmented the test suite for v2 using the suite for v1 and augmented the test suite for v3 using the suite for v2.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Because each point pi is generated systematically, based on the residual of the previous point pi-1, we intuitively expect that whenever pj = pk we will also have pj+1 = pk+1.
Sentence 2: if we ever revisit a point pj, then the next point must be pj+1.Con­sequently, P will end in an in.nite repeating subsequence .pj,pj+1,...,pk-1,pj,.....
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In particular, one of the implementations we sketched was over 8 times faster than the original reference implementation on a 1.3 GHz Itanium-2, even though they were compiled and optimized using the Intel Fortran compiler version 9.1, arguably one of the best com­pilers commercially available on the Itanium architecture.
Sentence 2: the sketch expressed optimization ideas which the compiler was unable to discover on its own.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In order to reduce the overheads on selecting the best victim blocks for the garbage collector, the garbage manager maintains a counter array for each block region, and the i-th entry of the counter array is a counter to keep the number of blocks having i invalid pages in the block region.
Sentence 2: the i-th entry of the counter array is to keep the number of IPCs whose value is i in the corresponding block region.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In both cases, a logic and its encod­ing must be sound in order for the resulting language to be type-safe.
Sentence 2: when a certain condition needs to hold in order for evaluation to proceed (such as, for exam­ple, the constraints on the subscript that must be satis.ed for an array operation to make sense), it must be shown as part of the safety proof that the existence of the proof ob­ject supplied by the program entails the required condition.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: High-level Programming of Embedded Hard Real-Time Devices Filip Pizlo Lukasz Ziarek Ethan Blanton Petr Maj Jan Vitek Fiji Systems Inc. Purdue University Abstract While managed languages such as C# and Java have become quite popular in enterprise computing, they are still consid­ered unsuitable for hard real-time systems.
Sentence 2: the presence of garbage collection has been a sore point for their acceptance for low-level system programming tasks.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Edges are inserted from the predicate node for basic block if p and p' are not mutually exclusive and p' is the predicate guarding the instruction to the condition nodes not covered by any subset of predicates guarding instruc­ just created; for the example, edges from predicate node tions between d and u. pParentto condition nodes compand ¬compare added.
Sentence 2: predicate nodes representing pTand pFare also created, if d reaches u if d is a predicate-covering pre­they do not already exist.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Modern organization models entail distributed and heterogeneous actors and resources, which need to cooperate and coordinate to achieve their business goals.
Sentence 2: most organizations are Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Although there are no general principles for designing the best display efficient for all types of tasks, there exists a general principle that can identify correct or incorrect mappings between displays and tasks: the information perceivable from a display should exactly match the information required for the task, no more and no less.
Sentence 2: the tasks assigned to a display should be the tasks afforded by the external representations of the display and the displays assigned to a task should be the displays whose external representations support the task.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The reading of the documentation, especially the developer s guide for cxf, and of the speci.cation of the standards implemented, and the instability of the behavior that we have observed from one version to another lead us to the following conclusion: the validity of the substitution principle has not been required in the speci.cation of the cxf framework.
Sentence 2: the errors detected do not corre­spond to failures, since the behavior that would be expected if the substitution principle was applied is not speci.ed.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Since the Java compiler is oblivious to the special se­mantics of the dummy invocations, it is unable to perform proper control .ow analysis during the initial compilation, which may lead to unexpected results.
Sentence 2: com­pilers may optimize or otherwise generate code that vio­lates the stack-neutrality property of statements (see Sec­tion 3.3), which can result in invalid programs after inserting new jump instructions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: As proposed in [4], a typedprogramming language should allow for the selection of the typesystem or systems to use in a program, as different parts of the pro­gram may require different set of constraints on its data that onetype system may not be able to express.
Sentence 2: also the type system mustbe used to state data constrains only, as semantic rules stated by onetype system may not be preserve when other type system is used.uses of the type system to express data accessibility,data abstraction hiding, or ad/hoc functional polymorphism shouldnot be allowed.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 4.1 SP-DAG preliminaries The next few lemmas elucidate the undirected cycle structure of SP-DAGs, which we will exploit later to build ef.cient deadlock avoidance algorithms.
Sentence 2: we use the property, veri.ed in Lemma 4.4, that every undirected cycle on an SP-DAG has a single source and a single sink.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 6.2 Object Read-Write Information We performed measurements to estimate the potential im­pact of our analysis on clients of object read-write infor­mation (e.g., side-e.ect analysis and def-use analysis).
Sentence 2: we considered all expressions of the form p.f oc­curing in statements in reachable methods.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: For additional future work we intend to use the open source media streaming platform VideoLAN [6] and Planet-Lab [33] to further explore the mechanism by which non-converging service graphs are selected, and to investigate implementation issues related media service composition.
Sentence 2: we aim to address media flow synchronisation issues introduced by composed service paths, especially hybrid and non-converging service graphs such as those illustrated in Figures 1b-d. We aim to incorporate parts of our design into a larger context management and mobility handling architecture [11] with the goal of providing mobility that is seamless not-only in the sense of network connectivity, but also in the sense of end-user perception.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: It was designed to support scalability of AHP to requirements whose size make AHP prohibitively expensive (the number of pairs that must be elicited to apply AHP is quadratic with the number of re­quirements).
Sentence 2: aHP implements a pairwise comparison it­erative process in which the decision maker is required to specify a preference as an integer value pij .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In addition to the constructors shown in Figure 6, our queries also allow annotating arbitrary subtrees with integer weights.
Sentence 2: we allow queries to contain another con­structor WeightedQuery(Int *Doc), and we extend the Score function from Figure 7 as: Score(WeightedQuery(w, q),d)= w × Score(q, d).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The XML representation of these terms could be used in a web ser­vice such as the Virtual Workspace Service [18] to negotiate a lease.
Sentence 2: a resource consumer would present the desired lease terms to the service, which would determine whether to accept or reject the request, and publish the accepted lease terms (which may be concretized by the service if the lease is accepted).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: CONCLUSIONS In this paper, we have elaborated on the idea of mod­eling and developing next generation of pervasive service framework by getting inspiration from ecological systems.
Sentence 2: by conceiving future pervasive service frameworks as a spatial ecosystem in which services, data items, and re­sources are all modeled as autonomous individuals (agents) that locally act and interact according to a simple set of well-de.ned eco-laws .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Such annotations inform if the formally defined subtyping relations defined in [1] hold between the elements of both ASDs (note that the ASD DSL is designed to support the modeling of both ASDs and annotated ASDs).
Sentence 2: considering S1 as the ASD being annotated and S2 the one against which S1 is compared, each element in S1 is annotated as: .
Relationship: entailment
Domain: Software and its engineering
Sentence 1: EXPERIMENTAL STUDY To evaluate our proposal for language-level checkpoint­ing/replaying, we performed a variety of experiments, fo­cusing on the e.ectiveness and e.ciency of the static anal­yses, and on the run-time performance of the checkpointing version and the replaying version.
Sentence 2: our experi­ments consider the following research questions: How e.ective are the static analyses in reducing the number of variables that are captured/replayed?
Relationship: entailment
Domain: Software and its engineering
Sentence 1: If we are working in an imperative language and reason (per­haps informally) using Hoare logic-style pre-and post-conditions, the standard, commonly-used partial-correctness interpretation of these pre-and post-conditions continues to be valid.
Sentence 2: many of our most important local reasoning principles remain in­tact in the presence of harmless advice.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: 2.2 Idempotence Idempotence can be identi.ed through the absence of clob­ber antidependences, which are antidependences with no prior .ow dependence on the same variable [8].
Sentence 2: an idempotent region can contain an antidependence as long as the antidependent variable is de.ned before it is used.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In the context of this essay, however, it is important to note that these newer characterizations of AOP do not assign it properties voiding the discussions that follow.
Sentence 2: in all but the most trivial cases the composition rules C (labeled R in [38]) will likely need some intimacy with the structure (including context) of the actions A (labeled C in [38]) to be composed.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Our scheduling algorithm exploits the temporal locality and popularity characteristics and uses the information in the history to perform predictions.
Sentence 2: the block with a higher write fre­quency in history (i.e., more likely to be written to again) should be migrated later in the pre-copy model, and the block with a higher read frequency (i.e., more likely to be read again) should be mi­grated earlier in the post-copy model.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The following expression takes zero elements from data to form an empty array, and then proceeds to take one element from the empty array: DISPLAY 1.0.data +.-------------------+ ¦ +.---------------+ ¦ ¦ ¦ +.---+ +.----+ ¦ ¦ ¦¦¦ ¦¦000¦¦¦ ¦ ¦ +----+ +~----+ ¦ ¦ ¦ +.---------------+ ¦ +.-------------------+ DISPLAY is a library function which shows us structural information, so we can see that the result is a nested array with one element, it contains a nested array with two elements, and that the leaf arrays are a character array containing four blanks (a bit hard, but you can count them) and a numeric array containing three zeros.
Sentence 2: the type and structure of the first element of data has been preserved.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The software archi­tecture of gVirtuS is shown in Figure 3.
Sentence 2: gVirtuS adopts the split-driver model and assumes the presence of a host and one or more guest machines (which can be located on the same physicalnode).TheGPUisphysically locatedonthehost machine, whereas the CUDA-enabled applications run within the virtual ma­chines residing on the guest machines.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Given the nearest neighbour of a new input size we evaluate the N best con.gurations of that point and pick the one that delivers the best performance.
Sentence 2:  Benchmark Loop nest depth Loop size (LOC) Benchmark description correlation3 2 8 Computation of correlation fdtd2d_3 2 7 2-D .nite di.erence time domain kernel fdtd2d_4 2 7 2-D .nite di.erence time domain kernel gemm 2 11 Matrix multiplication le2d_x 2 275 Seismological simulation le2d_y 2 266 Seismological simulation nek5000 3 21 Computational .uid dynamics stencil27 3 24 27-point stencil stencil27_2 3 10 27-point stencil syr2k 2 11 Symmetric rank-2k threedconv 3 19 3D convolution twodconv 2 9 2D convolution Table 2: Description of benchmarks used in this work.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In fu­ture work, we will extend our methodology to consider mul­tiple distributed nodes as local optimizers (scalability to hori­zontal composition).
Sentence 2: we plan to construct an in­terface language for generic composition (e.g., negotiation and contract) and focus on carrying out a large scale demonstration with heterogeneous applications (mission critical, multimedia) on multiple devices in a distributed network.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This paper presents an anomaly-based framework for error detection in critical software systems able to exploit the information available while the system is still in its development phase for gaining the necessary knowledge on the system behavior, accurately and inexpensively.
Sentence 2: the framework relies on the idea of i) describing the system behavior with a combination of application-level and OS-level variables, and ii) of collecting their values during the testing phase, in order to drive the detection at runtime with the availability of a reference behavior description, obtained with minimal training overhead.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: vec(B, t1+t2) ~ = .B:GL2, t1:T2.vec(B, t1) .
Sentence 2: vec(B, t1) (by Lemma 4) ~ = .B:GL2.vec(B, 0) (by Lemma 4) ~ = unit (by Theorem 1) the vector addition operation is the only inhabitant of its type!
Relationship: entailment
Domain: Software and its engineering
Sentence 1: That is not always the case because the the delay of the current addition depends not only on the current input values but also on the state of intermediate logic gates that were set by the previous addition.
Sentence 2: if a previous addition induces a long carry chain but the current one does not have any carries, the intermediate logic gates representing the propagate and generate signals must change to hold the correct values for the current addition.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Such collaborative sensemaking should take seriously the diverse perspectives and the processes of communal meaning negotiation [24].
Sentence 2: such (meta)­level conversations are about the collaborative sensemaking by the community of its context: why are we collaborating (goals), what needs to come out of it (results), who should be involved (roles) and how should the conversations for action be defined (workflows) and supported (tools)?
Relationship: entailment
Domain: Software and its engineering
Sentence 1: This paper uses automatically generated tree models, such as those in Figure 10, to de­scribe the trends in the results.
Sentence 2: we use the binary recursive partitioning algorithm [2, 5] to determine how the explanatory variables (e.g., the choice of a mutation operator) impact the response variable (e.g., a metric such as CE).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Our experience also indicated that although there is a strong conceptual difference between a component and an ensemble (in the sense that a component is state-full while an ensemble is stateless), the developers of the case-study had problems with differentiating between responsibilities of a component process and knowledge exchange.
Sentence 2: they incorrectly tended to reduce autonomy of components by pushing some of their functionality to ensembles (by employing complex knowledge transformations in the knowledge exchange).
Relationship: entailment
Domain: Software and its engineering
Sentence 1: In order to put the SPEM meta-modelling power to test, and emphasise its bene.ts and limitations, in this paper we apply SPEM to a more articulated context than the object­oriented one where it was initially conceived  that is, Agent-Oriented Software Engineering (AOSE) methodologies.
Sentence 2: we take the SODA methodology as a signi.cant case study in order to assess strengths and limitations of SPEM, given the peculiar SODA focus on the modelling and engineering of (i) social issues and (ii) application environ­ment essential aspects in the engineering of complex soft­ware systems.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Instead, as an example, in a guard we replace a call to is pid with pattern matching against the new process identi.er for­mat {pid,nodename::atom(),number::integer ()}.
Sentence 2: a call is pid(Pid) is translated into the guard fragment: is tuple(Pid), size ( Pid ) =:=3 , element (1 , Pid) =:= pid , is integer ( element (3 , Pid )) 1 The earlier translator for instance lacked support for the try ... of ... catch ... end construct, it could not handle bit strings nor binaries, nor could it translate correctly most higher-order or anonymous functions.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: The paper describes a design paradigm that uses the functional primitives of positive/negative feedback and sporadic random walk to design robust resource discovery and distribution schemes over MANETs.
Sentence 2: the scheme offers the features of (1) cross-layer design of P2P systems, which allows the routing process at both the P2P and the network layers to be integrated to reduce overhead, (2) scalability and mobility support, which minimizes the use of global flooding operations and adaptively combines proactive resource advertise­ment and reactive resource discovery, and (3) load balancing, which facilitates resource replication, relocation, and division to achieve load balancing.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Givenaclosed well-typedexpression e in .2,Gµ,weuse |e|for the type erasure of e, that is, the expression obtained from erasing all types in e. We can then evaluate |e|in a un­typed .-calculus extended with pattern matching.
Sentence 2: clearly, e.. * e ' holds if and only if |e|evaluates to |e ' |..2,Gµ supports type-erasure semantics.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: Note that all boxes stored in Tupper extend below the refer­ence point and therefore cannot lie above Q.Consequently, the question whether or not a rectangle intersects the query rectangle, reduces to the question whether the top edge of the rectangle lies high enough (that is, above the bottom edge of Q) and extends far enough to the right (that is, be­yond the left edge of Q).
Sentence 2: it reduces to the question whether or not the rectangle s top edge intersects the half-line q that extends upwards from the lower left cor­ner of Q see Figure 5.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: We give a detailed account of the methodol­ogy, compare its formal expressiveness to prior art, and describe its application to an open-source Java-implementation of the SSL­protocol.
Sentence 2: we show how one can make use of run­time veri.cation to dynamically enforce that assumptions on the crypto-protocol implementations (that are commonly made when statically verifying crypto-protocol speci.cations against security requirements) are actually satis.ed in a given protocol implemen­tation at runtime.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: ing STL Multiset on RAID-5 While implementing and testing the ladder queue data structure, an issue with the original algorithm [22] arose.
Sentence 2: a problem arises when, during a redistribution Simulation time (s) 150 100 50 0 1 2 3 4 5 6 7 8 Number of LTSF queues Figure 6: Performance of Multiple LTSF Queues us­ data structure used for the LTSF queue with the Splay tree data structure.
Relationship: entailment
Domain: Software and its engineering
Sentence 1: However, since AOP is a paradigm for dealing with a crosscutting concern, our model forAOP needs some pred­icates that deal with non-local contexts.
Sentence 2: en­abling method dispatch depending on non-local contexts is a unique featureofAOPagainstOOP.Forexample, seethe following aspect in AspectJ: aspect Logging { around(): call(void HashMap.put(..)) &#38;&#38; within(WebApp)) { System.out.println( "WebApp updates a hash map"); proceed(); } } This typical logging aspect declares an advice that is invoked when anymethod in the WebApp class calls the put method ona HashMap object.Ifamethodin other classes callsit,the adviceisnotinvokedbutthe original put method is invoked.
Relationship: entailment