V represents a value greater than or equal to zero, we have -8  vk = vk and +8L vk = vk.If [ai,bi]=[-8, +8] (which means that the length of the array is unknown at the entry of this instruction), we have [ai  vk,bi L vk]=[vk,vk].

after the execution of an arraylength instruction, we introduce a new symbolic value, vk,to the frame state to represent the length of this array if the length of this array is unknown before the execution of this instruction.


If all procedure interfaces are conservative, then the updates (21) and (24) will completely remove the preconditions and e.ects of the auxiliary operators introduced in (19), (20), (22) and (23).

if the code producer is honest about the optimization directives, then the run-time checks for fraud detection will be optimized away.


For this example, the weight placed on edges in the logical network reflects the distance vector between connected nodes.

given two connected nodes, the weight on ~-connecting them accounts for both the displacement and the direction of the displacement between the two nodes.


In the context of this research area, systematic mapping (also systematic mapping study or scoping review) [23] has recently been proposed and has provided mechanisms to deal with research evidence.

it makes possible to systematically identify, select, analyze and aggregate research evidence, aiming at providing knowledge of a research topic.


The goal of the Pensieve project is to allow the exploration of compiler techniques and the cost necessary to support stricter consistency models in Java.

the Pensieve system generates code whose executions are sequentially consistent rather than the more relaxed original Java consistency model and the new Java memory model [10].


Thus, a sequence of terms in a SmPL semantic patch matches a sequence of C-language terms along such a path.

the SmPL construct ... represents an arbitrary CFG path fragment.


1.2 Stability Ratio Competitive ratio defines the worst case bound on the per- formance of an online algorithm.

all possible histories are considered and the maximum ratio between the performance of the online algorithm and the offiine al- gorithm is computed.


This paper presents a novel approach that provides the programmer with a capability to enhance the functionality of the generated code, without any of the shortcomings of the two approaches outlined above.

we enable changing the functionality of the generated code externally to the code itself and to the COTS code generator.


Speci.cally, our approach enables a smooth separation of concerns, allowing the core algorithmic functionality and its adaptivity schemas to be expressed in di.erent languages by their respective domain experts.

following our approach makes it possible for scienti.cprogrammers and computing expertsto collaborate harmoniously while playing on their respective home turfs.


We were also able to obtain answers to our initial set of questions.

we learned the following information: Customers were satisfied with our getting started guide, but needed more information as they progressed through the individual store creation and store maintenance tasks.


That is why some policies use the cost/bene.t ratio to choose their victims.


One of the most important features of XMF is that it is capable of describing itself.

it provides several meta-languages that together describe themselves, and thereby also XMF.


Once maintenance is viewed as a service, we can leverage from the vast theory proposed to study queue systems in order to model and evaluate software maintenance processes.

in this article we present a quantitative approach that adapts to software maintenance a methodology originally proposed to characterize the workload of e-commerce services [9].


Consequently, input processes can skip part of cache invalidation operations.

if the sent_packet_size equals to max packet size, ADB-MAC can skip cache invalidation for the entire buffer.


The unique characteristics of this emerging application domain have led to a signi.cantly different design from the popular MapReducestyle batch data processing.

we advocate a powerful new abstraction called resilient substitution that caters to the speci.c needs in this new computation model to handle failure recovery and dynamic recon.guration in response to load changes.


Furthermore, checks never need be inserted for immutable classes, nor for classes reached only via immutable references.

(the more instances of readonlyin the program, the less the overhead of run-time checking, if any, will be.)


Since we do not use subtyping, it is possible to improve support for typeinference in our source language.

we currently require a type annotation for let expressions,but it should be possible to make that annotation optional,bybuilding onexistingwork for the GHC Haskell compiler [33, 41].


With a small tile size, the sequence of accessed memory banks in each tile will not affect the scheduling decision much since these bank accesses can be considered concurrent .

as long as two tiles have the same memory bank to be accessed, scheduling these two tiles at the same logical time slot will hurt BLP since we have multiple accesses to the same memory bank around the same time.


For example, suppose that we start from all the facts that have been described in Section 5.1.

dLV has req(robustness), req(small), char(persistent),etc.


The Learner can improve its predictive capabilities by using (13) the results of this validation.

if the Learner recovers TLs incorrectly, then it can be retrained on these negative examples to improve its performance.


To manipulate the interrupt level properly, operating system code typically follows a strict discipline.

a procedure should save the original interrupt level in a variable, say flag,(represented as save(flag)) before changing it (represented as change()) and should restore the interrupt level from flag (represented as restore(flag)) before terminating.


However, in HIS, the minimum size of system that needs to be built before a verifiably (and certifiably) safe design has been reached may be very large.

a substantial number of increments must take place before any useful feedback can be acquired and passed back to the customer.


This shows how data groups enable information hiding in assignable clauses.

the assignable clause of Point2 s move method no longer needs to expose the hidden .elds _oldX and _oldY, which was noted as illegal in Fig.


CALCULATION OF AVERAGE DETECTION TIME A.1 Average Detection Time with Constant Vehicle Speed We assume that a vehicle has a constant speed v (v = vm where vm is a maximum vehicle speed) and it enters the road on the basis of the uniform distribution for its arrival time within each period consisting of working period (W) and sleeping period (I), which is W +I.

we focus on the average detection time for a vehicle with uniform-distributed arrival time.


Therefore it is assumed that any subset of children of the element book can be deleted.

the children elements are tagged as potentially deleted.


Given a class c and a set of observer-method calls OB = {ob1 , ob2 ,..., obn} of c, the observer abstraction technique constructs an abstraction of c with respect to OB.

a concrete state cs is mapped to an abstract state as de.ned by n values OBR = {obr1 , obr2 ,..., obrn}, where each value obri represents the return value of method call obi invoked on cs.


Host-language processing, which comprises methods to process host-language code.

languageLib requires methods for processing a module declaration, import statements, and a module s body.


CALM calls the set of possible types which fall into these minimum/maximum constraints the type-spectrum of the scenario.

type checking of the assembly not only tells the developer about the compatibility of component/connector connections, it also indicates whether additional connections are possible/required.


The basic version of the scheduler always sends the .rst ready rule operation, according to the preferred order (we discuss how this order is derived in the next section).

each time the Queue Manager informs the Preferred order scheduler that (some) switches are ready, the scheduler goes through the sub-updates in the current order, inspects each sub-update and sends out any ready rule operations.


The language for tuple template is as follows: C ::= $ALL | $NONE | cname | C , C | %(1) C ; C | $not C | D | { [ iname { , , iname } ] } |C ( D ) | ( C ) D ::= F | $exists F | %(2) $all F | M F ::= R in C | R : I | %(3) R : I | R : Msymb N |R : = string | R M ::= # R Msymb N %(4) R ::= rname | rname / vname %(5) Msymb ::= > | < | = | = | = %(6) By exploiting such a grammar it is possible to express any SHOIN(D) DL description with the possibility to insert variables to specify which kinds of individuals one wants to obtain.

figure 1 shows the mapping between the main constructs of SHOIN(D) DL and the constructs introduced by our grammar.


Only constraints that involve preceding and succeeding methods identified during the first step are selected.

if component methods m1 and m2 appear in UML sequence diagrams, then constraints (m1,m2, p) and (m2, m1, p ) are selected.


Introduction Writing correct concurrent programs is hard, because inconsistent results may be computed when two threads access shared data concurrently.

a data race is said to occur when two threads concurrently access some data, where one of these accesses is a write, and where no synchronization exists between the * This work has been supported in part by the Defense Advanced Research Projects Agency (DARPA) under contract No.


It is important to note that it is possible to generate partial statechart models from partially re.ned models, as described in the following subsection.

it is not necessary to de.ne the behavioral re.nement of the entire model in order to visualize the resulting statechart, which is consonant with the Twin Peaks notion of iteratively and incrementally re.ning requirements and architecture [14].


The notation: Exps ::= ... | proceed-exp rede.nes Exps within the aspect extension syntax only, without propagating the change to the syntax of MyBase expressions.

proceed-exp expressions are valid only within a His-Ext1 advice-body expression.


Note that this .rst-order representation for pure untyped Aexpressions still retains some aspects of higher-order abstract syntax.

the LAM constructor takes a term of some universally quanti.ed type.


Speci.cationbased test generation improves the pitfalls of random testing by generating inputs that are guaranteed to satisfy certain well-formedness speci.cations [7, 9, 4, 11].

