sadat2307/MSciNLI huggingface dataset:
Domain: Software and its engineering
Sentence 1: Since definitions of agility and leanness are not clearly agreed and the study is explorative in nature, we did not want to restrict the usage of agile and/or lean to specific definitions.
Sentence 2: the survey was designed for whatever software practitioners understand to be using agile and/or lean is, starting with the questions Are you currently applying agile (lean) methods in your organizational unit?
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: In combination with certain runtime checks (e.g., for in-bounds array accesses), these type systems guarantee that at runtime, type-correct programs will respect the abstractions expressed by the lan­guage s type system.
Sentence 2: programs that have passed the type checker have been veri.ed, albeit with respect to rel­atively weak speci.cations (i.e., types).
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: For this, we .rst use an underlying basic budget assign­ment (e.g., Budget or Budget &#38; Seeding), and then multiple by a factor h > 1, such that the budget for S becomes zS = h× 2 1 ×zD.
Sentence 2: if h = 2 (which is the value we use in the experiments re­ported in this paper), then the modi.ed simple class S will receive the same amount of time as the unchanged dif.cult class D. Given an overall maximum budget (see Section 3.1), the to­ tal budget should not exceed this maximum, even in the face of 1 changed classes.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: However, full compaction is costly since a substantial fraction of the objects may be moved and all references need to be updated [1, 11, 12].
Sentence 2: modern systems tend to either use compaction infre­quently, or employ partial compaction, moving some objects in an attempt to reduce fragmentation and keep its cost acceptable [2, 3, 8, 9, 14, 15].
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: The Program Size section states benchmark sizes in terms of total lines of source code, number of source .les, and the following at the start of the SR phase: total number of basic blocks, and total number of de.ned procedures.
Sentence 2: the Files col­umn is indicative of the length of a compilation command-line with the -combine/-fwhole-program combination.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Each aspect weaves persistent read and write methods to .gure-related classes.
Sentence 2: 1http://swerl.tudelft.nl/bin/view/AMR/AJHotDraw 2http://www.jhotdraw.org/ 3http://wwwiti.cs.uni-magdeburg.de/iti db/research/berkeley 4http://www.oracle.com/database/berkeley-db these methods have disappeared from the base be­cause the declaration of Storable interface was moved to the aspects.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Because Prop­erty 4.9 requires isEq to identify e2 and e2' , we know that the ~~' context G * , x = e2 is equivalent to the context G * , x = e2.
Sentence 2: by using context conversion (Lemma 4.4), we can ~' conclude G * , x = e2 f t2 = t. To show progress, we must .rst prove a canonical forms lemma.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Also, the basic blocks constitut­ing the program are not reordered during deobfuscation be­cause the deobfuscation transformation does not construct the whole-program control .ow graph.
Sentence 2: the numbers we present in Section 4.4 are upper bounds that can still be lowered if one is only interested in building CFGs suited for program understanding, but not in gen­erating working binaries out of them.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Indeed, we would like to de­velop a strategy for generating specialised code that makes use of this property at any state of the automaton for which it is guar­anteed.
Sentence 2: we wouldn t sacri.ce the generality of patterns by disallowing those that do not bind all variables upfront, but at the same time would get the performance bene.ts whenever possible.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: The dedicated focus of activity diagram-based JPDDs on the dependencies between activities and data such as the engagement of the same object in diverse operations, for example makes them an appropriate means to represent join point selections which are based on data flow.
Sentence 2: they can help developers to comprehend the selection objectives of such join point selections even if these objectives are disseminated across multiple code abstractions (as it has been the case in this example).
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: However, a very important requirement of such fed­erations is the capability of the adopted publish/subscribe service to tolerate faults occurring in the network and/or computing nodes composing the federation, without nega­tively a.ecting the provided event noti.cation.
Sentence 2: it is crucial that publish/subscribe services are equipped with proper methods to support reliable event noti.cation.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Note, however, that this code is expected to have good data locality (cache behavior) as suc­cessive loop iterations reuse the data in the same cache line (except, of course, at the cache line boundaries).
Sentence 2: as it is, the code shown above is preferable from a data lo­cality viewpoint (assuming no con.ict misses occur between the two references shown) but not from an AGU utilization viewpoint, illustrating the potential con.icts between the two goals.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Finally, the popular DOM [8] and XML document tree mod­els [17, 37] can be nicely encoded via this attributed, directed graph­based representation model since their trees form a sub-class of this type of graph.
Sentence 2: many types of implementation artifacts in a Web application such as HTML, XML, and other markup docu­ments can be represented using our graph-based model.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: With atelierB, we proved that queries from user generate events and actions whose security levels are higher than or equal to L and that the associated condition security levels are lower than or equal to L. These formal proofs assure that the formal properties we presented in section 3.4 are indeed satis.ed by our implementation.
Sentence 2: finally, we proved using in­ference systems that the database equivalence invariant and the aforementioned proofs are su.cient to ensure that our model satis.es the con.dentiality property for two equiva­lent traces w.r.t to requests at level L. we assure that .a, a ' ,s0 ~L s ' 0 .
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: c assigns circle c to shape s and initializes c to a new public class BddStack { private final int MAX; private Object[] contents; private int top; public Stack(int n) { MAX := n; contents := new Object[MAX]; } public void push(Object x) { assert depth() < MAX; contents[top] :=: x; top++; } public void pop(Object x) { assert depth() > 0; top--; x :=: contents[top]; }  public int depth() { result := top; } } circle object.
Sentence 2: the approach does not introduce aliasing, but it does require the creation of a new object, and because Tako s underlying implementation guarantees unique references it ultimately requires memory from an old object to be reclaimed.initializing transfer is less efficient than swapping.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Hence, the amortized overhead is at most SL2 (N) = 6N·T (6N) 4N·T (4N) N + N = 6 · T (6N) + 4 · T (4N) block scannings per query.
Sentence 2: amortized shuf.ing overhead S(N) is: ( ) L1L.2-1 .
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Now, there are two possibilities to verify this communication: a) Verify both roles for correct re.nement of the abstract role b) Re-verify all properties for the re.ned protocol If a role is a correct re.nement of the abstract role (case a), a communication partner cannot distinguish it from the abstract role.
Sentence 2: all properties being veri.ed for the parameterized coordina­tion pattern will hold for the re.ned one as well.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: In the case of SODA, we decided to group into the same Discipline the activities be­longing to the same phase of the SODA development process, which led us to de.ne two disciplines Discipline Analysis and Discipline Design.
Sentence 2: each Discipline contains and  Figure 2: Use-case diagram of the SODA process: relationships between phases (left) and workde.ni­tions expressing sub-phases (right).
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Fig­ure 2(d) shows the result of applying copy propagation (after every phase) to the code in Figure 2(c).
Sentence 2: we can see that applying copy propagation transmits and replaces r[7] by r[18] on line 6 of Figure 2(d) and eliminates the dead copy instruction on line 2.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: For the Cobol system, rating was limited to a random sample of 68 out of the 151 inconsistent clone groups, since the age of the sys­tem and the fact that the original developers were not avail­able for rating increased rating effort.
Sentence 2: for the Cobol case, the results for RQ 2 and RQ 3 were computed based on this sample.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: It is tedious because there are so many attributes to which physical domains must be assigned, and it is error-prone because the many replace operations which move data to the assigned physical domains must be inserted by hand, with no automatic veri.cation of their correctness.
Sentence 2: we would like Jedd to relieve the user from having to perform the full assign­ment by automatically generating a reasonable assignment from a minimum amount of user input.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: A throughput increase due to a lower TLB miss rate as observed for OLTP transactions can not be observed for queries because the ac­cess pattern of OLAP queries is sequential, making prefetch­ing possible.
Sentence 2: the TLB miss rate in OLAP queries can be assumed to be low and thus no signi.cant perfor­mance increase can be expected from reducing TLB misses.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: It is also referred to as one of the inverse prob­lems of simulation, coarsely speaking: Instead of forward computing starting from given input Ifix and parameter Pfix and producing output behavior Osim, calibration starts with given input Ifix and output values Ofix, searching for the appropriate parameter values Popt so that the out­put produced Osim when using the latter input and pa­rameter set resembles in su.cient detail the given output: Osim ~ Ofix.
Sentence 2: calibration is basically an optimization problem.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: It is worth mentioning that al­though this version will yield the same level of performance, it will be smaller in size, as even a null specialization con­text implicitly implies the exclusion of code features that are not used by the requested functionality.
Sentence 2: the result­ing code can be seen as the result of a simple dependency analysis where only code that the customized functionality strictly depends upon is returned.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Speci.cally, we can prove that, for any program P con­taining exclusively statements whose corresponding constraints are in a given decidable theory T (i.e., for which the .ag complete al­ways remains 1), the SMART search algorithm provides exactly the same program path coverage as the DART search algorithm.
Sentence 2: for those programs P , every feasible path that is exercised by DART is also explored , albeit compositionally, by SMART;and conversely, every compositional execution considered by SMART is guaranteed to correspond to a concrete full execution path.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: This leads to the programmer s view that the execution of micro step actions does not take time at all while every macro step of a synchronous program requires the same amount of logical time.
Sentence 2: the starting point of our analysis is a system described by a set of synchronous guarded actions of the form (..A)de.ned over a set of variables V. The Boolean condition .is called the guard and Ais called the action.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: For example, the Java language specification defines the maximum array size as 0x7fffffff.
Sentence 2: we can eliminate a sign exten­sion for the effective address computation of an array access whose subscript expression is i+j, if both i and j have been sign­extended and if -1 ï i or j ï 0x7fffffff holds.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: For the refactoring case, this is prevented by a con­straint rule saying that accessibility of an overloading method that is more specific (in terms of its formal parameter types; here: A.m(String)) than the one a method call currently binds to (here: A.m(Object)) must remain on a level that leaves it inaccessible for the location of the method call: (A.m(String)) < a(A(B.n()), A(A.m(Object))) Again, negating this constraint means demanding a change of ac­cessibility and therefore leads to a change of binding, potentially changing the meaning of the program.
Sentence 2: by replacing the original constraint rule with its negation, a constraint solver can generate relevant mutants directly.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: However, no state-of-the-art tool including Pex can deal with all complicated situationsin real-world codebases au­tomaticallywithouthumanintervention orguidance.For ex­ample, sometimes atool couldfailtogeneratetestinputsfor covering a branch for one or more reasons.
Sentence 2: understanding these reasonsbythedevelopersis requiredbeforethedevel­opers couldprovideguidancetothetool such as carryingout environmentisolation,instrumenting someframework orli­brarycode that the code undertestinvokes, and writingfac­tory methods that encode method sequences for generating desirableobjects.While weareactively researchinghowto automatically provide better explanations when encounter­ingproblems[25], exposing someinternal technicaldetails ofthetooltodevelopers wouldbe still needed(atleastin the nearfuture) to allowdevelopersand atool to cooperate for effectivelycarrying out testing tasks.training developers withsuch skills remainsimportantfuture work.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: [9] In the programming model, we de.ne an entity as a speci.cation that describes which context information and actions are expected from an object (e.g., an area, lights, web service or a person) in an envi­ronment.
Sentence 2: the set of all entities that are de.ned in a context­aware application provide the full description of requirements for an environment.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: For example, interactions between services may be added or re­moved due to the addition of functionalities to the system at hand or loss of a service [18].
Sentence 2: in the con­text of dynamic IoT environments where a huge number of volatile services are available, adaptability becomes a key feature of services as it provides a way for an application to continuously change itself in order to satisfy new con­textual requirements.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: The same reasoning is applied to the edges of the DAG, separating them in another set.
Sentence 2: for example, all edges linking tasks from the .rst level to the second level have relative cost of 1, thus they would be in the set .rst set E1 of the partially ordered set E. in RCTE, the scheduler receives as input a set of tasks sortedbytheir weights, where a task withlarger weight means only that it takes longer to run than tasks with smaller weights if they are placed in the same processor.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Although there are opportunities for individual software engineers and managers to adopt EBSE principles, the decision to adopt a technology is often an organisational issue that is influenced by factors such as the organizational culture, the experience and skill of the individual software developers, the requirements of clients, project constraints, and the extent of training required.
Sentence 2: to use EBSE in practice may be more demanding than EBM because the decision-making structure and adoption process is often more complex.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Besides, it should be noted that all the elements of our system work on the same network (activity recognition module, assistance module, power analyser, etc.).
Sentence 2: when the assistive service determines that it is essential to guide the patient through prompts, the algorithm, which is programmed in C#, evaluates the appropriate prompt to send and finds the pathway to route the hint which must be executed by designated multimedia.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: When webuild thisexpression,a possible result mightbe SendEnv LANG LC_ALL ... ForwardX11 yes XAuthLocation /nix/store/j1gcgw...-xauth-1.0.2/bin/xauth It is worth noting that due to laziness, xauth will be built if and only if con.g.services.sshd.forwardX11 is true.
Sentence 2: the lazi­ness of the Nix expression language directly translates to laziness inbuilding packages.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: However, the GCHandle.Alloc method accepts an object as its .rst parameter, implicitly boxing the primitive type before pinning and transmitting it.We have introduced several new branches into the implementation of Send, but these branches rely on values known when the type parameter Tis known.
Sentence 2: when the CLI runtime creates a specialized implementation of Send for a partic­ular primitive type, the exact MPI datatype will be known immedi­ately.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: 0 = y  d) describing the effect of the procedure split called by quicksort does not need the use of the pattern 0 = y1 = y2 < len(res) that is used for the generation of the sorted­ness property.
Sentence 2: during the analysis, at procedure calls and returns, we need to switch from an abstract domain of formulas parametrized by some set of patterns, say P, to an abstract domain parametrized by another set of patterns P1 or P2 as shown in Figure 3(AU(P) denotes the domain of .rst-order formulas parametrized by the set of patterns P).
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Since inheritance and polymorphism was used extensively, we preferred to overload new() and delete() at the base class level.
Sentence 2: we also wanted to minimize the amount of code that had to be changed, since we had so many classes to change we defined new and delete in a template class, and used the Curiously Recurring Template Pattern [2][5] to create a custom base class from which the class would inherit the new() and delete() functions.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Figure 7 shows some examples of the idioms for "fopen".
Sentence 2: in the later version, i is seen that the idioms in the previous version appear as the substructure of the new idioms_ by replacing the idioms with the functions in the evolved library, the idioms in the later version should have been smaller in size or it could have been possible to capture more abstract idioms.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: 7.4 External Clock Synchronization There is a lot of work on external clock synchronization al­gorithms [18, 19, 21], where a source of real time is available and the objective is to synchronize all clocks to this source.
Sentence 2: there is a single node v0 for which logical clock time, hardware clock time, and real time are identical.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: 3.MCextensionsaresimple.Theextensionsmen­tionedabovearetypiallylessthanahundred linesofode.
Sentence 2: apratialresultofourexperienewithMCisthat themajorityofourextensionswerewrittenbypro­grammerswhohadonlyapassingfamiliaritywiththe systemsthattheyheked.Althoughwritingode thatobeyssystemrulesanbequitediÆult,these rulesareeasytoexpress.writinghekersfor manyofthemisrelativelystraightforward.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: in the median Mk values is greater than 20% for all the CR estimators for inspection team size of 1 upto 9 inspectors.
Sentence 2: the CR estimators are not recommended for estimating the cost-effectiveness of the inspections with less than ten inspectors; b) The CR estimators belonging to Mh and Mth models improve faster.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: Consider an arbitrary target method whose signature is decomposed as follows:  ( p1,  p2, , pn) A method with the signature: public boolean pre( p1,  p2,  pn) is considered its precondition method.
Sentence 2: the following method: boolean preGetBMI() {return height >= 0 &#38;&#38; weight >= 0} is the precondition method of the target method: public double getBMI() { assert preGetBMI(); return weight / (height*height); } If a target method is a getter for some property P, then ObjectEditor does not display P until its precondition method returns false.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: A log entry for a received message must include a matching authentica­tor; therefore, a node cannot invent log entries for messages it never received.
Sentence 2: when i is about to send m to j, it creates a log entry (sk,SEND,{j,m}), attaches hk-1, sk and si(sk||hk)to m, and sends the result to j.recipient j has enough in­formation to calculate hk and to extract aik.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: The Hindsight Lemma assumes that the algorithm maintains cer­tain simple invariants which are resilient to interference, and which can themselves be veri.ed using purely thread-local proofs.
Sentence 2: the lemma allows us to unlock a perhaps-surprising intuition: a high degree of interference makes non-trivial highly­concurrent algorithms in some cases much easier to verify than less concurrent ones.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: In this tree, each node corresponds to a virtual block to main­tain the mapping information of the virtual pages of this virtual block when the up-to-date data of these virtual pages are stored in the out-place area.
Sentence 2: as shown in Figure 3, each node has six .elds: The vba .eld is the address of its corresponding virtual block and serves as its key for key searching, and the left and right .elds denote its left child and right child nodes respectively; the pba1 and pba2 .elds point to its corresponding two physical blocks, and the tbl .eld points its corresponding run-length table that maintains the mapping information of its corresponding virtual block.
Relationship: reasoning
Domain: Software and its engineering
Sentence 1: The probability of each of these values of X occurring is 1/mk .
Sentence 2: the n expected value of X, when k is .xed, is: X H(x)= - p(xi) log2 p(xi ), i=1 where xi =1, ..n are all the possible values contained in the stream and p(xi) is the probability of their occurrence.
Relationship: reasoning