id
stringlengths
7
12
sentence1
stringlengths
5
1.44k
sentence2
stringlengths
6
2.06k
label
stringclasses
4 values
domain
stringclasses
5 values
train_127100
Move operations can be used in the context of modi.cations of the .ow structure, which occur very often.
exhaustive checking of alternative di.erences would lead to intolerable overheads.
reasoning
Software and its engineering
train_127101
The .rst page of an object stores not just data but also the frequently modi.ed object header which is why we avoid sharing this page.
our system passes R objects smaller than two pages of memory to the standard, non sharing memory allocator.
reasoning
Software and its engineering
train_127102
In the lookup table, the gain of .nding the physical address of replacement block is amor­tized by the number of OOB data reads incurred during a backwards search to locate a required page.
the advantages of the lookup table are smaller in a .ash with larger block size, since a larger block holds more replacement pages compared to a same size .ash with smaller block size.
reasoning
Software and its engineering
train_127103
In addition, a proxy object might be ac­cessed via re.ection, e.g., by reading the .elds of another object.
the analysis treats all objects obtained that way as possible proxies.
reasoning
Software and its engineering
train_127104
In terms of data structure support, SAP Gravity is more .exible than Apache Wave or ShareJS since it allows syncing graph models that may in­clude cycles.
it is capable to accommodate arbitrary business processes that can be expressed in BPMN.
reasoning
Software and its engineering
train_127105
For the sixth occurrence, we need to .nd CHR constraints of the form leq( ,X) to ensure that B = B ' holds.
we need an index on the second argu­ment.
reasoning
Software and its engineering
train_127106
This contrasts sharply with the physical sciences, in which, for example, a measurement of the electron s charge would have an explicit statistical confidence bound arising from the intrinsic sensitivity of the equipment used in generating the evidence.
it is often difficult to use statistics to combine measurement error and credibility into a confi­dence bound around one estimate of a software attribute.
reasoning
Software and its engineering
train_127107
An addi­tional issue with the hardware-assisted approach is that the necessary hardware mechanisms are typically speci.c to a particular micro-architecture.
exploiting them in a virtual machine that must ship on several architectures (and an even larger set of micro-architectures) represents a sig­ni.cant engineering investment.
reasoning
Software and its engineering
train_127108
By Lemma 2, CSowner has the value p in some configuration C that lies between the steps Line(p, k, 1) and Line(p, k, 7[last]).
if the value of CSowner is not p in the configuration D, then there must exist a step s' in the fragment of the run from C to D such that s ~ changes the value of CSowner from p to something else.
reasoning
Software and its engineering
train_127109
In order to analyze the result in a better way, it is relevant know the pro.le of the assessors.
some characteristics as, age, gender, education level, knowl­edge in technology, expert or naive in video quality test, etc.
reasoning
Software and its engineering
train_127110
This is mainly because of the memory accesses and fewer numbers of blocks needed to fully utilize the GPU.
tuning stops increasing the aggressiveness of the optimization because it does not provide any further speedup.
reasoning
Software and its engineering
train_127111
Second,ineach classversionthestaticinitializerisex­tended toinvoke the pbi_initClass() methods of all class versions inthe end(if thereis no staticinitializerin a class version,itis created).
after merging of the staticinitializers, the pbi_initClass() methods of all class versions willbe executed, in­dependently ofthe executed code version ofthe merged staticini­tializer.Thatis,allinsertedstatic .eldswillbeproperlyinitialized.
reasoning
Software and its engineering
train_127112
Hence, we simply add the following line to the tracematch de.nition, giving the clue that actions occur more frequently than other symbols: frequent action ; Association aspects also choose their indexing structure based on the look-up direction.
look-up is guaranteed to be fast.
reasoning
Software and its engineering
train_127113
The class E.F could then be an extension of Top.this.a.b.C.
only if there is a common class wrapping the classes in point and there is a path of .nal .elds to the class that is to be extended.
reasoning
Software and its engineering
train_127114
MEASUREMENT AND RESEARCH ENVIRONMENT Tiwari mentioned in his paper that time the processor used was directly related to the power it needed [3].
to get the same output from similar essential working steps while controlling other kinds of element, the shorter the processor time uses the better performance of the chosen component is - in term of the power optimization.
reasoning
Software and its engineering
train_127115
Abductive exploration just performs the func­tion of a model builder that should be followed for a con.rmatory data analysis.
abduction plays the role of an explorer of viable paths, but further inquiry should determine which are the most plausible solutions [43].
reasoning
Software and its engineering
train_127116
But, the principal contribution of Little-JIL is perhaps its suggestion of abstractions that seem particularly effective in communicating process thought.
little-JIL is a member of a newer family of process definition languages aimed at determining what these models and abstractions need to look like.
reasoning
Software and its engineering
train_127117
In other words, the dynamics of any given software development effort make it necessary to revise written requirements.
waterfall approaches are faulted for not allowing for revision.
reasoning
Software and its engineering
train_127118
This constraint means that, viewed as un­signed 32-bit integers, I1 is strictly less than I2.
we view the machine as capable of manipulating mathematical integers,but the comparisons are limited to a 32-bit perspective on these math­ematical integers.
reasoning
Software and its engineering
train_127119
Toautomatethe entireloadingprocessitshould runwith­out user interaction.
for dynamic loading of appro­priate bundle code at runtime, bundles have to be describ­able with metadata characterising the OSGi bundle/service requirements and dependencies (see Figure 2).
reasoning
Software and its engineering
train_127120
In a work-stealing program, tasks often have the same features (e.g., number of instruction, compute-intensive or data-intensive).
the workers of a work-stealing program have similar demands on the computation resources as well.
reasoning
Software and its engineering
train_127121
An instruction needs to be dispatched before it can execute, and execute before being committed.
within each instruction s nodes there is a DE edge and an EC edge.
reasoning
Software and its engineering
train_127122
Furthermore, modern supercomputers are often configured by connecting multiple GPUs in large-scale networks due to the advantages of such architectures, including their very high cost/performance ratios and low power consumption.
outside of the GMs, it is also essential to have some way of detecting faults in the interconnections between the SMs and GMs, or in the network between the GPUs.
reasoning
Software and its engineering
train_127123
ECMAScript 5 s frozen ob­jects help to simulate ActionScript 3 classes more accurately.
jangaroo will not become dispensable, but on the con­trary, it will be possible to approach full support for Action-Script 3 in modern browsers.
reasoning
Software and its engineering
train_127124
Dis­abling network bu.ering for puts (this happens to be correct for this benchmark) brings the auto version s performance to within 3% of that of manual blocking, but has no ef­fects on the other benchmarks.
while our framework is e.ective for small to medium transfer sizes, a zero-copy consistency checking algorithm could further bene.t appli­cations with large-sized puts.
reasoning
Software and its engineering
train_127125
Only when they are equal, the proof passed in by the user can be casted to a proof of pf (Cashier says (Paid m)), where m is the value of the stored current nonce.
an old proof with an ex­pired nonce will not reveal the secret.
reasoning
Software and its engineering
train_127126
As you can see in Figure 10, the store replication itself worsens the performance of the program.
we need to cancel such a transformation if the loop cannot be transformed to the faster code.
reasoning
Software and its engineering
train_127127
Al­though thebenchmarks, when partitioned into tasks, do not contain inter-task dependences, false sharing introduces de­pendences that occasionally cause speculation to fail.
webelieve that ourresults re.ect theperformance ofbench­marks with dependences.
reasoning
Software and its engineering
train_127128
In contrast to R.1, we also need to modify annotations on members, because we include the containing class in more variants than before.
we propagate the classes annotations to their members.3 Similar to merging classes from mutually exclusive features, with refactoring R.3, we also merge members with the same name inside a class.
reasoning
Software and its engineering
train_127129
If we were to lock the data structure for each of Q queries, each query might be forced to wait for in­sertions and other queries, thereby increasing the apparent work by as much as T(QP) and nullifying the advantages of P-way parallelism.
we lock the entire global tier when an inser­tion occurs, but use a lock-free implementation for the presumably more-numerous queries.
reasoning
Software and its engineering
train_127130
We felt these issues would make it dif.cult to extend Ruby s parser for our own purposes, e.g., to add a type annotation language for DRuby.
we opted to write a Ruby parser from scratch.
reasoning
Software and its engineering
train_127131
For example, collocating two blocks in a 13­region, which includes two virtual pages in our system, produces a 50% probability that two blocks are in the same page.
other values of K affect the probability for cache or page collocation.
reasoning
Software and its engineering
train_127132
Consequently, different tools are able to accurately render and edit the globally traced artifacts.
a new artifact can be entered via a Word document, modified through a web data entry form, and viewed in a table-format report.
reasoning
Software and its engineering
train_127133
If we consider a product line with hundreds and thousands of features [1], it becomes obvious that product-based measurement does not scale.
we need better methods for determining quality attributes of all products.
reasoning
Software and its engineering
train_127134
3) Finally, smartphone users can benefit from a more flexible choice of sensors for their intended applications, as long as the sensors have the Dan­delion support.
users will also benefit from a wider range of emerging applications and sensors.
reasoning
Software and its engineering
train_127135
Second, if a variable is allowed to have multiple lifetimes, they may be assigned di.erent colors, depending on the or­der of the basic blocks.
in connecting the data.ow, the number of data.ow transfer instructions needed is also dependent on the order.
reasoning
Software and its engineering
train_127136
This implies that this value can be recovered neither by the rede.ne tech­nique nor by the extract-from use technique.
the RCG algorithm resorts to state saving which is performed by the inserted save instruction before i1.
reasoning
Software and its engineering
train_127137
At a call site to the procedure, the objects accessed via the iterator are resolved to be parts of composite objects.
applying the summary of the procedure results in some points-to relations which have the pointer components of composite objects as sources.
reasoning
Software and its engineering
train_127138
Note that if two or more input (output) transitions have the same output (input) vector, we can fuse them in one transition whose rate is the sum of the rates of the original transitions.
without loss of generality, we assume that all the input (output) transitions have di.erent output (input) vectors.
reasoning
Software and its engineering
train_127139
We assume in this work that the collectors operate on spare processors.
complicated scheduling issues that often appear with uniprocessors do not arise.
reasoning
Software and its engineering
train_127140
2) An atomicity violation may be benign it does not affect the correctness of the program.
in order to understand the effectiveness of the tool, we tried to identify if an atomicity violation error reported by ATOM-FUZZER could lead to a bug.
reasoning
Software and its engineering
train_127141
However, as mentioned in Section 5.2, whenever a formula is satis.able there always exists an in.nity of possible labellings which satisfy it.
rather than propos­ing just one labelled tree, the solver gives a minimal tree together with labelling constraints representing all labellings which make that particular tree a counter-example.
reasoning
Software and its engineering
train_127142
Additionally, Figure 5(d) con.rms that the latter strategy promises a better temporal workload balance.
thelatter strategyispreferred to cope withpeerheterogeneity.
reasoning
Software and its engineering
train_127143
Since routing nodes in a wide-area pub-sub system are typically managed by entities in di.erent administrative domains, we must assume that publishers do not trust rout­ing nodes in other domains in terms of the con.dentiality of their published data.
our secure aggregation protocol should allow untrusted routing nodes to perform aggregation of raw data without learning the private input values.
reasoning
Software and its engineering
train_127144
In other words, xi = cji for 1 =i =k.
since each count c is independently selected with probability g(c), for each occurrence of c, on the average g(1 c) -1 other nodes have (I,c)but did not sample it; that is, each occurrence of ccan be thought of as representing g(1 c) occurrences of c. we estimate the total count fI of I as x1 x2 xk fbI = + + ···+ (1) g(x1) g(x2) g(xk) The following theorem shows that this estimator is unbiased and establishes its MSE.
reasoning
Software and its engineering
train_127145
In order to continue exemplifying the use of negative scenarios let us assume that the new implied scenario is also deemed as undesired behaviour by stakeholders.
we obtain a new negative scenario (Figure 10) from which a new constraint can be built to check for further implied scenarios.
reasoning
Software and its engineering
train_127146
First, for each considered parameter, the values of that parame­ter in the two samples are being compared; a parameter similarity factor (p SimF) is calculated for each such pa­rameter.
there will be an individual memory usage p SimF, a workload p SimF and so on, for each monitored parameter.
reasoning
Software and its engineering
train_127147
However, a merge com­bines a data block and a log block into a new data block.
physically, a merge results in using an already erased block but producing two new erased blocks.
reasoning
Software and its engineering
train_127148
Barring special thread interfaces such as OpenMP, however, the number of threads cannot be dynamically adjusted during runtime for most workloads.
if the power cap or workload behavior vary signi.cantly during runtime, it is highly likely that the sys­tem operating point will not lie on the power-delay Pareto ef.cient Table 2: A comparison of the average power and execution de­lay of our MLR classi.er with and without thread packing for a 130W power cap.
reasoning
Software and its engineering
train_127149
On the other hand, a better bound has been proved for C B C -M AC than for our construction, namely on the order of 2-blq2 [7] (when l < 2b/3).
the trade-off between slightly slower performance and better bound should be explored.
reasoning
Software and its engineering
train_127150
Then the derivation ends with TEXP fol­lowed by an application of subsumption for the re.exive case.
f f e1 : L and f f e2 : L, and by induction µ(e1)= v(e1) and µ(e2)= v(e2).
reasoning
Software and its engineering
train_127151
Such a script can di­rect other applications to perform useful functions, but may also call other script .les.
script .les provide a simple mechanism for modularity.
reasoning
Software and its engineering
train_127152
In addition, we also remove the user provided atomicity constraint of incAndLog,sonow M3 (mutator increments) and mutator log­ging are no longer constrained to execute atomically.
the only atomicity constraints left in the mutator are those forming the individual building blocks.
reasoning
Software and its engineering
train_127153
However, this comes at a higher storage cost in memory, as well as higher mem- ory traffic.
the rest of this subsection gets into greater detail comparing DP with RP, in terms of per- formance implications of these prediction accuracies, par- ticularly for the applications with higher TLB miss rates.
reasoning
Software and its engineering
train_127154
If we do succeed, the new coloring can be committed.
we overwrite the old color with the temporary one and reset the changed .ag for each node in the list.
reasoning
Software and its engineering
train_127155
We deliberately chose to measure the gross effect including all startup and transfer over­heads as that is the impact that eventually can be observed by pro­grammers in terms of wall-clock runtime effects.
we present speedups of generated CUDA programs (referred to as SAC-CUDA) against their sequential counterparts (referred to as SAC-SEQ).
reasoning
Software and its engineering
train_127156
Working independently, these algorithms suit different types of programs.
using one or more of these algorithms, a variety of programs can bene.t from the use of Of.ine GC.
reasoning
Software and its engineering
train_127157
Sometimes design patterns introduce complexity.
before applying the transformation process, the impact of pattern oriented refactoring on quality attributes[11] needs to be estimated.
reasoning
Software and its engineering
train_127158
Note that Permissions propagated upwards via a doPriviledged node do not propagate beyond the predecessor of the doPrivileged node.
the above definition (or the algorithm based on it) must be refined to replace G-() by G- n, p), where n ( To clarify all of the concepts introduced in this section, consider the following simple example.
reasoning
Software and its engineering
train_127159
To achieve maximum degree of semantic interoperability, the SNOMED CT ontology is one of the choices to use in standard MLMs.
the use of standard information model HL7 vMR and standard terminologies such as SNOMED CT ontology in MLM provide interoperability and exchangeability features in knowledge base.
reasoning
Software and its engineering
train_127160
However, in terms of emulating the NUMA API, while these results show slightly more variation between the two implementations, the dif­ferences, again, are always within the margin of error.
our framework provides an effective implementation of the NUMA op­timization in HotSpot.
reasoning
Software and its engineering
train_127161
High-level lan­guages provide type-safety, memory-safety, encapsulation, and strong abstraction over hardware [12], which are desir­ able goals for system programming as well.
high-level languages are potential candidates for system programming.
reasoning
Software and its engineering
train_127162
At room temperature for silicon, fv is 15.6 THz and the ratio of power for stoke and anti-stoke output is around 10.
in this paper, we will only consider the stoke wave for maximum power emission from the Silicon Raman laser.
reasoning
Software and its engineering
train_127163
In languages such as Java in which objects are always accessed indi­rectly through references, points-to information is also an impor­tant prerequisite for many analyses, and points-to analysis is often interdependent with call graph construction.
tools for com­paring points-to analysis results should also be developed, perhaps combined with the call graph comparison tools.
reasoning
Software and its engineering
train_127164
(R ) The secondhypothesis of(R ) creates O(#edge.2) table entries, in contrast to O(1) table entries created by (L ).
we conclude that the right-recursive version should run a constant factor slower.The experimentsinSection6 con.rm this.
reasoning
Software and its engineering
train_127165
In other words, the value of the corresponding logical expression must be changeable through some user interface control.
our approach works in two steps: 1) Identify all the alternative paths to the backbone execution.
reasoning
Software and its engineering
train_127166
In the next O(log k) time units the win- ner of the tournament tree is determined (according to the properties of the tournament tree).
in O(log k) time units some process enters the critical section.
reasoning
Software and its engineering
train_127167
Change in data correlations may result in changes to the correlation graph.
each deleted node s periodically checks for validity of the hyperedge (S, s)usedin its C3 condition by gathering data from the nodes in S (using the piggyback strategy over normal data-gathering process as described in Section 2.3), recomputing the a parameters (Equation (2)), and checking if the least square error (Equa­tion (1)) is within the given bound.
reasoning
Software and its engineering
train_127168
Generally, private cloud platforms may benefit from a better network interconnect, better security, and more user control over the resources.
private cloud platforms are ideal for testing scientific applications and identifying best practices for scientific computing on cloud platforms.
reasoning
Software and its engineering
train_127169
Therefore, the difference between nx (where every ai =1) and R increases, and the given range increases.
the effect of using virtual nodes will increase as the system becomes more heterogeneous.
reasoning
Software and its engineering
train_127170
The former is comparable to the Object... parameter list in Java: variadic arguments can be accessed through void pointers, but also their typeid is available.
the programmer can safely cast the ar­guments to their expected types and deal with errors in a controlled manner.
reasoning
Software and its engineering
train_127171
However, it still requires all non-deterministic events, even those related to messages ex­changed inside a cluster, to be logged during failure-free exe­cution to ensure that the exact same execution can be repro­duced after a failure [7].
the performance of these pro­tocols can also be impaired by the overhead of event logging.
reasoning
Software and its engineering
train_127172
0 if |f1 - f2|= a I(f1,f2,a)=(|f1 - f2|) (1) 1 - otherwise a For IEEE 802.11b/g three channels of the 2.4GHz fre­quency band are theoretically orthogonal.
we set a to 30MHz, which results in the following set of orthogo­nal channels {1, 7, 13}.
reasoning
Software and its engineering
train_127173
In this paper, we are mainly interested in how this choice of base language affects the design of aspect-oriented features.
we present an aspect-oriented exten­sion to Petri nets and demonstrate its use with an invariant enforcement example.
reasoning
Software and its engineering
train_127174
Thisleaves alotofBluetoothbandwidth un­used because the Bluetooth interface in BlueStreaming is always active.
when there are uploading packets pending, un-used Bluetooth bandwidth is .rstly exploited to transmit the uploading traf.c.
reasoning
Software and its engineering
train_127175
3.3 Fault Localization An EFG is a Bayesian network which models the error propagation in a set of program runs.
we can apply an inference technique on the EFG to .nd the root cause of the error.
reasoning
Software and its engineering
train_127176
This highlights that a single ISTOF value (maximum stress traffic) can happen in different time instances, thus suggesting the search landscape for the GA is rather complex for this type of problem.
a testing strategy to further explore would be to cover all (or a subset of) such test requirements with maximum ISTOF values in different time instances.
reasoning
Software and its engineering
train_127177
THE FUNCTIONAL PARADIGM The definition of an MPL-RM function is required to be free of side effects.
neither global variables nor objects may be destructively updated within a function.
reasoning
Software and its engineering
train_127178
We have implemented this idea by creating a predefined concrete interface for each kind of traditional constructor, which extends the set of operations provided by the constructor.
the record constructor is associated with a predefined concrete interface with well-defined semantics.
reasoning
Software and its engineering
train_127179
Taking a snapshot when an object has been converted violates the third safety requirement for using a snapshot from an optimized execu­tion in a debug build.
we restrict the compiler to only convert objects that are non-escaping and whose lifetimes do not cross snapshot safe points.
reasoning
Software and its engineering
train_127180
However, the relevant sets of objects may not be explicitly available in the original program.
in this paper, we present a declarative approach for de.ning sets of objects with the same usage pattern by means of a dedicated language construct.
reasoning
Software and its engineering
train_127181
All graphs of order lower than 11 are also included in this amount.
any possible graph up to Order 11 can be pre-calculated and all instances of known character graphs can be mapped to these pre-calculated models.
reasoning
Software and its engineering
train_127182
This is a hard problem both in theory and in practice [2].
rather than compute the pre­ cise answer, we seek to bound the probability of satisfaction.
reasoning
Software and its engineering
train_127183
In our solution, we exploit the interpretation that ensem­bles can be viewed as a con.guration of a .attened SPL reference architecture.
we create an SPL con.gura­tion by (i) transforming the SPL reference architecture to an architecture of DEECo components and ensemble de.ni­tions, and (ii) re.ecting the establishing and dissolution of DEECo ensembles at the level of the SPL reference architec­ture.
reasoning
Software and its engineering
train_127184
At the end of each round, the results in array tempU are copied back to U.The (ij)T loop nest implements the actual 5-point stencil computa­tion, and is the focus of our approach.
we will omit the outermost t loop and the array copying part (which is not a stencil computation) in the rest of our discussion.
reasoning
Software and its engineering
train_127185
Because of these prob­lems, it is di.cult to use an only PRAM main memory.
researchers consider a hybrid main memory architecture with DRAM and PRAM.
reasoning
Software and its engineering
train_127186
As a result, based on the concavity of R(ek)inTheorem2and the optimalityof Theorem1,wecandividetheoverall optimization problem into two subproblems, says inter-frame and intra-frame energy assignments.
what we have to do is to determine the intra-frame energy assignment.Byapplying the Lagrange Mul­tiplier method, we can solvethe problem in Equation (1) optimally, as shown in Algorithm 2.
reasoning
Software and its engineering
train_127187
However, with limited profiling, sophisticated path profiling schemes can no longer offer any prediction advantages over simpler schemes that exhibit much lower runtime overheads.
while intuition may call for longer and more elaborate profiling, we will show in fact show that the opposite it true: less profiling actually leads to more effective predictions.
reasoning
Software and its engineering
train_127188
In fact, the least .xed point assigns to each port the empty signal.
deadlock manifests itself as a least .xed point of empty or .nite sequences.
reasoning
Software and its engineering
train_127189
We assume that the security manager establishes an aggregation path such that there between pi and psub.
at least m + 1 colluding parties are required to obtain the value of vi.
reasoning
Software and its engineering
train_127190
By the previous rollback scheme, the federate state is always re­covered at the point of an NMR call to the TiMaC layer.
this means that, upon state recovery, the federate automati­cally re-starts from the epoch with initial time trecovery .after having performed the state recovery phase through the Recovery-Action B, TiMaC skips exe­cution of Step 1 and immediately goes on executing Step 2 and Step 3 for that epoch.
reasoning
Software and its engineering
train_127191
i=1 where n is the number of .elds of o; Lo is the lifetime of th instance o; li is the lifetime of the i.eld of o; r(o)is the idle .eld ratio for o; b is the size of each .eld; and Bo is the total size of o (i.e., Bo = nb).
p(o) is determined by three factors: the idle .eld ratio, size and lifetime of instance o.
reasoning
Software and its engineering
train_127192
While both approaches are potentially good, the .rst one is likely to be harder and, in addition, not very e.ective when the algorithm runs with a small number of processors like in our experiments.
in this paper, we focus on the second approach.
reasoning
Software and its engineering
train_127193
automaticdeductionofacompoundexpression ssemanticvalue:Ifthecompoundexpressionreferencesonlyasin­glenon-voidnonterminal,thatnonterminal ssemanticvaluemustbetheoverallexpression svalue.
atext-onlyproductionisaproductionwithadeclaredtypeofString.Additionally,itmustnotcontainassignmentstoyyValue andmayreferenceonlyothertext-onlyproductions.Theseman­ticvalueofatext-onlyproductionisthetextmatchedintheinput.text-onlyproductionseliminatetheneedforexplic­itlybuildingupstringsthroughJava sstringbuffers;onasuccess­fulmatch,theimplementationsimplycreatesthestringfromthebufferedinputcharacters.Text-onlyproductionsaretypicallyusedforrecognizingidenti.ers,keywords,andliterals.Forexample,thefollowingtext-onlyproductionfromourJavagrammarrecognizesstringliterals: String StringLiteral = ["] (EscapeSequence / !
reasoning
Software and its engineering
train_127194
Furthermore, clients also have to pay money for transferring data across the networks to/from the providers.
depending upon how much the client is willing to pay, the client might want to do some processing at the server in order to reduce the amount of data that it has to transfer to the client.
reasoning
Software and its engineering
train_127195
Traditionally, clean-slate design tends to focus on creating effective and elegant networks for a static set of requirements.
the approach is often one of engineering, which tends to neglect competitive effects.
reasoning
Software and its engineering
train_127196
Additionally we assume that time constraints allow us to execute only n% of the original test suite.
lru(n) chooses the n% of the test suite with the highest selection probabilities.
reasoning
Software and its engineering
train_127197
Moreover, the other application processes will be able to use their local checkpoint copies.
this storage mode pro­vides recovery as long as one of the two nodes containing a checkpoint replica is available.
reasoning
Software and its engineering
train_127198
Given variables tl, ..., tl+n .fv(C), representing the types of locations l, ..., l+ n,if a.fv(.ti), then the type at location i contains the variable a.
we report it as a candidate for a type annotation.
reasoning
Software and its engineering
train_127199
DEFINITION1(CAPSULESTATEHART).Aapsule statehartSC=(S,E,A,T,P,port)onsistsof anon-empty,fnitesetSofstates, afnitesetEofevents, afnitesetAofations, atransitionrelationTSxExAxS,where e/a(si,e,a,s})ETisdenotedbysi -s},and afnitesetPofportnames.
wedistinguishbetweeninternalandexternaleventsanda­tions.Externaleventsandationsareausedbyreeiving andsending,respetively,amessageviaaport.we assumeafuntionport:E+A-P+{I}assoiatingto eaheventorationxaportnameinPorthedistinguished labelIdesignatinganinternaleventoration.
reasoning
Software and its engineering