there are test input generators that take as input a grammar (written, e.g., in yacc) describing valid inputs and generates test cases that satisfy the grammar [7, 15, 13].


qi is the number of parallel threads after a task is processed by Algorithm 1.

at any point of time t, ti stretch * will have at most qi concurrent running threads on m cores.


At the transmitter, a turbo code word is .rst fed to a bit-wise interleaver, and then transmitted across multiple fading blocks with coherence time T. The length-L interleaved codeword v is divided into several length-n vectors, and used to label the transmitted USTM signal matrices.

a turbo codeword is transmitted across multiple coherence intervals.


Note that the analysis works with a representation that maintains more information than the generated scopes.

the escape information enables the analysis to recognize (and eliminate) any accesses to captured nodes.


In a pointcut-advice model, each join point is selected and advised individually and independently.

the relationships between join points are not taken into account in join point selection and advice, except in limited prede.ned ways, such as the c.ow pointcut in AspectJ.


The end results of using this testing framework have been deployed in real consumer products such as cell phones and camcorders that are being sold worldwide.

in the next section we describe the software testing framework.


In order to be applicable to the purpose of each system designer in a dynamic business environment, public knowledge base stores the mapping results even if they are not guaranteed in all systems consistently.

from the viewpoint of a certain system designer, the message format of his system has the relation to the message format of another system.


Metamodel for template concepts 4.1 Template Concepts Conceptually, a template de.nes an artefact that provides built-in support for variability.

the template can be instantiated to produce different variants.


Duetothelimitedrange ofits wireless communication, every PDA-equipped automobile depends on information received from other vehicles moving ahead which are yet found within range.

a vehicle receives from anyone moving ahead estimations on how fast thetransmittercanreach speci.c regionsoftheroad network and what the transmitting vehicle experienced in its most recent movement.


By applying the idea of the virtual blocking time in Algorithm OSS, the enhanced algorithm, denoted as Algorithm VOSS, performs on-line simulated scheduling at time instant t by taking ri,t +Zi as the arrival time of the next arrival job of task ti, where ri,t is the arrival time of the next job of ti arrived after time instant t and Zi is no more than the virtual blocking time in Algorithm V-RM.

the .rst step in Algorithm 1 is revised to lm ri,t .


The deterministic nature of zzuf allows FuzzSim to triage bugs after completing all fuzz runs .rst.

fuzzSim does not compute bug identi.ers during fuzzing and instead re-derives them using the log.


pj pj If the bucket contains = 2 logN(i) = 2 logn coordinates, then coordinate y incurs a violation with pj logn probability = q 2 .

(a violation may happens when at most all the O(log n) coordinates of the elements in bucket j are >y1, that is, when yj * >y1.)


These two values represent the truth of direct and indirect occurrence of DDR respectively.

dDR can probably or possibly take place.


The approach seems very natural, but the key question is whetherit will work correctly.

are we guaranteed to have the sameresult as we would have gotten had we implemented a native XMLdata-exchange system?


Suppose now that I. is split into two sub-nodes: I.a and I.b .

we call this split satisfactory if all of the following three conditions are satis.ed after the split: No dependency goes from any I., .GI to I.b .all the original in-coming dependencies of I. are directed to I.a .


3.1 Dynamic Pro.le Generation In this phase, we instrument runtime executions of the binary executable under analysis to capture a sequence of system-level actions for dynamic loading of components.

we collect three types of information during the instrumented program execution: system calls invoked for dynamic loading, image loading, and process and thread identi.ers.


Third enables accuracy that is between that of best and first/random.

third is able to select an interval that is more representative of the steady state of the phase than first and random.


As can be seen from the top .gure, the results are similar to the single node results of Figure 1.

eMSO-GD slightly improves SGD while EMSO-CD is resilient to increase the mini-batch size.


Deny elements promise that if an execution reaches a certain state, or changes state in a certain way, or accesses some program entity, then the code must satisfy some given properties.

rely policies are about suf.cient conditions, while deny policies are about necessary conditions.


OBJECTIVES 2.1 General Objective The general objective of this research is to develop a framework integrating cellular networks and cloud computing in support of real-time road traffic data collection and management activity of road safety organizations.

2.2 Specific Objectives this study aims to accomplish the following tasks.


JML syntax is intentionally similar to that of Java so that it is less intimidating for developers.

the mathematical types that are heavily used in other model based speci.cation languages (sets, sequences, relations and functions) are provided in JML as classes, and the operations on those types are speci.ed (in JML) and implemented as Java methods.


We realized that end users, even when they do not have technical competences, might profit from packaging such components by themselves.

we identified the need for a further level of flexibility to be offered to end users to transform raw data extracted from remote data sources into components that are really meaningful to them.


Finally, in Section 4.4 we explore how functional dependency information associated to particular tables can carry over from the argument tables to the result tables of table operations.

we will show that the functional dependencies of the result tables of projections and joins can be computed at the typelevel from the functional dependencies on their arguments.


One of the reasons is that current virtual memory mechanisms place a high premium on thrashing avoidance .

we want a good replacement algorithm to avoid its worst-case behavior and not cause system thrashing for common memory access patterns.


It seems that acquisition can co-exist with concurrency without any more than the normal di.culties associated with concurrent programs.

if one thread changes the object containment graph while another is traversing that graph to look up an acquired .eld value, the results are unde.ned.


The results in Figure 1 indicate that the savings achieved by reusing the memory space that hold dead elements are not suf.cient in most of the cases.

we need a more powerful scheme, a scheme that can reduce memory requirements below what is demanded by live data elements.


However, if we look at the worst case for unroll factor 4 and compare it to the best case for the other unroll factors we .nd a ratio of no more than 1.0065.

if we chose factor 4 as the best factor, we could be fairly con.dent that if we are wrong it would be by not much more than 0.65%.


Each of our iterators will then be de.ned using a relational calculus query.

we can de.ne iterators by selecting elements in a relation through a logical language that supports universal and existential quanti.ers.


We, therefore separately analyze contributions made to the project source code repository according to the type of artifact contributed.

we differentiate between source code, project documentation, project build scripts, translations, and other artifacts.


The heart of the event delivery challenge is the ability to deliver current events from many sources to meet the growing speci.cation sophistication of an increasing number of clients.


[32] found that the addition of kind polymorphism to the FLINT/ML compiler allowed it to be fully re.exive.

they were able to extend their typeanalyzing operations so that they are applicable to the type of any runtime value in the language.


In general, they use a broader set of applications, a difference that derives from the subjects studied.

we select applications likely to produce interesting I/O behavior; many of the programs they use, like the video game Quake, are more likely to exercise threading than the .le system.


We assume that type checking has already been carried out for the underlying standard types of the language, and that these types are given to us.


Moreover, we expect that the amount of importance related to the information included in the DDRD depends on the DDRD UC.

we expect that different DDRD UC(s) require different categories of DDRD information.


If that is not the case, the signal could be generated by a blocking-time timer.

in fact, if the active priority for the 5 when using a Pentium processor, a timer in MaRTE OS is implemented using the time-stamp counter.


3.2 Language Design Moving from hardware-oriented issues, let us now discuss the design and organization of the RCXLisp language itself.

rCXLisp lets one remotely control the RCX from a Common Lisp program running on a desktop computer,  write RCXLisp programs to run on the RCX,  create and compile RCXLisp programs for downloading to RCXs on the fly, from within Common Lisp desktop environments,  simultaneously control more than one RCX from a single MindStorms infrared transceiver tower  set up a network of RCX units that can communicate with each other in a targeted manner (as opposed to the broadcast manner supported by LEGO s kit).


For the optimizing con.gurations, localOpt and localOpt with inlining consume far more energy than localBaseline except for compress.

the cost of locally optimizing and inlining code is so great that for most benchmarks it overwhelms the bene.t of optimizing the code.


There is a (ef.ciently) computable isomorphism between a program and its graph that enables us to treat programs and graphs as a single object.

by changing the graph of a program, our normalization algorithm effectively restructures the program itself.


This appeared to be because she misunderstood the operation of the push-to-talk button, and rather treated it as a click-and-go button.

instead or pressing the button, holding it while speaking and then releasing it, she pressed and released and then spoke.


For Perlbmk, Twolf, Bzip2, and Eon, the initial prediction with retranslation threshold of 100 or higher is more accurate than the training input.

the initial prediction for Perlbmk is significantly better than the training input.


