id
stringlengths
7
12
sentence1
stringlengths
5
1.44k
sentence2
stringlengths
6
2.06k
label
stringclasses
4 values
domain
stringclasses
5 values
train_127200
However, there is a dramatic difference between the programming model for a batch message queue and an event handler.
our view might be summarized as event notifications are messages that cause actions.
reasoning
Software and its engineering
train_127201
Output checking The bugs in the benchmarks CB.aget and parsec.streamcluster2, lead to incorrect output.
we added extra code to read the output .le and trig­ger an assertion failure when incorrect; the output checking code for the CB.aget was provided as a separate program, which we added to the benchmark.
reasoning
Software and its engineering
train_127202
As DMP-B .ushes store buffers on every fence (not distinguish­ing between different types of fences), it implements a weak order­ing memory consistency model [2], speci.cally total store ordering (PowerPC and Sparc processor architectures have a .avor of such a model).
dMP-B does not noticeably weaken the consistency model provided by modern execution stacks.
reasoning
Software and its engineering
train_127203
The results indicate that all the four independent variables are statistically significant at 0.01 level.
all the four propositions are significant.
reasoning
Software and its engineering
train_127204
However, by definition, master data services are shared service across all business service providers, i.e., lines of businesses, and no individual lines of business is responsible for implementing such services.
this is modeled as a new type of enterprise wide business service, used by all other lines of businesses.
reasoning
Software and its engineering
train_127205
The node for an invoked procedure will be pushed into the stack and popped out of the stack when the invo­cation ends.
the contents of the call stack repre­sent the nodes on the paths from the root of the invocation graph to the currently active procedure.
reasoning
Software and its engineering
train_127206
Two calls were pre­dicted correctly by the system (setText(), setLayoutData()); the third call (setFont()) was not proposed.
the system proposed 2/3rd of the calls the developer actually needed.
reasoning
Software and its engineering
train_127207
Recall that there is an implicit disjunctive mandatory constraint over all the roles played by the same type, since none of the types are in­dependent .
each qi value appears exactly once in the predicates.
reasoning
Software and its engineering
train_127208
This exact match is explained by our observation that all the translation and transformation rules that our compiler applies to Green-Marl programs are what program­mers typically do when implementing algorithms manually using the Pregel API.
the compiler-generated implementa­tions run in virtually the same way as the manual implementations do and exhibit similar performance behavior.
reasoning
Software and its engineering
train_127209
This happens as because the number of tracked pending calls never rises above k,after the k successive dispatches, the map value must be zero, thus the k +1-th call yields a ..
the MVP solution for the Ck-reduced instance is an underapproximation of the exact AIFDS solution that includes exactly those paths along which there are at most k successive dispatches to a particular procedure with a given local fact.
reasoning
Software and its engineering
train_127210
While we have included the number of lines of code of the benchmarks, Manticore is a whole-program compiler, including the entire basis library.
in addition to the lines of code, we have also reported the number of expressions, where an expression is an individual term from the intermediate representation shown in Figure 1.
reasoning
Software and its engineering
train_127211
Sec­ond, if z has type DPJPartition,then z.get(i) has type DPJArray and points into a DPJArray.
we must not treat z:[i]:* as disjoint from R. Here, we simply do not include this distinction in our type system.
reasoning
Software and its engineering
train_127212
The compositional or hierarchical real-time framework [8, 20] enables a group of real-time applications to be a single real-time resource requirement to the upper layer of real­time environments.
we assume that a RT-VM Vi is de­.ned from multiple real-time applications, {tk (rk,wk,dk,pk, fk)|k =1,...,n}, of the service by using compositional real­time technique.
reasoning
Software and its engineering
train_127213
This allows cloud schedulers to randomly distribute jobs to proces­sors with statistically more uniform global behaviour in execution time and processor utilisation.
the principles of CL at a hardware parallelism level and as taught in computer systems engineering undergrad­uate courses can be exploited for higher-level software co­ordination in grid and cloud applications through the CL dwarf, as identi.ed in the classi.cation of parallel software architectures.
reasoning
Software and its engineering
train_127214
Additionally, some constructs, such as con­dition wait, arguably do not lend themselves well to the TM paradigm [20].
lock-based multithreaded pro­grams will continue to be popular even when TM is adopted.
reasoning
Software and its engineering
train_127215
However, previous audio fingerprinting works are not designed exclusively for the MP3 songs.
the prime 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.
reasoning
Software and its engineering
train_127216
Further­more, these scrips or scenarios can be tedious to create and maintain.
we propose an approach, supported by the MBPeT tool [1], where load is generated from abstract graphical models describing VU behavior.
reasoning
Software and its engineering
train_127217
Foracompletegraph,PoA =1,andforastar,PoA = 2.Foracompletegraph,whena> 1,bothNashequilibriaandso­cialoptimaplaceonereplicaatoneserver,soPoA =1.Forstar,when1 <a < 2,theworstcaseNashequilibriumplacesreplicasatallleafnodes.However,thesocialoptimumplaces (n-1)a+1 onereplicaatthecenternode.Therefore,PoA = = a+(n-1) 2(n-1)+1 = 2.Whena> 2,theworstcaseNashequilibrium 1+(n-1) placesonereplicaataleafnodeandtheothernodesaccesstheremotereplica,andthesocialoptimumplacesonereplicaatthe a+1+2(n-2) n center.PoA = =1+ =2.
a+(n-1) a+(n-1) v Foraline,thepriceofanarchyisO( n).When1 <a < n,theworstcaseNashequilibriumplacesreplicasevery2a sothatthereisnooverlapbetweenareascoveredbytwoadjacentserversthatcachetheobject.Thesocialoptimumplacesreplicasatleast v every2a.Theplacementofreplicasforthesocialoptimumisasfollows.Supposetherearetworeplicasseparatedbydistance d.Byplacinganadditionalreplicainthemiddle,wewanttohavethereductionofdistancetobeatleasta.Thedistancereductionisd/2+2{((d/2-1)-1)+((d/2-2)-2)+... +((d/2- v d/4)-d/4)}=d2/8.dshouldbeatmost2 2a.the v distancebetweenreplicasinthesocialoptimumisatmost2a.
reasoning
Software and its engineering
train_127218
Thus, to guarantee parametrized opacity, we must have v = v '.
t must issue an update instruction to ax with value v. Theorem 1.
reasoning
Software and its engineering
train_127219
However, it is important to keep the underlining principle and philosophy of Wikis, of making it easy to edit and correct errors.
we suggest a pragmatic balance between flexible and rigid approaches with a process rather than product orientation as the underlining objective of the development.
reasoning
Software and its engineering
train_127220
To summarize, as we demonstrated, PPT did not only pro­duce the exact same regression tree showing the same pat­terns, it also resulted in a reasonable prediction performance when we generated the OLS models from the perturbed data based on the COCOMO model.
pPT success­fully met our research objective of preserving privacy while preserving the utility of the perturbed data when used for research purposes.
reasoning
Software and its engineering
train_127221
SOA technology can support the independent infrastructure and allow the autonomous operation of its functional components.
using SOA as a fundamental infrastructure, a virtual community is formed through rewrapping services with additional functionalities.
reasoning
Software and its engineering
train_127222
It is also dif.cult for users to determine suitable values for the parameters without .rst having a good understanding of the MapReduce application characteristics.
it is a challenge to systematically explore the parameter space and select a near-optimal con.guration.
reasoning
Software and its engineering
train_127223
An exception to this overall trend is the LBM benchmark, in which the EDP im­provement for coupled execution is larger than for decou­pled, due to the fact that its write accesses are coupled with computations during the execute phase.
this applica­tion does not take the complete advantage of the decou­pled execution which decouples only the read accesses from computation.
reasoning
Software and its engineering
train_127224
The re­mainder [7, 14, 31] were classi.ed as a study that evaluates, reviews, or presents the state of the art about model-driven development to automatically generate software-intensive SoS.
we observed that there is still opportunities of research to be investigated, since most of the included papers report ongoing research.
reasoning
Software and its engineering
train_127225
Figure 5: Complete lock state transitions when lock reservation is coupled with tasuki lock that precede the release.
when we implement lock reservation on a multiprocessor system with a relaxed memory model [1], we need to issue appropriate types of memory barriers in the functions of lock acquisition and re­ lease.
reasoning
Software and its engineering
train_127226
The result of this desug­aring step is a homogeneous abstract syntax tree, which con­tains only nodes declared in the initial SugarJ grammar (if some user-speci.c syntax was not desugared, the compiler issues an error message).
this tree represents one of the prede.ned top-level entries in SugarJ and is therefore com­posed only of nodes describing Java code, grammar rules or desugarings.
reasoning
Software and its engineering
train_127227
However, the included as­sets for generated product outputs still might change dueto architectural changes.
engineers need to check foreach product if its con.guration can still be created.
reasoning
Software and its engineering
train_127228
These are aggregated into larger messages by the runtime, but overhead is associated with each independent task that issues a remote request.
our cost function has to take into account number of messages in addition to the amount of data moved.
reasoning
Software and its engineering
train_127229
After several tries, we decided that it encompassed the infi'astructure relating to Universal Accessibility, that is, the legal, government, economic and social environment in which UA is embedded.
we had to define what this environment is and also the research issues related to that environment.
reasoning
Software and its engineering
train_127230
In general in order to get bene.t from sleeping period of the sensors, the saved energy due to sleep­ing for l/vmax should be greater than the energy exhausted for sensors turn-on.
we can allow the sensor net­work lifetime to be extended by adopting sleeping periods especially when nEon < Ps l .
reasoning
Software and its engineering
train_127231
The reason is that the lack of synchrony may cause P to miss input changes (of the geodesic path) and therefore to reduce the number of output changes.
the number of changes of the output of a processor P in BP is not larger than the values stated in Theorem 3.6.
reasoning
Software and its engineering
train_127232
By using the role diagram and the properties, we are able to express it inside our pattern de.nition.
our MDE approach delivers a complete solution, from the modeling of the pattern, to the last stage of its integration, by insuring at all stages that the pattern properties are respected.
reasoning
Software and its engineering
train_127233
As such, endpoint models require signi.cantly less runtime resources than their real counterparts.
it will become pos­sible to emulate the interaction behaviour of a large number of endpoints on one to a few physical hardware nodes only, allowing testing of enterprise systems in more realistic envi­ronments than currently possible.
reasoning
Software and its engineering
train_127234
Usually, DFI checks can detect an error before the checks that we use during normal execution.
we can stop the replay earlier and generate less path conditions.
reasoning
Software and its engineering
train_127235
r ctx} while sound, is useless because the .rst assumption requires e1 and e1 ' to evaluate to syntactically the same function.
a P P V requires the functions to be already values, and checks that their bodies are related whenever the functions are applied to the same arguments.
reasoning
Software and its engineering
train_127236
The reason is that the composed trait may be the subject tolatertrait composition or modi.cation operations.
method speci.cations that were unsatis.able in the original composition may againbe satis.able.
reasoning
Software and its engineering
train_127237
Considering that multiple strategies can be used to .x these interactions, it is up to the designer to select the right one, according to his/her intention.
the way a designer resolves such an interaction is part of the domain variability: it represents a variation point at the domain level.
reasoning
Software and its engineering
train_127238
Federated identity management empowers the cloud tenant to authenticate themselves using their desired identity provider.
an exchange of identity attributes takes place between identity providers and service providers.
reasoning
Software and its engineering
train_127239
For instance, it does not matter how a particular list box may look like in a par­ticular computing platform, for a particular UI.
the physical position (e.g., in terms of absolute coordinates) and the physical dimensions (e.g., in terms of pixels) can be left out if needed.
reasoning
Software and its engineering
train_127240
Therefore, it is guaranteed that a task is blocked (to acquire its mutexes) at most once (when it first tries to lock any mutex) and by at most one lower priority task.
transitive and chained blocking cannot happen.
reasoning
Software and its engineering
train_127241
EXPERIMENT DESCRIPTION The goal of this experiment is to assess whether the use of stereotypes improves the understanding of UML sequence diagrams.
by using the GQM template for goal definition [1], the goal of our experiment is defined as follows: Analyze the use of stereotypes for the purpose of evaluating it with respect to the comprehension of UML sequence diagrams from the point of view of the researcher, in the context of fourth year undergraduate students in Computer Science from the University of Bari .
reasoning
Software and its engineering
train_127242
Since AspectJ s join points are regions in time rather than events, we had to add the before and after keywords to our add and remove expressions.
compiling to a different target language with native support for events (e.g., EScala [11] or Composition Filters [2], the point-in-time join-point model [16]) would in.uence the notation of these expressions.
reasoning
Software and its engineering
train_127243
We prove that our algorithm .nds the optimal solution for a given network and work.ow, decreasing the energy consumed on mobile devices by 32-37% compared to an approach where the entire work.ow is executed in the infrastructure.
in typical domains like logistics and health care, one third of the energy can be saved.
reasoning
Software and its engineering
train_127244
They support the re-use and extension of declara­tive language speci.cations but lack the modular analyses in Silver and Copper that provide strong guarantees that the automatic composition of speci.cations will result in a trans­lator that will just work.
their audience is primarily those who have some compiler implementation ex­pertise.
reasoning
Software and its engineering
train_127245
The reason for this is that reclationships such as l_< i or i_</, where I denotes a legal type and i denotes an illegal type, would contradict program correctness as we go up the lattice.
a bounabd type lattice s that is serviceable even in the presence of type incorrect programs should have the general form shown in Figure 1.
reasoning
Software and its engineering
train_127246
In contrast, reflective APIs built around the concept of mirrors are characterized by adherence to these three principles.
mirror-based architectures have significant advantages with respect to distribution, deployment and general purpose metaprogramming.
reasoning
Software and its engineering
train_127247
The example above illustrates that the reachability anal­ysis discovers that a loop does not terminate but only if the loop invariant is strong enough.
it would be bene.cial to combine the reachability analysis with techniques for loop invariant generation [10, 17, 23].
reasoning
Software and its engineering
train_127248
6; (atomic (seq(l2 := 7,l1 := !l2))) i (l2 := 4) Weak allows a sequence of steps where the .nal value in l1 is 4.
the two languages are not equivalent,but there are still manyprograms for which they are (i.e., anyresult possible in one language is possible in the other).
reasoning
Software and its engineering
train_127249
3.3 into a Java class following the semantics rules de.ned in [12].
a repository storing some policies, and the related PDP, consists of a Java archive containing all the Java classes generated from the policies.
reasoning
Software and its engineering
train_127250
In fact, when we reach maxLive > 2 · n of reg, we often have to increase the II.
most of the spill instruc­tions added by MIRS are added once a .rst complete schedule of the original loop has been produced.
reasoning
Software and its engineering
train_127251
As Figure 14 illustrates, the problem is that interrupts are not disabled immediately after calling TOSH INTERRUPT at line 1.
a long whistle at the right frequency will cause the tone detector interrupt on the Mica Sensor Board to contin­ually .re, preemptively invoking the handler routine mul­tiple times in a row and causing a stack over.ow.
reasoning
Software and its engineering
train_127252
Through algorithms that are written by ex­perts, composite components are automatically generated before the composition process starts.
our approach is not a substitute for existing composition algorithms but complements them with a preprocessing step.
reasoning
Software and its engineering
train_127253
In this case, Af.nity-Accept s goal is to preserve ef.cient local processing of connections.
af.nity-Accept must match the load offered to each core (by packets from the NIC s RX DMA rings) to the application s throughput on that core.
reasoning
Software and its engineering
train_127254
The pointer operations inevitably insert address cal­culation code in-between.
unless the compiler can eliminate the code explicitly by utilizing ARs for the ad­dress calculation, the multiply and add operations cannot be merged to a MAC instruction.
reasoning
Software and its engineering
train_127255
For example, most keywords, like resource, can contain any nested keyword (as shown in the contract in the lower-right of the .gure), but collection, member, and namespace can contain any keywords except collection and member (as shown in the contract in the upper-right of the .gure).
we see that RDL allows the con­tract structure and the implementation structure to differ if needed.
reasoning
Software and its engineering
train_127256
Fact 4 (Collector .-expansion).
for all term t and for all variables x and p free in t, we have: p2 t p x =ß (t x)x p it seems that we should be satis.ed with the KAM description.
reasoning
Software and its engineering
train_127257
In other words, whereas the two-set algorithms maintain two sets X and X' corresponding to variable x, the one-set algorithm only maintains X.
during execution, we may have to rebuild X' from X, which in principle is an expensive operation.
reasoning
Software and its engineering
train_127258
Before the data item d is read on the client in task B,the data item d on the client must be made valid (Vci(B, d)=1).
the state of data item d on the client changes from invalid to valid, which means that a data transfer is required for d from the server to the client on edge (A, B).
reasoning
Software and its engineering
train_127259
To further complicate matters, browser vendors often add new features without consulting other vendors.
each browser de.nes an idiosyncratic JavaScript interpreter, HTML parser, and layout engine.
reasoning
Software and its engineering
train_127260
From these border colors, the teacher is kept informed of which areas of the spreadsheet are tested and to what extent.
in the figure, row 4 s Letter cell s border is partially blue (purple), because some of the dependencies ending at that cell have now been tested.
reasoning
Software and its engineering
train_127261
The typechecker must derive propositions from it and propagate them to the then and else branches.
it .rst computes the propositions derived for each of the three subexpressions, giving Nx |Nx for the test and Sy |Sy for the then branch.
reasoning
Software and its engineering
train_127262
For this implementation, the matrices are stored in the traditional column-major order, and blocks are refer­ences into these matrices.
blocks are not con­tiguous in memory.
reasoning
Software and its engineering
train_127263
The same holds for parts of the architecture description and its logical statement the parts that describe which layers and allowed dependency directions exist are extensional, and a minimal design model for them exists.
a joint minimal design model can be determined for a description triple as exemplary depicted in the bottom part of Figure 1.
reasoning
Software and its engineering
train_127264
It is enough for the weaver to ensure that aspectual computation is run at a higher level.
our AspectJ extension does not support explicit level shifting at the moment.
reasoning
Software and its engineering
train_127265
Information on template variation can be used to come up with such an optimal set of templates.
statistical information gathered on template reuse and variability has appeared to be very important for the evaluation of the template meta-programming approach.
reasoning
Software and its engineering
train_127266
If the SRT scheduler admitted a SRT task with Eavg/P = 0.1 by using condition U - u0 + Eavg/P = 0.95 < 1, the system would be overloaded with utilization U = 0.95 + 0.1 = 1.05 >1, when VS-CBS0 becomes serving later.
in this algorithm, we use a variable U* to keep track of the amount of reclaimed bandwidth, instead of directly modifying utilization U, when adjusting the speed.
reasoning
Software and its engineering
train_127267
First, for a technical reason in the proof of Theorem 2.3, we need fjj to be small when |j| is small.
we de.ne the following notation f. For any j, de.ne J l |j| fj = +1 .
reasoning
Software and its engineering
train_127268
In this case the part of the input that was most recently removed must be the failure-inducing input difference.
the above approach isolated the failure-inducing input difference for these memory related bugs.
reasoning
Software and its engineering
train_127269
The XSEDE systems are based on an allocation-based accounting sys­tem where a project has limited usage hours.
the course must be able to distribute a su.cient number of usage hours to each student while reserving enough to perform extensive scaling studies for all students using the autograder.
reasoning
Software and its engineering
train_127270
But on the other hand, we can use instances of this trait to fold over ASTs or poly­morphically embed sentences, as discussed in Section 5.3.
the intended usage is that in a compiler that is modularized with object algebras, each module exports ob­ject algebras with context-sensitive operations or context decorators.
reasoning
Software and its engineering
train_127271
In other words, if the compaction is successful in providing suf.cient free space, the compression is not activated.
our approach is oriented towards reducing the impact of compres­sion/decompression on performance.
reasoning
Software and its engineering
train_127272
Males percent tested: r(22)=.46, p<.03; females: r(35)=.07, p<.68.
by every behavioral measure, the testing strategy was strongly tied with males success, but not with females success.
reasoning
Software and its engineering
train_127273
First, given that the network connection between the two sites is shared by other users, the e.ective networkperformance achievableis usually much lower than within the cluster.
with mpiBLAST trans­ferring the entire output result over this network, its per­formance would be heavily impacted by the network per­formance.
reasoning
Software and its engineering
train_127274
In fact, this need for evolution is common to all OSes, however, the developers of Linux have chosen to face evolution most directly while others stack layers upon layers leading to an intricate software architecture.
we believe that the use of Coccinelle is not limited to Linux, and could be envisioned in any systematic evolution process.
reasoning
Software and its engineering
train_127275
Our preliminary experiments with these two techniques showed that node split­ting can generate better savings than node merging, mainly because the lat­ter sometimes keeps disks in the active mode unnecessarily.
in the rest of our discussion, we focus our attention on node splitting.
reasoning
Software and its engineering
train_127276
While this standard behavior is suitable for most basic operations, it obviously cannot be used during transactions.
each database adapter is aware of its current transaction state and does not return connections to the queue while a transaction is in progress.
reasoning
Software and its engineering
train_127277
We would like to ensure that n1 s and n2 s cost will not increase due to n s leave.
at the beginning of round t+1, n1 s and n2 s outgoing balances with respect to each other are set to B1n and B2n, respectively.
reasoning
Software and its engineering
train_127278
"2 Guy Steele Coming back from general semiotics to programming, the important questions are the following: what would the es­ 1 The idea of the semiotic triangle has been developed by several philoso­phers at different times.
the actually used notions for three constituents of the semiotic triangle vary a lot, although the idea behind them is the same.
reasoning
Software and its engineering
train_127279
We apply DBP and we need 2 bu.ers.
in total, we have 8 single bu.ers.
reasoning
Software and its engineering
train_127280
The test reports a p-value = 0.001, which is below the a threshold.
we can reject the null hypothesis.
reasoning
Software and its engineering
train_127281
4.2 Maintaining Coherence on the GPU A GPU kernel cannot transfer data while executing, so insert­ing coherence checks into kernels would be futile we can­not update stale GPU copies mid-kernel execution.
x10CUDA+AMM must check and update all the Rails in a ker­nel s read set before it begins execution.
reasoning
Software and its engineering
train_127282
Thus, models conform to, and are considered the instances of metamodels.
metamodels are at the appropriate level for de.ning di.erence metamodels.
reasoning
Software and its engineering
train_127283
One then might want to rely on laziness, as we do, to avoid depending unnecessarily on the tail of the input, but then we hit the problem that the algorithm must be described imperatively.
we think that such an approach would be awkward, if at all applicable.
reasoning
Software and its engineering
train_127284
Software is not only produced by software companies but also within companies and organizations from traditional sectors ranging from automotive to telecommunications to banking and insurance.
the ability to Permission to make digital or hard copies of part or all 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.
reasoning
Software and its engineering
train_127285
Then, we ¯¯can safely substitute every occurrence of M with e in rule (ZR2) from Figure 2.
v now generates the regular * language a¯a *.
reasoning
Software and its engineering
train_127286
USER STUDY II -PROFESSIONAL DEVELOPERS The other type of potential users our approach targets is pro­fessional software developers who are experienced with ap­plication development.
in addition to studying ASIDE on novice programmers, we ran a similar comparison study on a group of expert programmers.
reasoning
Software and its engineering
train_127287
The approach vouches for a unified environment.
the developer is able to perform all the tasks using a single integrated platform.The succeeding subsections discuss the processes and components that are envisaged as possible solutions in minimizing the challenges of engineering semantic services.
reasoning
Software and its engineering
train_127288
Since the MOM is considered as a black box, we cannot measure its internal time consumption.
we cannot assign the exact load to the sender, receiver, or MOM components, but have to allocate all load to the MOM com­ponent.
reasoning
Software and its engineering
train_127289
The distinction between code artifacts (classes and class re.ne­ments) and features (containment hierarchies) requires a special treatment in FFJ s semantics and type system, which is different from prior work (see Section 5).
we use in the type system information about features that has been collected by the composition engine and that does not appear in the program text.
reasoning
Software and its engineering
train_127290
If we were to amortize the manufacturing cost of the home router on the basis of total traffic flow, we would assign almost the entire manufacturing cost of the home router to movie content alone; this seems unreasonable.
instead of attributing cost based on number of bits transmitted, we attribute costs as a percentage of time used for a given service.
reasoning
Software and its engineering
train_127291
The decay organizer periodically decays the profile dy- namic call graph to bias hot edge detection toward recently sampled call edges.
the decay organizer attempts to ensure that the system can adapt to program phase shifts.
reasoning
Software and its engineering
train_127292
SPL tools and training: There is acknowledgment across all groups that tools and training are important and have been neglected in the past.
the fact that an SPL approach depends on the consistent use of tools by trained developers should not pose an insurmountable problem.
reasoning
Software and its engineering
train_127293
Therefore, the number of tables created during s-topdown is no more than during v-topdown, and the number of answers stored in tables that exist in both are equal since they both should compute the same answers.
ss-topdn = Sv-topdn.
reasoning
Software and its engineering
train_127294
The HSBColour type can not be trans­lated directly into an X3D type.
the developer has the possibility to adapt the code generation mechanism for every complex type individually.
reasoning
Software and its engineering
train_127295
The rationale of AR is to foster the transition of knowledge from a mature research .eld to practical problems encountered in the daily routine.
aR is capable of providing insights which might be overlooked in a traditional research approach.
reasoning
Software and its engineering
train_127296
Variant-preserving mapping changes the im­plementation technique of an SPL.
the primary di­mension is SPL implementation technique.
reasoning
Software and its engineering
train_127297
Actually, concerning the assistive service, we propose sequences of activities which are related to preparation of breakfast in order to assist the patient with cognitive impairment in these ADL.
our system includes an algorithm for the activity recognition (see Algorithm 1) that allows recognizing the scenario performed according to the electrical appliances used and a prompting algorithm to evaluate the need to intervene if the patient has difficulty to complete it.
reasoning
Software and its engineering
train_127298
However, for the analyzed system, recall was largely preserved of the 72 clone groups to which coupled changes occurred, 68 were still detected by the tailored clone detection, indicating a recall of the tailored compared to the untailored detection of 94.4%.
changes in clone (group) count mostly denote changes in precision.
reasoning
Software and its engineering
train_127299
Opis [11] is recent work, which takes a functional-reactive ap­proach for developing distributed systems in OCaml.
the aim of Opis is similar to D3N.
reasoning
Software and its engineering