Figure 5 shows the PCM write traffic when the baseline replacement policy is changed to RRIP.

the figure shows the write traffic of LDFRRIP relative to RRIP.


we expect that many results that hold for constructor sharing CSRS s also extend to unions of composable CSRS s which, additionally, may share de.ned function symbols provided they then share all their de.ning rules, too (cf.


This property enables us to apply appropriate narrowing strategies for unconditional TRSs to evaluate such programs.

both the non-strict evaluation strategies weakly needed and parallel narrowing can be applied to the transformed programs.


5 Related work Recon.gurable distributed object systems [21] [1] [4] and other component-based systems [16] [24] are restricted by closed implementations.

these systems encapsulate a single .xed recon.guration algorithm.


While this is a fairly simple policy, it is still not easy to determine whether the current policy is safe (i.e., prevents a subject from obtaining an unauthorized right).

the web server (httpd_t) and administrator (admin_t) read and write data from a variety of less trusted subjects, such as the user (users_t) and user scripts (user_script_t).


It turns out the vast majority of the time is in the type-checker each call to the type-checker takes a few milliseconds (but much longer for a large .le without the optimization described below).

sEMINAL s algorithms are not the bottleneck, but calling the type-checker too many times is.


Yet Freese, Rivas, and Hargittai do not attribute this all to age, as they found that for older adults cognitive resources may be presently more strongly associated than socioeconomic factors with finding Internet use enjoyable or rewarding [2006 p. 244].

they found correlations between usage and education but, when they analyzed the data, they propose that education is just reflecting other antecedents such as cognitive ability and consequences like occupation for older adults; therefore, age alone is not as great an issue [Freese et al.


GHC reports: mdef.hs:3: Couldn t match Char against Bool Expected type: Char Inferred type: Bool In the definition of f : f x y z = if z then x else y What s confusing here is that GHC combines type information from a number of clauses in a non-obvious way.

in a more complex program, it may not be clear at all where the Char and Bool types it complains about come from.


In fact, by invoking observers after a pop() operation we would discover a part of the hidden state of the component, which is different for the two objects.

pop() is a discriminating operation for the state denoted by {size() = 2, top() = a, isEmpty() = false}; that is, after the application of pop() it is possible to verify if two objects that previously exposed the same observer return values are indeed behaviorally equivalent.


The second, called µLP , further restricts the .rst-order quanti.cation in µLA by stating that only quanti.ed objects that are still present in the current domain remain of interest as we move from one state to the next.

knowledge of objects is preserved only if they are continuously present.


First, our current tool uses of.ine dynamic analysis, which makes the tool often not scalable for large programs.


Our solution to the entailment problem is via a reduction to the uni.cation problem.

we are able to determine whether two Fµ types are uni.able in time O(nlogn).


A .x to the error is to convert the else if in Figure 7 to an if.

whenever the length check succeeds, the control should return.


Therefore, if we only take into account the two aspects of energy consumption and response time replacing a 2.5. disk with multiples of smaller disks may be said to be feasible.

eight ST1.3s and Microdrive 3K8s saved energy by 43% and 45%.


However, using the dictionary as a cache and placing aberrant values in a secondary hash increases the opportunities signi.cantly, and so value set caching saves more memory.

pseudojbb can compress the heap by 14% with value-set caching.


We de.ne bx to be of size 2n, where the .rst n variables determine whether a statement will be computed on the CPU and the last n variables determine whether a state ment will be computed on the GPU.

bx = [x1 x2 ... x2n] , and exactly one of xi and xi+n is 1, where bbeq bxc 1=i=n.


And it must say how the system is to be constructed [Ros77b].

requirements engineering must address the contextual goals why a software is needed, the functionalities the software has to accomplish to achieve those goals, and the constraints restricting how the software accomplishing those functions is to be designed and implemented.


Erlang QuickCheck is the tool of choice for our property-base testing framework.

we utilise its support for abstract state machines through the eqc statem behaviour.


If the requests in the DRAM controller buffers (which we call DRAM request buffers) are not to different banks, the amount of BLP achieved will be very low, thereby reducing the effectiveness of such techniques.

while a carefully-selected tile size can improve cache performance, its impact on bank-level parallelism is not clear.


If average slack size is too small and, thus, overhead of writing data to scattered slacks is too high, the SSR scheme may not be a good choice except when .le system utilization is very high.

when slack space is highly fragmented and the size of each slack is too small, cleaning would be more e.cient than Slack Space Recycling.


In contrast to polling-based approaches, we do not measure any load in order to draw conclusions about future utilization.Instead,weusethe currentprocessorutilizationbased on the existence or non-existence of load.

the processor is either in status Idle or Load.


When angelic choices are independent we get the bene.t that choose expressions can be re.ned independently of each other.

the implementation need not consider how the other choices are determinized, as the next example illustrates.


An important observation is that both of these techniques are equally powerful and can be used alone (without the other).

if desired, one can eliminate all cycles using node splitting only or node merging only.


Con- versely, a file might contain enormous chunks.

the Rabin fingerprint has the property that a long extent of zeros will never contain a breakpoint.


To simplify the tracking of dependencies and the analysis of how strata can be combined to create a system, we have restricted the concept to being non-hierarchical.

a stratum cannot contain another stratum.


In an interleaved execution, a sequence of calls to Atomic.assert(obj,pred) indicates that there must exist some serial execution a linearization of the interleaved execution in which each corresponding call Atomic.assert(obj ,pred) is such that pred.apply(obj,obj ) returns true.

suppose the n th call to Atomic.assert(obj,pred) in an interleaved execution records the serialized value of object obj.


Consequently, we agree with Ole Lehrmann Madsen s view [21] that the next important OOPL will bring classes and prototypes together.

we know some of its characteristics but lack a concrete example.


Instead, we convert the time ratio into the data ratio.

we assume it is proportional to ratio of the footprint of loop i to a fraction of the shared cache size.


We opt for a default semantics regarding pointcuts and advices that favors stability.

by default, we consider both pointcut and advice execution as higher-level computation, invisible to aspects.


SYSTEM ARCHITECTURE The design philosophy and the envisioned use of the system contributed to our decision to implement our prototype as a peerto-peer system.

the high administrative cost of centralized shared workspace systems was a major factor in this decision.


The source of the problem is that, in ML, the type of a function argument is monomorphic: it is a type ct, not a type scheme cs.

the activation clock of the process q cannot be universally quanti.ed, as it is for most processes declared at toplevel.


Hence, the veri.cation of large and data-intensive synchronous programs requires further techniques.

interactive proof steps like abstractions or other kinds of proof goal reductions are required to develop compositional veri.cation techniques for synchronous programs.


We prove in the following that this protocol is self-stabilizing for specME under the unfair distributed daemon and exhibits the optimal convergence time under the synchronous one.

we will prove that this protocol is sdspeculatively stabilizing for specME.


We want to classify every node in V with a boolean value 0 or 1.


The body is composed using computations that merely represent aliases (using a mutable variable internally).

both of the alternatives combined using .


However, the semantics of MABLE are given in terms of a belief-desireintention (BDI) logic called LORA [22].

the effects of MABLE program constructs are de.ned with respect to the mental states of the agents that perform these actions.


A summary of the results is shown in Table 2. phPay: In a .rst step, we considered an access to the database as critical when it can modify the stored data.

we calculated the sensitive path coverage under the assumption that all SQL insert, update,and delete operations are sensitive.


We used Soot version 2.2.4 for the analysis and transformation.

the SPARK [20] .ow-insensitive, context-insensitive, and .eld-sensitive may points-to analysis was used.


However, even if further inlining takes place, this does not always mean that a size reduction is warranted for.

non-virtual calls never require a guard to inline.


All edges between an edge and its lock placement share the same placement.

.x any edge uv and take any edge xy in a path in the decomposition from .


Java 2000 San Francisco CA USA Copyright ACM 2000 1-58113-288-3/00/'6...$5.00 between two equivalent download sites must assume that the conditions that have been observed will persist until the download is complete.

the user uses the current conditions as a prediction of what the conditions will be a short time into the future.


Also, no name is assigned twice in the same substitution.

an explicit substitution is a function from the set of names to the set of terms T : N .Terms We treat the substitutions in our calculus as providing assignments for all the names; some names are assigned speci.c terms, and some names are simply unchanged by the substitution.


The main result of this paper is stated in the following theorem (Theorem 3.1) and improves the result of Sipser and Spielman [26] (see Section 3.1 for discussion).

we show that expansion parameter 23 is su.cient for lineartime decoding.


4.1.2 A Greedy Algorithm The main idea of the greedy algorithm is to divide the memoryinto small units d andincrementally allocate d amount of memory to the process which can bene.t the most from this memory at each step.

the process that receives this d memory is the one with the highest gradient of the utility function at its current memory allocation.


Discussion We are ready to draw some conclusions from the examples of the previous sections.

we identify the particular strengths of type classes, when compared to basic or advanced OO expressiveness.


As future work, we plan to consider language extensions that could simplify the de.nition of specializable operations.

abstraction over type classes (similar to the proposal by Hughes [17] that was used by L ¨and Peyton ammel Jones [23]) could help eliminate the boilerplate of reifying type classes as explicit dictionaries.


To properly analyze the results of these large sets of experiments, we followed the guidelines in [1].

we used the Wilcoxon Mann-Whitney U-test (at a = 0.05 signi.cance level) and the Vargha-Delaney A 12 standarized effect size.


By modeling local dependences in natural images using the di.erences Ii,j+1 - Ii,j , our model assumes that the differences Ii,j+1 - Ii,j are independent of Ii,j .


At meet points in the control .ow, and if the analysis is in non-abstraction mode, the path formulas of the two branches are combined via disjunction (resulting in a disjunctive path formula).

as long as the analysis operates in non-abstraction mode, a disjunctive path formula is constructed that represents all program operations since the last abstraction formula was computed in abstraction mode.


This owner-as-modi.er discipline is enforced by disallowing modi.cations of objects through any references.

an expression of an any type may be used as receiver of .eld reads and calls to side-effect free (pure) methods, but not of .eld updates or calls to non-pure methods.


Note that these results hold for any service-time distribution with .nite mean (see Section 3.3 of [12]).

the theory holds true for the Zipf distribution, which has been shown to represent the online lifetimes of human users [13].


Note that one consequence of step (3) is that not every execution leads to the creation of events, but each registered state-machine may contribute a new event.

the event queue may grow maximal by the number of registered clients in each iteration.


This is not sufficient in our example because messages must be inserted at multiple places and an alt fragment must be added around existing base elements.

note in Figure 4(c), that the second mitigation must insert an alt fragment so that an existing message (submit) is placed inside the second operand of the fragment.


The former is a type modi.er which declares that anyinstance of the type is recursively immutable.

a value 01 public value enum bit { 02 zero, one; 03 public bit ~ this { 04 return this == zero ?


The PERC Pico verifier enforces that the body of this constructor does nothing with its implicit this argument that would violate the expectation that the constructed object may have a temporary lifetime.

the verifier forbids the constructor from saving the value of this in any static variables or in any instance fields associated with objects that cannot be proven to have a shorter lifetime than the constructed objects itself.


A local network is not necessarily connected to the Internet and might only be connected to a content server in the immediate area.

users have to be within this area to obtain the content.


At the same time, because of the research innovation mode, both the available content like postprocessed assets from Navteq data and the client requirements keep on changing.

such a program mode implies a need for a very pragmatic approach for architecting the service platform.


The quality of the test sets for the programming tasks mostly determines the quality of the challenge itself.

weak tests allow a number of incorrect solutions to pass the tests, so skilled participants who are trained to invent correct solutions are given less chance to win than unskilled ones who write incorrect solutions in the hope it will be accepted.


That is, the attacker wants to reduce or boost the reputation of the objects in St.  Related Object Set, denoted by Sr, contains the objects that have positive correlation with at least one object in St.

turning an object in Sr into a trap will help to attack the objects in St.


If vj ./RetPt,the Propagate function is called, which simply pushes triples backwards through all predecessors of vj , identifying new correct transitions and new triples.

for each predecessor vi of vj ,if (.g,.i) .PE(vi)and .j .d(vi)(.i), then the transition (vi,.i) r (vj,.j ) is added to T and a new triple (vi,.g,.i) is added to W. T and W are accumulated in M and WL1, respectively.


Fact 1 follows directly from the fact that transitions are deterministic, processes cannot access the local state of another process, arguments to both methods are the same, and the starting global states are the same.

from Fact 1 and hs(pbase1 ), hs(pbase2 ) being complete sequential histories, we can show that Glast(pbase1 ) = Glast(pbase2 ).from first(pbase1 )= first(pbase2 ) (both are initial states), we can inductively show that any complete sequential invocation preserves the fact that the global state in the last states of the two executions are the same.


(Still those numbers vary from experiment to experiment, due to different network load and different machine load.)

the Erlang runtime system implementation behave differently in a local setting as compared to in a distributed setting.


On the other hands, if the instrumented target is optimized, there is no context-switch overhead though the optimization incurs extra computation during translation.

to benefit from the optimization, it requires the conclusion that the overhead of the optimization is less than that of maintaining hardware context.


Many stages implement high-level optimizations.

optimizations that are hardware independent, such as source-to-source [27] transformations or data .ow reductions[29].


However, in order to demonstrate the validity of the approach, we have to make additional experiments.

we are developing a prototype for MzScheme.


4.3 Hardware-based Implementation To implement our hardware-assisted prototype, we used a cycleaccurate simulation approach, which is nearly ubiquitously used in computer architecture research.

we extended SESC [17], an open-source simulator that models the complete execution of code through a modern processor and memory system.


All these considerations and the work reviewed here motivated us to look into this problem of what is a good strategyto do integration testing of classes and aspects in the context of a software development process.

weare interested in the order of integration of classes and aspects aiming at minimizing the need to create stubs in theline of the works of Briand et al.


We conclude that the evaluation model embodied in the CLS machine is a call-by-value interpreter threading a stack of environments and a stack of intermediate results with a caller-save strategy (witness the duplication of environments on the stack in the meaning of applications) and with a left-to-right evaluation of sub-terms.

the meaning of a term is a partial endofunction over a stack of environments and a stack of intermediate results.


Drivers are used to execute the various components.

we focused on performing augmentation 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.


The inner loop, on the other hand, iterates over the current page using the translation in TRj (for U1).

during the execution of the inner loop, the accesses to array U1 do not lookup dTLB.


Then we generate two variables that do not appear in the obtained con.guration and add two new columns consisting of these variables and the successor states of the a-labeled transitions.

the contents of the two new columns in the .rst row of C2 arises from the transition s1 .


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.

if we ever revisit a point pj, then the next point must be pj+1.Consequently, P will end in an in.nite repeating subsequence .pj,pj+1,...,pk-1,pj,.....


The translation of loops needs additional code.

it is necessary to use promela goto to implement break and continue C statements.


Generalized Visit Order  3.3 Generalizing the Tree Navigation Hot spot #3 requires making the navigation of the tree structure a feature that can be customized to meet the needs of a specific application.

it should enable variability in the order that nodes are accessed.


6.1 Static Typing Where Possible, Dynamic Typing Where Needed The arti.cial separation between the supporters of dynamically and statically typed languages is rather unfortunate [71].

dynamically typed languages miss a great chance to leverage static information about programs that the compiler and tools can leverage.


Conclusion In this paper, we consider the problem of instrumenting programs to reproduce bugs effectively, while keeping user data private.

we focus on the tradeoff between the instrumentation overhead experienced by the user and the time it takes the developer to reproduce a bug in the program.


We assume that the way of providing the domain knowledge and its tools should be changed by the stakeholder s preference and their situation [4].

our research aims to provide the suitable knowledge e.ciently for each stakeholder.


Thus, our techniques provide practical interpolating decision procedures whenever such reductions exist.

we get practical interpolating decision procedures for the quanti.er-free theories of arrays, sets, and multisets.


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 compilers commercially available on the Itanium architecture.

the sketch expressed optimization ideas which the compiler was unable to discover on its own.


The response time of performing Reply Reply Unsafe Reply Unsafe Reply Unsafe Reply  (a) Existing replication strategies Sync Pipelined Sync Async Figure 3: Relationship between application views under different replication algorithms.

sV and CV relations de.ne the RPO guarantees upon disaster.


Also, most infections are from a very small number of distinct malware.

in Limewire, the top three most prevalent malware account for 99% of all the malicious responses.


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.

the i-th entry of the counter array is to keep the number of IPCs whose value is i in the corresponding block region.


should be used to represent various types of context information.

a way of revealing situations will be investigated, as situations are expressed using predicate logic which is not easy for the end user to understand.


DISCUSSION In this section, we discuss some of the questions raised by this study.

we discuss the robustness and the limitations of this study as well as provide some intuitive explanations for some of the observed effects.


In both cases, a logic and its encoding must be sound in order for the resulting language to be type-safe.

when a certain condition needs to hold in order for evaluation to proceed (such as, for example, 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 object supplied by the program entails the required condition.


The Mediator knows about the objects involved and links to the appropriate noti.cations, the objects simply provide their services without being aware of the Mediator or the other objects.

the objects do not even know that they are collaborating.


If this result is a reference Ref to an exported 4 remote object in the card, then the terminal may invoke a method m of this object by a new INVOKE command.

any object whose reference has been returned to the terminal may be used for remote invocation, as soon as it has been exported.


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 considered unsuitable for hard real-time systems.

the presence of garbage collection has been a sore point for their acceptance for low-level system programming tasks.


In order to diagnose ' the value of a variable v using the value of another variable v, v must depend on v'.

there must exist a function F ' that connects the value of v with the value of v'; i.e., v = F (v).


In contrast to the .rst step, we now consider adaptive JIT compilation, i.e., the JIT compiler optimizes the most frequently executed methods at run time, and we consider heap sizes that introduce GC activity in order to achieve representative performance numbers.

compilation and optimization time as well as GC time become part of the overall execution time.


We augment our notion of a well-formed class table to require that the subtyping and exclusion relations it induces respect each other.

for all well-formed constructed types M and N, if M .


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.

predicate nodes representing pTand pFare also created, if d reaches u if d is a predicate-covering prethey do not already exist.


However, it took us several monthes and many endeavors to reach that simplicity.

the .rst version of the IDL was much richer and it was then dif.cult to describe harmoniously Scheme codes coming from different systems.


Hence, the decision between the di.erent governors from a pure energy perspective in scenario B depends on power characteristics of the machine and the load if applicable.

the powersave governor is not always the most energy e.cient choice.


In our case, the candidates are the holes, and the voters are either the di.erent scoring functions or the problem dimensions.

we focus on the rankings induced by the problem dimensions.


This model is not economically suitable when the contractor s intellectual property forms a significant part of the product.

if the product is a member of an SPL, the benefits derived from reuse should accrue, not only to the customer, but also to the contractor.


Here we want to establish p(x) from the user viewing behavior logs.

p(x) is represented as a function of Pp(x) and Ps(x).


Modern organization models entail distributed and heterogeneous actors and resources, which need to cooperate and coordinate to achieve their business goals.

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.


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.

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.


compiler: Contains classes that realize the processing explained in Section 2.

the compiler contains code to build and execute the user-de.ned parsers and desugarings.


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.

the errors detected do not correspond to failures, since the behavior that would be expected if the substitution principle was applied is not speci.ed.


Because XY and YZ are parts of several hierarchies, overriders 4 and 5 re.ne several basemethods.

4 is an overrider for 1 and 2, while 5 is an overrider for 2 and 3.


Since the Java compiler is oblivious to the special semantics of the dummy invocations, it is unable to perform proper control .ow analysis during the initial compilation, which may lead to unexpected results.

compilers may optimize or otherwise generate code that violates the stack-neutrality property of statements (see Section 3.3), which can result in invalid programs after inserting new jump instructions.


While natural languages themselves are not appropriate for programming, they contain a number of elements that make descriptions concise, effective and understandable.

natural languages referentiality is a key factor in supporting powerful program organizations that can be easier understood by humans.


Therefore, pro.ling based loop dependence analysis is used for this work.

the frequencies of cross-iteration dependences are captured during the pro.ling run.


This result clearly demonstrates the benefit of 8 We select Kryo and Java because, like scala/pickling, they both are automatic .

they require no schema or extra compilation phases, as is the case for other frameworks such as Apache Avro and Google s Protocol Buffers.


It is usually the case that classes below a certain layer do not need to be extracted and shipped because they are already available in the deployment en-vironment.

the standard class libraries are generally available and are usually excluded from the ex-traction process.


Trust management solutions serve as potential candidates for such measures.

a trust management system helps peers establish trust relationships with other peers in the system, and these relationships help a peer determine the trustworthiness of other peers in the system.


Figure 4 shows the form tree corresponding to that in Figure 2 after being pre-processed.

all the leaf textboxes under textlabels are removed.


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 program may require different set of constraints on its data that onetype system may not be able to express.

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.


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.

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.


As we have analyzed in Section 2.3 conceptually and illustrated in detail with the GIMP example in Section 3, they have to earn their status and recognition in the community gradually by making small contributions at first.

they start with peripheral participation by, for example, reporting and fixing bugs.


6.2 Object Read-Write Information We performed measurements to estimate the potential impact of our analysis on clients of object read-write information (e.g., side-e.ect analysis and def-use analysis).

we considered all expressions of the form p.f occuring in statements in reachable methods.


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.

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.


This is the .rst study of this kind, and our results reveal several interesting aspects of test-suite evolution.

our .ndings show that test repair is just one possible reason for test-suite evolution, whereas most changes involve refactorings, deletions, and additions of test cases.


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 requirements).

aHP implements a pairwise comparison iterative process in which the decision maker is required to specify a preference as an integer value pij .


weight assignments are feasible for multiprocessors.

those weight assignments in which the bandwidth assigned to a single thread exceeds the capacity of a processor are infeasible (since an individual thread cannot consume more than the bandwidth of a single processor).


In addition to the constructors shown in Figure 6, our queries also allow annotating arbitrary subtrees with integer weights.

we allow queries to contain another constructor WeightedQuery(Int *Doc), and we extend the Score function from Figure 7 as: Score(WeightedQuery(w, q),d)= w × Score(q, d).


The XML representation of these terms could be used in a web service such as the Virtual Workspace Service [18] to negotiate a lease.

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).


The tree-like organization of form elements gives rise to a hierarchical structure for modeling a form.

a form can be modeled as an ordered tree of elements called form tree which captures the semantic relationships among the real-world objects represented by the form.


It is also important to point out that proper choice of projection matrices plays a signi.cant role in this result.

matrices generated by symmetric Bernoulli distribution, which obey RIP, are able to preserve the information of x in y.


OpenCL C++ is more than some smart tricks to reduce the amount of host code.

openCL C++ addresses abstraction for GPGPU programming both on the host and also for the device itself.


; where one path leads to a state from where m is never consumed, and in the other all sent messages are consumed.

a deterministic I1 containing deterministic peers is well-formed.


CONCLUSIONS In this paper, we have elaborated on the idea of modeling and developing next generation of pervasive service framework by getting inspiration from ecological systems.

by conceiving future pervasive service frameworks as a spatial ecosystem in which services, data items, and resources are all modeled as autonomous individuals (agents) that locally act and interact according to a simple set of well-de.ned eco-laws .


We can clearly see that each of our load balancing algorithms reduce the query drop fraction, thus improving the system performance.

algorithm All, which integrates all of the other algorithms we presented earlier, experiences the best performance in terms of minimizing the query drop rate even under a highly skewed query distribution.


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).

considering S1 as the ASD being annotated and S2 the one against which S1 is compared, each element in S1 is annotated as: .


Thus the parser for b fails, and eis used.

since choices are biased, parses earlier in the input affect whether the left-hand side of a choice succeeds and thus whether the right-hand side should even be attempted.


Nl is approximately equal to `´n-k+1 a 2 .

for a =20 there exist a total of 100.000 local Pareto fronts while for a = 2 there exists merely one.


The performance of work stealing is largely dependent on the performance of its task queue implementation.

we need to ensure that each pushed task is only popped or taken once such that each task is only executed once.To achieve atomic take and popoperations, most implementations, like (Arora et al.


We propose to employ statistical methods like least recently used or least often used to decide which specializations may be displaced by new ones and when.

persistent storage is managed like a cache memory for specializations.


EXPERIMENTAL STUDY To evaluate our proposal for language-level checkpointing/replaying, we performed a variety of experiments, focusing on the e.ectiveness and e.ciency of the static analyses, and on the run-time performance of the checkpointing version and the replaying version.

our experiments consider the following research questions: How e.ective are the static analyses in reducing the number of variables that are captured/replayed?


What is the desired feature binding time?

in which program phase are the feature implementations included into the product: at design time, at compile time, at start-up time, or at runtime?


Nevertheless, this function is reasonable to accept since it ful.lls our safety conditions.

each subpart of the result correspondingto X must be identical to some subpart of the input correspondingto X.


We observe a large gap between short and long requests1.

the 95thpercentile service demand is 3.68 times the average.


Some of the issues we looked at were driven by the fact that we took a closer look at information systems and differentiated the various forms of variability that may occur there.

we looked at the individual di.culties in merging variations in user interfaces, data, business rules and processes.


the rules after a run of the same symbol has .nished, whereas SEQUITUR does this on reading every symbol.

rLESe restructures the grammar rules less frequently than SEQUITUR.


GLOBAL PAIRS We assume that global pairs are self-managed and organized.

the project manager only specifies the output expected and the time given for a task he/she does not get involved in the internals of the task execution.


SAFE ensures that the intended f-units are activated.

vi shall not be a.ected by a customization of any of its child f-units.


We believe that as leakage is becoming an important part of overall energy budget [6], the experiments with large L values will be more indicative of future trends.

the experiments with L=1 try to capture the anticipated importance of leakage energy in future.


If we are working in an imperative language and reason (perhaps 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.

many of our most important local reasoning principles remain intact in the presence of harmless advice.


The running components are glued with this object by delegating the runtime interpretation of object references and associated method invocations in the form of O.m() to the architecture object.

the references and invocations are functions over the current software architecture configuration.


In order to enable efficient and effective testing of the reusable product line components and the product line members, the product line architecture has to be designed for testability.

the architecture has to support the testing of concretely planned products in the product line.


Overview SEMINAL s error-message generation operates on untyped abstract syntax trees (ASTs).

the code we add to the compiler front-end sits between parsing (which converts a token stream to an untyped AST) and type-checking (which converts an untyped AST to a typed AST).


2.2 Idempotence Idempotence can be identi.ed through the absence of clobber antidependences, which are antidependences with no prior .ow dependence on the same variable [8].

an idempotent region can contain an antidependence as long as the antidependent variable is de.ned before it is used.


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.

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.


These observations led us to develop a code that is suitable for the test data [10].

a code yielding a good compression gain for the type of data.


We have integrated several, very different languages into FEA-TUREHOUSE almost automatically, in particular Java, C#, C, Haskell, JavaCC, and XML.

fEATUREHOUSE can be used to compose software artifacts written in these languages.


Risk -One risk of including a variation point in a product line architecture is the possibility that the variation point is never used.

an option is created but overall the products in the product line that option is never exercised.


Our scheduling algorithm exploits the temporal locality and popularity characteristics and uses the information in the history to perform predictions.

the block with a higher write frequency 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 migrated earlier in the post-copy model.


Most current practices in software design and implementation are based on a design now and fix performance later approach.

the functional design and implementation of the system are done first and the performance techniques are retrofitted at a later point in time.


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.

the type and structure of the first element of data has been preserved.


ViP currently always monitors all global variables of the program.

speci.c global variables cannot be excluded from the analysis, and speci.c variables local to, for instance, a function or process, cannot be included.


The software architecture of gVirtuS is shown in Figure 3.

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 machines residing on the guest machines.


Parallel Bindings Parallel arrays and tuples provide a fork-join patternof computation,butin some cases more .exible scheduling is desirable.

we may wish to execute some computations speculatively.


We equate expressions up to a-renaming of their polymorphic variables.

when substituting an expression e ' for a variable x in an expression e, we suppose the polymorphic type variables of e to be distinct from the monomorphic and polymorphic type variables of e ' thus avoiding unwanted captures.


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.

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.


In future work, we will extend our methodology to consider multiple distributed nodes as local optimizers (scalability to horizontal composition).

we plan to construct an interface 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.


The prover will use the speci.cation, rather than implementation, of called methods to continue symbolic execution.

frequently used library methods need to be speci.ed.


On the other hand, developers are concerned about receiving too many notifications of things that were not relevant to them.

they were concerned about not being in one s impact network and still receiving notifications.


2.1.2 Resources We abstract computational resources as ticks, which determine the granularity of availability and consumption of resources.

resources are provided to cyberorgs in terms of numbers of ticks, and computations consume resources in multiples of ticks.


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.

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.


5.3 Automated Precondition Strengthening The universal and existential generalization algorithms generalize a counterexample, but in the neighborhood of the original counterexample.

all generalizations are from the same variant as the original counterexample.


Henceforth, we will assume that each server in S offers a different service, and each request is targeted to exactly one server.


Our approach represents a signi.cant departure from traditional program analysis, where iterative re.nement techniques are the norm [2, 7, 22].

our methods exploit randomness to generate information in the form of statistical correlations.


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!


The credo to design is human is valid for all people, but as a specific activity design encompasses only experts.

design as a general activity is an aspect of human activity.


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.

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.


Aspect speci.cations have both static and dynamic elements, but the most distinctive ones are arguably in the latter category.

aspectJ provides a pattern language that predicates the execution of an aspect on the shape of the runtime stack.


In the future development of the JavaMen framework, a key requirement will be to understand the implications of hardware invocation on Java s concurrency model.

the e.ect on locking behaviour of crossing the hardware/software boundary in the same control .ow and the leveraging of parallel execution had to be considered.


Such collaborative sensemaking should take seriously the diverse perspectives and the processes of communal meaning negotiation [24].

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)?


Firstly, in VM packing phase, each sub task already assigned with resource flavor type is aggregated to the generated VM instance sequentially.

the fragmented partial instance hours is minimized since sub tasks that require same resource flavor type is aggregated to the common VM instance in VM packing phase.


Initially, the dif.culties imposed by the limitations of such devices were discussed.

the restrictions of performance and storage greatly dif.cult the use of structural testing criteria in this context.


Step 1 extracts subqueries following the innermost, leftmost-.rst dependency order of computation.

if a subquery is contained inside another subquery, then the inner one is extracted .rst; if neither of two subqueries is contained inside the other, then the left one is extracted .rst.


Besides, qualitative .ndings cannot be traced back to the structural properties of an API at the code level.

the few quantitative studies exhibit several limitations: the research questions cover DSL aspects other than API complexity from the perspective of API users.


7.1 Rapid Prototyping After the requirements for the systems became available, and developers were able to identify the various building blocks that were needed, the development of the individual building blocks was carried out from the bottom up.

developers created task-specific infotrons and composed them to build a system.


When the number of VM increases to 9, the computation time for the bruteforce algorithm rapidly increases to 32 seconds, while the computation time for the heuristic algorithm is a much more reasonable 274us.

the heuristic algorithm reduces the computation overhead up to 99%.


Unfortunately, a simple PCA-based model will not accommodate di.erent non-buggy processes that have di.erent observational behaviors.

such a model cannot take into account scaling e.ects that might change the observed behavior of a program as the system size or the data size increases.


This paper uses automatically generated tree models, such as those in Figure 10, to describe the trends in the results.

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).


Gray code The function bramah enumerates the con.gurations {A, B, C}n changing only one peg at a time.

the succession of con.gurations corresponds to a ternary Gray code!


While this supports the main features of our system, it is not optimal for several reasons.

the use of Aspect/J imposes large memory overheads, whilst its ability to track dependency information is somewhat limited (indeed, to do this effectively may require VM support).


have been implemented in Racket, so this approach makes it possible to host many more languages than Racket itself.

we are using Whalesong to host a new, non-parenthetical language called Pyret.


First, the tester drives the GPCA system to a particular state from which the validation of the requirement can start.

if state V-Init is needed so that the validation of a certain safety requirement can start, we query the UPPAAL tool to verify the property A[ ](!V-Init) against the model.


More importantly, programmers will assume there is no concurrency and deem the program to behave as expected.

programmers follow a closed world assumption: the rules for evaluating a program are exactly those of the programming language speci.cation.


1 h1 .L(H ' ), then h1 = h2 q2 h3, where h2 contains no kills and q1 =G q2.

every lock acquisition is eventually followed by a lock use ordered after it, and no kills occur in between.


the ß functions repeatedly transform the combination of keys ki to .nd an associated non-.


It allows a semi-formal modeling with the SysML language which will be extended by the Modelica in order to verify WSN properties.

we o.er the possibility to design clear models, to allow also the simulation and the virtual veri.cation of designed system properties.


On the other hand, in the case of GPU, from Table 9 through Table 11, we can see that increasing the number of SM reduces the execution time and increases the correct solution rate.

the problem of initial value dependence tends to be eliminated as the number of SM is increased for both the processing time and the correct solution rate.


To address this issue, we .rst locate all the comparisons between strings in the source code.

we locate comparisons between strings through identifying invocations of string-comparison methods provided by the supporting libraries (e.g., String.endWith() in Java, strcmp() in C).


Second, we identify a novel connection between distributed computational complexity and modal logic.

the classes VVc(1), VV(1), MV(1), SV(1), VB(1), MB(1), and SB(1) have natural characterisations using certain variants of modal logic.


The GIMP is also an image manipulation program, but with many more features than Eye-of-Gnome.

it is scriptable, and capable of many more sophisticated image transformations.


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.

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).


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 objectoriented one where it was initially conceived  that is, Agent-Oriented Software Engineering (AOSE) methodologies.

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 environment essential aspects in the engineering of complex software systems.


Instead, as an example, in a guard we replace a call to is pid with pattern matching against the new process identi.er format {pid,nodename::atom(),number::integer ()}.

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.


The goal is to provide a designated (modi.ed) library function that, when used instead of the original data structure, reduces the problem with no need for further modi.cations to the original program.

we propose a new lock-free implementation of the queue data structure that enables more scalability of the garbage collector.


This makes programming with constraints more predictable and helps to localize actual sources of nontermination (unrelated to clpfd).


There is no direct .ow of information from from u to x, but there is an implicit .ow due to the condition u > 0.

by observing x, one can deduce whether u > 0 or not.


An aspect can be the combination of a pointcut and the corresponding advice.

using pointcuts, an aspect can specify at what points in the execution or under what circumstances a particular piece of code, representedas an advice, should be called.


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.

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 advertisement and reactive resource discovery, and (3) load balancing, which facilitates resource replication, relocation, and division to achieve load balancing.


However, unlike HRDB, if the master is suspected to be faulty, another replica is selected to act as primary.

our approach leverages the fact that, for transactions executing speculatively at non-master replicas, if an operation completes in the master, it can execute in other replicas without blocking.


Several extensions and changes have been done in the internal implementation of eNANOS, especially in resource and job management.

a new scheduling policy (called BestBrokerRANK policy) and an algorithm for aggregating the resource data were implemented.


Users that created those questions receive these reputation points .

building reputation within the community is a key motivator for contributing to Stack Over.ow, and contributors reputations are quanti.ed by scores based on their answers to questions posted on Stack Over.ow.


As a result, the data sets of some areas are no longer consistent.

the updates for the same area spread over in multiple versions; no single version is complete and up-to-date.


In this paper, we describe a new approach to mobile database access that avoids the need to compromise consistency.

we show how to achieve good client performance under conditions of weak connectivity without degrading consistency.


Each thread r is initialized with the interval [r * N!/T, (r + 1) * N!/T [.

the vector-position is set to r * N!/T .


CONCLUSIONS AND FUTURE WORK In this paper we have performed a historical review on software s structure improvement through detection and correction of bad smells.

we have analysed the current situation of the research in this .eld and we have identi.ed the automation of bad smell correction activities as the next milestone to reach.


This is mainly due to the existing gap between programmers and tool/language designers.

what new language features or tools should be developed or improved with enhanced usability in order to address programmers most important needs?


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 untyped .-calculus extended with pattern matching.

clearly, e.. * e ' holds if and only if |e|evaluates to |e ' |..2,Gµ supports type-erasure semantics.


MINHA does however virtualize a signi.cant part of a modern Java platform, thus providing unprecedented support for running off-the-shelf code.

the virtualization of threading and concurrency control primitives provides additional detail when simulation concurrent code, as is usually the case of middleware components.


This calculation is invalid for enduser computers because it does not account for the CPU transmission costs.

before the command reaches the network interface, the operating system must traverse the network stack and copy data buffers along the way, which takes time.


Note that the assert subgoal when executed creates the dependencies between provable instances of each subgoal in the body of a rule with that of provable instance of the head subgoal.

it captures the dependency between the answers.


Note that all boxes stored in Tupper extend below the reference 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, beyond the left edge of Q).

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 corner of Q see Figure 5.


Siri can handle a wide range of queries, but only those that are simple and relate to a single phone functionality [6].

users cannot give complicated commands that combine different phone features.


Whilethisdesign simpli.esthesystemsoftwarearchitecture it imposes bottlenecks.

parallel I/O from the accelerator-type cores, which are typically many more than the host cores, may su.er from serialization and queuing at the host cores.


The objective of the research presented is to explore a way in which context-awareness can be facilitated in the development of such applications.

the focus is on providing a programming model, an implementation framework and a development environment.


We give a detailed account of the methodology, compare its formal expressiveness to prior art, and describe its application to an open-source Java-implementation of the SSLprotocol.

we show how one can make use of runtime 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 implementation at runtime.


We then (b) de.ned a pointcut to match and override these join points with our application code.

each candidate solution in Knapsack comprises a vector of items, values, and quantities.


n then the corresponding function symbols in the signature of context decorators have the type declarations fi: t1 × ... × nE.

nE' i for i = 1 ... k. we create a symbol fi if the type of the ith argument of f is a nonterminal.


Two policies immediately spring to mind, that we shall call ROOT and WEAK: ROOT: Treat (non-.zzled) sparks as roots for the garbage collector.

retain all such sparks and the graph they point to.


Collection of comprehensive information: Often, a software engineering technique and experience with this technique are described separately.

it is difficult to find integrated descriptions that describe both, the technique itself and whether or how it works for the practitioner in his/her context.


ing STL Multiset on RAID-5 While implementing and testing the ladder queue data structure, an issue with the original algorithm [22] arose.

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.


Ehn contrasts Wittgenstein s approach to design with that of Descartes, which is based on analysis and rationalistic reasoning .

ehn stresses two aspects related to plexicons: the importance of specialized vocabulary and its foundation in actual use.


Erosion occurs whenever an implementation decision violates one or more component dependency constraints in the specified architecture.

an erosion symptom is the violation of a constraint at the level of a component dependency.


a type variable always scopes over the typing in which it appears.


The late binding of VOs to ROs is not paid for at the source code level, because lifting of the sub components of a root ROs happens automatically as they come into the scope of a connector.

the programmer never has to explicitly call the lift function.


The layers themselves are a substitute for the subclassing contract.

they eliminate the need for library documentation to include something like the subclassing contract.


However, since AOP is a paradigm for dealing with a crosscutting concern, our model forAOP needs some predicates that deal with non-local contexts.

enabling method dispatch depending on non-local contexts is a unique featureofAOPagainstOOP.Forexample, seethe following aspect in AspectJ: aspect Logging { around(): call(void HashMap.put(..)) && 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.


We suggest an integrated approach that protects the data while providing a built-in authentication system for the involved service providers to assess the authorization decisions.

an e.ective solution can be given by a combination of Java policies for authentication, to manage the data protection using nested JARs, and map the access control rights in terms of programmable constraints.


While Figure 11 shows how our system can effectively insert and remove instrumentations without incurring any performance penalties after class rede.nition, Figure 12 shows that steady-state performance is comparable to a setting where an aspect is woven at load time with the standard AspectJ weaver on the standard Java Hot-SpotTM Server VM 1.6.0 23.

we show values for the execution of the benchmarks without any instrumentation, and for the three combinations of pro.ling features (represented by three different aspects) described before.


While run-time analyzers can be implemented relatively ef.ciently, the signi.cance of their results depends crucially on the coverage o.ered by the executions that were fed into the analyzer.

the more possible executions remain unexplored, the less signi.cant is the analysis result.


This work revealed a number of weaknesses in existing HPC systems that could be dramatically improved by technologies included in the Hobbes design.

this type of application requires, at a minimum, portable mechanisms for inter/intra-enclave communication and coordinated scheduling.


Iteration space is the main focus in all these prior techniques.

data locality has been improved by modifying (restructuring) the loop access pattern.


For the particular case of real-time systems, models for the development of parallel software must be able to be shown correct in both functional and non-functional properties at design-time.

issues such as concurrency, timing behaviour and interaction with the environment need to be addressed with the same caution as for the functional requirements.


By analogy with real data types, we impose the restrictions that there are only a .nite number of constructor names, and for any given constructor the length of the associated list is .xed.

the .nite list of constructors will contain "Nil" (of arity 0) and "Cons" (of arity 2), with which we can model the lists of the previous section.


We shall introduce further features relating to join points and advice as we discuss speci.c benchmarks later on in this paper.

we shall examine different placements of advice (after and around) in addition to before.


even if o is accessed by threads in disjoint time intervals, it still escapes.


This further implies that, when analysis is applied to models derived from designs or implementations of actual software systems, a model of the system as built is unlikely to be suitable for automated analysis.

compositional, hierarchical analysis (where state-space explosion is avoided by simplifying models of subsystems at several levels of abstraction) depend on the modular structure of the model to be analyzed.


Upcoming Research Activities I aim at improving Umple and making it available for students and professionals.

we intend to implement and support arbitrarily deep nested and concurrent states and timed transitions.


Specifically, we use the core-periphery distinction as our measure of reputation.

developers in the core have a better reputation than those in the periphery.


In this paper, we proposed a statistical approach to the problem of optimal task assignment.

we showed that running a sample of several hundred or several thousand random task assignments is enough to capture at least one out of 1% of the bestperforming assignments with a very high probability.


Authorization constraints, such as SOD, cardinality, and prerequisite role constraints [1, 4] are an important aspect of RBAC.

sOD is a fundamental principle in security systems and is typically considered as a requirement that operations are divided among two or more persons so that no single individual can compromise the security.


Although they provide important insights on the problem of manual model comparison, not every single design decision can be motivated by them.

when developing our tool we also included results from the more .ne-grained network of categories and their descriptions.


Its parameters are a closure f and a value arg; its task is to simulate the application of the source function encoded by f to the source value encoded by arg, and to return its result.

if [eDdenotes the image of the source expression e through defunctionalization, we intend to de.ne [e1 e2Das apply [e1D[e2D.


Cassandra makes use of a data model similar to that described in the work on Google s Bigtable [2].

cassandra provides modeling concepts similar to Bigtable s rows, columns, and column families.


SAs, SONs and BFs affecting either the checker input nodes (Xi,1i) or the transistors they drive), to satisfy the TSC property the checker requires the application of only two two-railed input words, out of all the possible 2n.

such input code words must ensure that each (Xi,1i) couple (i= 1,...,n) assumes both (10) and (01) logic values.


[10], such design of H makes it very di.erent from a monolithic random oracle, even if the compression function f is modeled as a .xed-length random oracle.

the extension attack here is as follows: given y = H(M) for any unknown value M, one can easily compute the value y ' = H(M, M ' )= Cascade(M ' , f, y), for any su.x M ' .


Each branch resulting from such a choice must be guarded with an inlet.

the choice to follow a particular branch is made by sending an appropriate message.


we put almost no effort to tune the fusion algorithm against the compiler and the language.


Importantly, this de.nition only demands the reuse of the base language s implementation but does not regulate how language extensions are implemented.

this de.nition does not prescribe whether multiple language extensions can be used jointly.


For instance, we could use some kind of symbol versioning: use completely different symbols any time we would previously rede.ne things, mark old symbols as obsolete and never reuse them.

add a monotonicity (purity) constraint to our bindings and achieve guaranteed static calls through manual alpha-conversion.


Hence, if the same token net (name) appears in di.erent places of the net, they point to the same object net instance.

the marking of each ob ject net instance is applicable for all tokens referring to it.


We compute Ci and ßi in the reverse order.

.rst compute CN, ßN, then CN-1 , ßN-1, .


While Reverb attempts to use a developerprovided change to de.ne a measure of similarity, this is not without its .aws and subtleties.

if Reverb forms a query that is overly precise or not precise enough to capture the exact nature of the change, the developer may need to intervene and provide additional re.nements.


The developer introduced ELIDE modifiers to support a better factorization of the program: Each class became re-sponsible for its own persistence, but the similarities of per- sistence that crosscut those classes were captured in ELIDE modifiers.

we defined read end vri1~e mod- ifiers to introspect on trace data type classes end to generate the appropriate read() end vzizeO methods to support persi-qtence.


The original techniques we com bine apply to algebraic data types more generally.

voigtl¨ander [2009, Section 6] employs generic programming tech niques to deal with trees and the like.


The correctness of this process follows immediately from the discussion of binary Bernoulli sampling.

the coordinator always maintains a collection of at least s items, so that all items in round i are chosen uniformly and independently with probability 2-i .


When a load/store is issued, some bits of the address (indicated in the load/store) are used to specify whether to go through the dTLB or whether to find the translation within a specific TR.

one can use the top log n bits (where n-1 is the number of TRs) to indicate whether the address should go through the dTLB for a translation (which corresponds to all these log n bits being 0) or whether to take the physical frame number from a TR, and if so, which specific one.


Every time a new service or technology is developed, a software module to connect each service must be added, and gradually the system becomes increasingly complex, making it difficult to develop and integrate new services.

component-based development assumes that at design time there is already complete knowledge of all the components that the system will contain at runtime.


This implies that energy becomes a .rst-class citizen in smartphones.

the energy consumed by DRAM is non-negligible [1].


A service adapter is a specialized Web Service proxy, designed through the Adapter pattern, which adapts the contract of a particular service according to the contract (speci.ed by the developer at design time) expected by the in-house components.

we refer to ASC as an adapter that accommodates the actual contract of a service S to the contract expected by an in-house component C. an adapter carries the necessary logic to transform the operation signatures of the expected client interface to the actual interface of a selected Web Service.


For example, the manual postcondition for mandelbrot is simply matrix = matrix' .

the resulting image, stored as a matrix of hues, is deterministic.


Less obviously, pre.x-free encodings are often essential to ensure security of iterative constructions in cryptography, such as CBC-MAC [6] and cascade constructions [14, 4, 10, 20].

pre.x-freeness gives the simplest provably-secure counter-measure to various forms of extension attacks on hash functions, message authentication codes and pseudorandom functions, as discussed in Appendix A.


Also, for the sake of space, we only report results for those thematic units that contribute to quantify the construct of clarification requests, namely Check Misunderstanding, Check Provisional, and Unknown categories.

the Check Misunderstanding unit categorizes any utterance providing evidence that a previous message was not fully accepted (e.g., "Not sure I get your question ", "What?").


However, in practical macro systems, it is a valuable addition.

it is relatively easy to add dist-.x operators to our language.


Inbrief,these verypreliminaryexperimentsshowthefeasibility of the proposed approach.

it becomes very easyfor collective communicationdevelopersto re-use code as shown with thegridbroadcastoperation.For static application developers, the impact is very low as the usual collective operations canbeprovided.


Similarly, the weight of a data access edge is determined using the minimum and maximum message sizes (msgmin and msgmax) sent along with the maximum/minimum data rates (ratemin and ratemax) in the NoC communication channels.

the lower msgmin bound can be expressed as lb = , whereas the upper bound ratemax msgmax is given as ub = .


Clean s dynamics have been used in a variety of scenarios, including typesafe distributed communication [14] and an interactive Clean interpreter [34], similar in spirit to plugs and GHCi.

it describes a safe .le I/O system for storing arbitrary objects (including functions) to disk.


Memory diagrams help the student to understand how arrays are implemented in Java.

multidimensional arrays are arrays of arrays.


As an executable architectural framework, re-ADA can directly be mapped into Ada95 code and constructed on the basis of CORBA to support distributed computing over-the-network.

the well-formalized QIM through mapping dependability into quantitative attributes that are attached to architectural artifacts makes it possible to statically verify quantitative attributes during architectural design, and dynamically monitor them at runtime.


Second, we change the if -clause that contains merge(., .1), where .1 is now a pair of agree and disagree,to iterate over extensions of merge(., agree) that cover parameters in disagree and check if the extension disagrees with some bindings in disagree.

we change the single line if .2 = merge(., .1)=.badsubst in (2) and (4) to if .1 = merge(., agree)=.badsubst for .2 in extensions(.1, disagree) if merge(.2, disagree)= badsubst This reduces the time complexity to the same as that for the basic algorithm, for memoization, and for precomputation, respectively, except with the factor substs replaced by substs ×2labelpars .


3.4 Service Variation In traditional systems, parallels could be drawn between components and services.

a component that is only responsible for providing some kind of utility can be thought of as a service provider, and then variations in this utility can be accommodated accordingly.


The mixing time T of a graph quanti.es how fast the ending point of a random walk approach the stationary distribution.

after T(T ) steps, the node on the random walk becomes roughly independent of the starting point.


4.5 Automatic players This new assignment does not add any new game, but extends the application features.

users can specify through the command line not only the game and user interface, but also the kind of players.