Nevertheless, several questions of interest remain open.

the above argument does not say what happens when the stability margin d becomes small: indeed, for small d, the lower bound (3) on a is T(d-2), and it is thus not clear how this replication policy behaves in a near-critical regime d .


An agent coordination model is a conceptual framework which should cover the issues of creation and destruction of agents, communications among agents, and spatial distribution of agents, as well as synchronization and distribution of their actions over time.

the coordinables are the coordinated entities (or agents) whose mutual interaction is ruled by the model, the coordination media are the abstractions enabling the interaction among the agents, and the coordination laws are the rules governing the interaction among agents through the coordination media as well as the behavior of the coordination media itself [3].


only the data contained in the training set have been used as fitness cases.

given an individual k producing the bioavailability predictions %F(PRE) on the training set, we define the fitness of k (RMSEk) as + m ( PRE) 2 .


The following axiom, for example, states that there is a thread associated with an invocation if and only if the invocation is being served4 .

3item thread represents a dynamic relationship between operation invocations and threads, whose dynamic behavior corresponds to a TRIO state (i.e.


The first approach allocates locks inline with objects, which incurs an overhead even when no transaction accesses an object, but has the benefit of good cache locality.

acquiring the lock gets the cache line in exclusive state which avoids any subsequent cache miss on a store.


Schedulability Regions of EDF-VD & WCR for uHI = 3/4 HI C. Comparing EDF-VD and WCR Clearly, EDF-VD outperforms WCR.

if a set of MC tasks is schedulable under WCR, it will also be schedulable under EDF-VD; cf.


Of course, for this generation process to work, someone has to specify the necessary bindings beforehand.

the instantiation bindings of pattern elements for an abstract style structure to elements of the input architecture, as well as some set of correspondence bindings for such style.


Note that this is true only if lookup tables are aligned in main memory, in such a way that no collision can exist.

elements of the lookup tables are not loaded into the same set more than the number of ways of the cache.


The contributions of this paper are: On the programming language implementation side, the paper considers the performance tradeo.s of various design alternatives for backend components on AMD64.

we focus our attention on how functional languages with an existing x86 backend can migrate it to AMD64 with moderate e.ort, but without missing opportunities to take advantage of architectural features present on AMD64 but not on x86.


We can see that the number of queries processed in parallel is very inconsistent and never reaches the allowed maximum of 64 or 128.

since a small number of queries need to be made, the graph for 64 and 128 is exactly the same.


The hybrid resource distribution scheme incorporates resource relocation algorithms that are adaptive to user requests and aim to reduce communication overhead.

by following the same pheromone maintenance concept, the hybrid resource distribution scheme introduces another type of pheromone which corresponds to user requests, instead of resources.


Starting from the selected node, we perform a greedy search based on weight in the reverse direction of incoming edges.

if we are presented with a choice of multiple incoming edges which have not yet been searched, we choose the one leading from the node with the highest weight and mark that edge as searched.


The proposed approach focuses on common program transformations occurring when using cloud-based services that are wellamenable to be expressed as a refactoring.

we will explore a set of refactoring techniques that facilitate the process of transforming centralized applications to use cloud-based services.


For perspicuity, we introduce the following syntactic sugar: SR(R)(Cons v1 v2) = [v2/y] [v1/x] SR(R)(Cons x y) Further, we also assume a .nite ordered map GR that maps structural relations to their sorts.

for all R such that · f R :: tR, we have that GR(R) = tR.


CONCLUSIONS Caching the results of computations is a useful technique across a variety of Computer Science disciplines.

in the area of algorithm design, it leads to the technique of dynamic programming.


CORRELATION-BASED CLUSTERING IN WSN FOR ENERGY SAVING PROTOCOL (CCES) From the analyzing in the previous section, it is found that the correlation ratio can measure the correlation among sets of data.

this ratio can be used to find high correlated region.


All of its operations must be based on event-local state.

an event in none is functional in nature.


Otherwise, the compiler has two options: issue a warning about a possible leak or generate code that dynamically tracks the hierarchy passed to a function call.

the compiler could preserve an exact correspondence between run-time views and static e.ects.


The second conjunct enforces a relation between the signal the transmitter sends (tdata) and the value captured by the receiver (rbit): if stable holds, then the receiver captures the signal.

the constraintmoduleprunestheexecutionpaths allowed by the system module alone in which the value of rbit is completely nondeterministic.


Synchronous exceptions are relatively tractable: The denotation, or meaning, of an expression says whether evaluating the expression will raise a syn-chronous exception and, if so, specifies the set of ex- ceptions that may be raised.

the syn- chronous exceptions that an expression may raise is properly part of the semantics of that expression.


Informed by writing, activity, and genre research and Spinuzzi's genre ecologies framework, we are able to describe how Scrum pulls together the many different genres and artifacts of software development to mediate and direct activity.

we can see how Sprint Planning, Reviews, and Retrospectives involve a host of ephemeral communicative genres (many of which are informal, verbal, gestural, or only temporarily written on whiteboards) that are then made visible and concrete through written user stories and tasks that become displayed and manipulated on the Scrum Board.


However the SA algorithm achieve higher accuracies of the derived BC above certain thresholds of some parameters.

the quality of the derived BC does not seem to be affected by the initial temperature when this later is suf.ciently high.


The experimental results show that the watermarking system achieves high image quality with PSNR not lower than 41 dB and no detection error against the total compression ratio 4%.

the PSNR value is 1.3 times larger than the required PSNR value of the IHC criteria.


For example, an organization may wish to utilize an e-Payment system to process a transaction without walking through any web pages.

it is expected that the information of the transaction is conveyed to the e-Payment system over the Internet through an HTTP (Hypertext Transfer Protocol) request, and the result code is passed back through an HTTP response.


Trace-driven simulations show that the proposed algorithm improves the I/O performance of mobile embedded systems significantly.

it reduces I/O time by 4.853.3% compared to widely acknowledged algorithms such as CLOCK, CAR, and CFLRU.


3.2.5 Control/Data Message Control and data messages are used for delivering control signals and application data, respectively.

data and control flows of a composite service are carried out using control and data messages, respectively.


Hence, all relations that turn up in the de.nition of the new logical relation as given in Figure 4 will in fact be admissible, total, and left-closed.

.seq t,0/ E Relseq(t, t) for every closed type t. .seq = .


Boost.MPI supports automatic serialization of objects, and has served as the model for our work on MPI.NET.

the high-level interfaces in MPI.NET and their resulting use of the low-level MPI library were ported directly from Boost.MPI [7] and its predecessor [10].


JSE is less ambitious in that it provides a convenient and powerful mechanism for extending the syntax in limited ways.

it provides only a limited number of shapes and requires that macros must always commence with a name.


This means that our system absorbs properties of theirs, including type safety for the FJ subset of FJsec, implying that the only case we really need to consider, to extend type safety to FJsec, is progress for trace checks.

we must show that checks can be statically enforced by our type analysis.


We also require that all call-ups execute atomically in some unspeci.ed order in the parent.

concurrent callups from multiple children are always serializable in the parent s address space.


The fourth definition (D4) treats variability as an architecture design time quality attribute [4]: Variability in software architectures is the ability of influential factors on design to vary.

variability is a quality attribute whose solution impacts other quality attributes (causing trade-offs between variability and other quality attributes).


Moreover, we used our concurrent unit testing tool to test its own implementation.

we wrote concurrent unit tests to exercise our test wrapper (Section 2.1) responsible for starting threads required by the thread-Count or threadGroup annotation parameters and initializing the TestBarrier helper class (Sections 3.2.2 and 3.2.3).


Once the framework has been de.ned, it can be used to realize the architecture description of the system-of-interest.

mEGAF allows to create an architecture description conforming to the architecture framework, to specify views that are governed by viewpoints de.ned in the architecture framework and that address some previously-speci.ed system concerns.


Thus, in this paper, we de.ne a framework for reusing and inferring test results for untested con.gurations of DSPLs.

here we focus on inferring structural testing results based on call graph similarity of con.gurations.


As HTML5 directly aims at addressing issues of reliability, security and performance of technologies like Flash1 , we believe this paper presents a number of insights to be considered as the Web evolves.

the requirements that motivated our work include: i.


This affects the software architecture of the underlying infrastructure.

the pure clientserver paradigm, where some machines play the role of service providers for other machines, appears to be unsuitable to enable the required intrinsic dynamism.


On a range of standard multithreaded benchmarks, we show that generalizing from the observed trace signi.cantly increases SideTrack s ability to detect atomicity violations, without introducing false alarms.

sideTrack detected 27 in-errors, which would also be detected by prior precise tools such as Velodrome.


Second, our strategies reduce the heap occupancy.

at a given time, our approach reduces the heap memory requirements of the application being executed.


bit-vector operations become expensive because new integershave to be allocated.

each time a set operation iscomputed such asan union, a disjunction, etc., new integersare allocated.


My sincere thanks go to my former colleagues and coauthors J. Gutknecht and H. Mössenböck, and to the teams who implemented Modula-2 and Oberon and ported them to a variety of machine architectures.


The most common faults could be modeled by mutation.

the faulty is the version di.ers from the original Boolean expression by exactly one syntactic change.


(int; .6);.3) the two program points that actually caused the problem also have multivocal types: f : ((bool;int;.10) .


To assess their methods in our framework and to devise more advanced structure-based heuristics are our goals for future researches.

symbolic manipulation of a system to achieve a structural diagonal dominance where only one variable is preeminent per constraint (e.g., with a much higher degree) seems a promising approach.


of the middleware components that handle the execution of service compositions.

we focus on Web service compositions described as BPEL processes, running on execution environments that consist of a BPEL engine and additional components such as service registry or enterprise service buses.


As shown in the .gure, all other energy accounting policies achieve 5% to 25% less utility value than Shapley valuebased energy accounting.

policy II and Policy III have the least utility values because they violate Axiom of Ef.ciency.


To this end, in this short paper we propose an MDA approach, which is able to automatically produce a semantically-enriched task model that can be used to obtain interactive applications with some application logic implemented through external services.

our approach starts with the task model of an interactive application and transforms it into a semantic service model by associating the task application objects to concepts of an ontology of the associated application domain.


We maintain control by doing so in as minimally intrusive manner as possible.

each time the elements of a mined speci.cation are used at runtime, we delay the minimum number of function calls by the minimum amount of (execution) time necessary to violate the property.


Similarly, after q.s1 transits to eating, q.s1 does not exit eating until q.s0 (which had exited earlier) becomes hungry and starts eating again.

the beginning and ending of each subject s eating session overlaps with the other subject s eating session.


Specialization improves the performance by 1.20x on average.


If the time consumption di.ers, also the so-called mismatch-level of the classi.cation is increased by one.

if the different execution time would render another implementation bene.cial, the level is even increased by .ve.


Here, we assume that the number of consumers NAP is equal to the number of cores in the system.

if all producers are blocked, the consumers can exploit all cores if there are enough full buffers to be processed.


3.3 Using a sparse table and interpolating via disassembly Another approach to reducing the call site table size is based on the observation that executable code itself con- tains some of the information in the table.

the number of a call site can be calculated by disassembling the executable code from the start of the code to the current return address, assuming that no data has been intermixed with the code.


For each BoT execution pro.led, the C factor is computed using all available BoT executions with same BE-DCI trace, middleware, and BoT category.

the learning phase (during which C is adjusted), is discarded and we assume perfect knowledge of the history of previous BoT executions.


We give one half of the derivation below: proof assistant [18].

we have de.ned a type M, representing the internal models of a repository.


Since in general we are not assuming that the rules R are sort-decreasing, what we can always ensure about terms t ' to which a term t of sort s can eventually be rewriten is that if t ' has sort s ', then s and s ' are in the same connected component in the subset ordering.

they belong to the same equivalence class [s] for the smallest equivalence relation generated by the subsort ordering relation =.


Eclipse s JavaScript annd HHTML editors do not providde as much proogramming suppport.

i thhey only proviide error highllighting for syntaxx errors and soome basic quic k fixes, such aas rename in file and assign sstatement to neew local variabble.


Now we consider the scalability of cGA, sHC, and rHC on the noisy OneMax problem with the exogenous noise variance of 10-5th of the deterministic variance.


The e.ort required to generate formal models is generally more than o.set by the early identi.cation of errors.

when formal methods are used early in the life cycle, they can reduce the overall cost of the project development.


However this result is correct because these two formulae are past time LTL, which are supposed to be always satis.ed.

runtime veri.cation code only reports exception for past time LTL formulae if it is violated, just like code in Fig.


An application is vulnerable to CIntAOs whenever inputs differing in untrusted symbols can cause the application to output programs differing in code symbols.

applications invulnerable to CIntAOs must, when given the same trusted inputs, always output programs containing the same code symbols.


Instead of using Cable, this method simply divides the traces into classes of identical traces and then counts the cost of inspecting and labeling each class separately.

the cost of Baseline is two times the number of classes of identical traces.


Filters implement application-independent functionality; they are composed with services to modify service behavior.

as with services, .lters are simple functions: type Filter[Req, Rep] = (Req, Service[Req, Rep]) => Future[Rep] a .lter receives a request and a service with which it is composed; function application evaluates to a future.


For performance reasons, the insertion in the beginning of methods may be omitted if each possible execution path terminates or passes by an already inserted conditional before any method/constructor invocation (invokeinterface, invokespecial, invokestatic, invokevirtual).

leaf methods may be omitted (especially accessors of abstract data types), as well as entry points of methods inside which the .rst method invocation happens after another inserted conditional, typically inside or after a loop.


We do this, similarly to [5, 8], by considering the following continuous relaxation of the problem.

we remove most feasibility constraints and leave only the constraint that the sum of the reciprocals of the positive periods cannot exceed 1.


A permutation is super.uous if no exploration from it can lead to any distinct concurrent def-use pairs.

all concurrent def-use pairs ful.lled from permuted states will still be encountered even if the permutation does not happen.


The library is comprised of a hand-constructed decision tree that checks for the presence of critical invariants and interface functions in order to declare a data structure match.

the presence of critical invariants and interface functions is tested, and any additional invariants/interfaces to not override this result.


Applications running in debugging mode [24] require support from the JIT compilers to inspect the state of the execution of a program (e.g., printing or setting values of variables) and to control the execution (e.g., setting a breakpoint).

the compilers need to provide the addresses of variables and the native code offsets of bytecode locations.


The rv peculiarity of this scenario is related to that ex and ey are both causally related to each other.

if ex is r v rolled back, then we need to rollback ey given that object x may have performed updates on the memory stocks destined to keep the state of simulation object y while processing ex .


Recall that our algorithm will delete and add some points in SB , so as to reduce the EMD.

when Bob .nds a quadtree cell with count larger than in its counterpart at Alice s side, he deletes a point chosen arbitrarily from the cell.


5.2 Multidimensional Scaling Multidimensional scaling (MDS) is a general term for the techniques to configure low dimensional mappings of given high-dimensional data with respect to the pairwise proximity information, while the pairwise Euclidean distance within the target dimension of each pair is approximated to the corresponding original proximity value.

it is a non-linear optimization problem to find low-dimensional configuration which minimizes the objective function, called STRESS[28] or SSTRESS [29].


This is required, as the fitness function used in the GA requires end times of task executions.

each time the fitness function is evaluated for a chromosome, the aperiodic tasks in the chromosome as well as the periodic tasks described in the inputs are scheduled by the scheduler.


The .rst thing to notice in this .gure is that, in terms of opr, both EXH and TTL-DANS achieve 100% object processing ratio.

tTL-DANS is able to locate a suitable fusion operator in each and every case.


Based on our evidence, however, the effectiveness of the technique is still limited, and the development of more sophisticated approaches is required.

the technique attempts to .x a broken method call by adding, deleting, and modifying parameters, but it does not synthesize new method calls.


The third equivalence is more interesting: as soon as the test command succeeds once, the th branch is immediately executed and the el branch can never be tried.

thus: ifte (m1 mplus m2) th el * (ifte m1 th el) mplus (ifte m2 th el) the context ifte [] th el interacts in an unusual way with mplus.


We assume that average cost per user converges to a smooth ¯ function of X, as N goes to in.nity.

we have ´` .2CN lim C N (X¯) = C(X¯) where C N (X¯) = CN X¯.


To convey our ideas, we first introduce the concept of an SDM-lifestyle, which is a meta-method that guides the actual adoption of an SDM (whether in academia or in industry).

an SDM-lifestyle guides both the process of the adoption of an SDM and its maintenance by the organization.


G. GENERATIONAL WRITE BARRIERS In a generational collector, to avoid scanning the (usually large) older generations when collecting younger generations, one tracks mutator writes using a write barrier.

when object p is modified to refer to object q, if p is in an older generation than q, we remember that fact.


At this point, the boundaries of the overlapping ARs will be adjusted.

the end time of AR-0 will be updated to 2, and the start time of AR-2 will be updated to 4.


However, it is possible through an indexing technique that assigns a unique code to each unique graph isomorphism.

each graph with edges and vertices connected in a unique way can be assigned a unique numeric code to express its singularity of structure.


Finally, to investigate the relationship between testing strategy and outcome, independent of time management behaviors, we performed post-hoc analysis excluding submissions with poor habits.

we included only assignments with the following credentials: one (or more) submissions preceding the deadline by at least 48 hours; multiple submissions spanning development over 24 hours; and final submission before the deadline.


Depending on the stage of the algorithm, the heuristics used to select the candidates varies.

three different methods have been used to select candidates: one for the instruction scheduling stages, i.e., stages 1, 2, 5 and 6; another for the elimination of outedges, i.e., stage 3; and finally, a different one for the final cluster assignment, i.e., stage 4.


See Figure 3 for a pictorial description of the action of the algorithm and this approximation.

note that a small number of slabs are sampled, and every other slab is approximately reconstructed using the information in those slabs as a basis and the information in a small number of .bers (depicted as the dashed lines).


And since iterators are the technical means to conduct such a traversal, then, conceptually, iterators should be independent of comparators and allocators too.

there is no conceptual reason that requires std::sets that disagree on comparators or allocators to have different iterator types.4  3.2 The Technical Aspect The question is therefore whether we are able, technically, to eliminate the unwarranted dependencies and utilize a single iterator type for different integer std::sets that have different comparators or allocators.


In practice, however, unavoidable .uctuations and errors in measurements may produce an incorrect result.

.uctuations make it non-trivial for procedure add to decide if a branching point X coincides with an existing branch.


Morphic events delivered to the Morph are converted to KSObjects that represent events.

squeak provides only a minimum of support for the graphics and events.


r « n, such that, by using only those r features, we can obtain good classi.cation quality, both in theory and in practice, when compared to using the full set of n features.

we would like to solve exactly or approximately a RLSC problem of the form (4) to get a vector to classify successfully a new document according to a classi.cation function of the form (6).


SIs of the stations located at the root node equal to the BSI and for each level of the tree the algorithm multiplies the SIs of the stations associated in the nodes by two.

sI of the stations B and C located in nodes b and c is 2BSI (Figure 5), and SI of stations D, E, F and G located in nodes d, e, f and g is 4BSI.


SOLUTION REQUIREMENTS Our analysis within the theoretical framework of mental models provides insight as to how a solution can be reached.

the goal should be to ease the burden placed on the developer of maintaining a mental model of the programming environment.


In this paper, we address the scenario where such a test suite is not available, and the user relies on test-generation techniques to create one.

we consider several test-generation techniques based on combined concrete and symbolic (concolic) execution and compare the fault-localization e.ectiveness of the generated test suites.


Second, HTTP Proxy , unlike Domain Proxy , is not a special infotron.

one can easily derive a compatible blueprint that provides a different implementation.


In this work, we leverage EV-Path, an event processing architecture built on Fast Flexible Serialization (FFS) which is designed to support high performance data streaming in overlay networks with internal data processing [11, 12].

eVPath enables the construction of active messaging overlay networks in the way that data stream analysis services such as data .ltering and transformation functions reside in lightweight stones that serve as processing points in the overlay, and stones are linked to form overlay paths .


However,our qualitativeanalysis of surprise defects and the feedback from the quality assurance manager clearly indicate that further work is needed to develop defect prediction into a practical tool.

we found support for the idea ofbuilding specialized models that identify not onlya defect s location,but also its nature, thus greatly simplifying the process of determining what the defect is and how it needs to be .xed.


3.3 Second Attempt: Naive H-DRF We now turn to a natural adaptation of the original DRF to the hierarchical setting and show that it can lead to starvation.

we show how the hierarchical share guarantee is violated for leaf nodes.


However, sinceitis not aSCDbranch, the correlation between y and the predicate is not strong.

applying an o to a (the left-hand side of the predicate) orto10(theright-hand side) may not changethe branch outcome and hence the value of y remains the same.


To this end, two services are of the same type if they provide the same interface and the same set of features composed in the same order.

the type system is partially structural (e.g., based on the feature structure) and partially nominal (e.g., based on feature names).


Future works deal with the generalization of the deployment mechanisms according to specific architectures for the dynamic deployment of software components [2,15], so that model deployment becomes a particular case of component deployment.

a promising extension could be to consider a ModelAgent as a macro-component with concrete ports and explicit connectors [2], which includes and manages one or more models that are treated as micro-components.


Intuitively, this is caused by the fact that the Quasit meta-scheduler implementation exploits a number of distinct active internal queues exactly equal to the number of priority classes and completely independent on the number of operators.

figure 4 shows that, when only two priority classes are used, the best throughput for both priority schemas is achieved in the con.guration with two operators thanks Num.


For t> 0, we .nd the optimal values opt[t][u] by considering the optimal migration paths to any node v at time t - 1, and adding the migration cost from v to u.

in order to .nd the optimal cost to arrive at a con.guration with server at node u at time t: min opt[t - 1][v]+ Costmig(v, u)+ Costacc(w, u) v.V w.st where we assume that Costacc includes the .rst (wireless) hop of the request from the terminal to the substrate network, and where Costmig(v, v)=0 .v.


From this investigation, two classloading strategies (one of which is new to this paper) are described and compared with the default non-preloading classloader.

we: describe a preloading (P) classloader that eagerly preloads all classes whose names are in the constant pool to reduce the chance of new classes being loaded after an IPA is triggered, and thus can improve performance by reducing the repetition of the IPA.


The goal of our study is to better understand risky changes, so that they can be addressed by practitioners and their risk can be mitigated.

we would like to identify risky changes and determine which factors are associated with them.


Theorem 2 states that the Prune-Re.ne algorithm is both sound and complete.

pruning has no impact on the answer to a query.


By limiting the number of CPU cores to handle interrupts, SimpleServerC can scale as well or better as when power-saving is disabled.

we see that using 4 cores for interrupt handling is optimal.


{22p+1pB, 32p+1 pB, ...}, there exists a constant E> 0 such that any Eerror distributed algorithm for any of the following problems 11 2 2(2p+1) ) requires O((n/(pB)) - time on some T(n)-vertex graph of diameter 2p+2 in the B model: Spanning connected subgraph, connectivity, s-t connectivity, k-components, bipartiteness, cycle containment, e-cycle containment, cut, s-t cut, least-element list [4, 14], and edge on all paths.

for graphs with diameter D =4, we get O((n/B)1/3) lower bound and for graphs with diameter D = log n we get O( n/(B log n)).


The concept of iterated dominance frontier has several applications.

it is directly useful in computing sparse evaluation graphs, the SSA form, and control dependences.


The correctness constraint is violated iff, for an edge (u,v).E, the label iv is inA and the label ou is in A.

correctness is e e violated if the succeeding node expects the computation but the preceding node does not deliver the computation.


The probability that this variable exceeds some value x is less than or equal to (1 - 1/w)(x-1) = exp(-1/w)(x-1) = exp(-(x - 1)/w).

it exceeds 1 + cw log n with probability less than exp(-n c).


Blocks represent one of the most powexful notions of F-Sct4pt (and Smantalk).

blocks cover the functionality of defined functions and defined opexators in APL language.


It is assumed that every player can recognize other players and recollect the past experience with them.

a player knows whether the opponent in the current exchange cooperated or defected in the previous exchanges.


Note that, in contrast to single-rounding FMA instructions, the new CMA instructions do not alter the guest ISA, as they are handled internally in the host ISA.

only the CMS can inject CMA instructions into a translated binary when creating optimized versions of the hot code regions.


Catchingsuch con.gurations errors early on, when writing the architecture description of a Dream assemblage, would be of tremendous bene.ts to programmers using the Dream framework.

what would be required would be a type-safe ADL that would allow the typing of component structures and reject ill-typed component con.gura- 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.


Our objective is therefore to integrate quantitative techniques for reasoning about non-functional properties, based on objective criteria, with goal-oriented techniques for building requirements models.

systematic support should be provided to: specify and propagate partial degrees of goal satisfaction precisely, in terms of domain-specific phenomena;  guide the elaboration of models that help stakeholders assess the impact of alternatives on the degree of goal satisfaction.


A concern is any concept, feature, requirement or property of the problem or solution domain of software [28].

highly 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 pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


A td-PDG thus contains all true and control dependences of a given thread trace and omits all con.ict dependences.

td-PDG is a result of partitioning a d-PDG by thread membership of vertices.


An independent set of a graph G is a subset of the nodes such that no two nodes in the subset interfere [1].

no two nodes represent an edge of G. In the proposed method, the value of the independent set S in a graph G {U} is defined as the summation of effective saving of a node U by each node of S. The independent set S is called maximum if there is no independent set which has the greater value than that of S. Again in Figure 3, when calculating the effective saving for a node A, the independent set of G {A} is {B, C}.


In particular, a rebalance never moves an element from one side of a marked cell to another.

whenever a rebalance moves an element, all the intervening cells are empty.


For continuous time, we assume that there exists some constant t .

r>0 such that tk+1 - tk = t for all k = 0.s(·) is subject to the dwell time t .


This integration is done in pure Java 5 and shows useful information to the final programmer, so that the configuration is more straightforward and more flexible than with classical frameworks.

we think that AOP annotation-driven development is well suited for incremental development, where the application is built through several refinement steps that require frequent codelevel reengineering.


The .exibility of these options can be extended further by potentially adjusting the disk s memory allocation between read and write caches.

depending on workload and execution context optimizations, the disk s cache may allocate more toward the read cache instead of the traditional 50%.


In fact, Table 3 shows that it has much better maximum pause times than pure RC because it is exposed to less load.

cycle detection causes problems as evidenced by the 213 javac result.


A few concepts in the adaptation language require further work to flesh out.

it is unclear what the best way is to handle failure during adaptation execution, or whether it needs to be dealt with at all if we assumed a continuous adaptation cycle of monitor and control.


Sharing a software instance with multiple customers however, makes it impossible to have customized software products for a speci.c customer.

multi-Tenant (MT) software should be able to ful.l all di.erent customer requirements, while still pro.ting from shared resources.


In this paper, we discuss the construction of HaRe and Wrangler, and comment on the challenges we had to solve.

we examine the sorts of analysis that underline our systems.


Because semantic analysis in compiler design often involves traversal of various AST nodes, it is natural to explore the effect of AOP on compiler construction [7].

in objectoriented compiler implementation, after the node types are implemented as classes, the AOP approach is an excellent technique to apply to semantic analysis.


However, the most common type of perception in MMOG is what an avatar can see, which does not always correspond to proximity.

game worlds usually contain static obstacles that occlude regions of the game space.


Therefore, once t is instantiated, the instance of t' must be uniquely inferable by the typesystem.

the relation between t and t' is actually a function.


Because BisimH considers one counterexample at a time, a re.nement may split a partition suboptimally.

a split partition may need to be split again to help eliminate another counterexample, even though a single split might suf.ce to help eliminate both counterexamples.


factor is relevant in empirical software engineering and ethnography, in particular.

what signi.cance do the results have for software development?


Hence, the merchant can be sure that the decryption keys as well as the decrypted content do not leave the trusted environment.

the keys and content will not be copied and distributed to a third party.


The intended usage scenario for EASE makes modularity even more critical.

good modularity should provide the following desirable properties: 1) rapid proto- typing, 2) highly complex actors, 3) use by novices, 4) a good development process, and 5) support fordevelopment teams.


However, the approach is missing su.cient mechanisms for managing business document model variants.

the following shortcomings are encountered.


}/> creates an input element that is enabled or disabled depending on the validity of the credit card number, and whose border color is correspondingly aqua or cyan.

the JavaScript object { borderColor: ... } is automatically converted into a CSS style speci.cation string.


However, such types of applications su.er from signi.cant performance degradation, especially as the overcommitment is common in cloud.

the number of executable Virtual CPUs (VCPUs) is often larger than that of available Physical CPUs (PCPUs) in the system.


This clone coverage metric can be applied at any level of abstraction.

we can compute clone coverage from one product to another product, and then to the next level of the product decomposition hierarchy.


Additionally, we are now restricted to working with single, regular datatypes.

recursive families of datatypes, common for expressing large ASTs, are out of our reach.


Therefore, a consumer with a low feedback reliability rate has a high probability of giving a good feedback for an attacker s bad service (i.e., cheating).

the attacker s misbehavior will not be punished under a given trust function, if most users have low feedback reliability rates.


In this case, after printing of e is .nished, we want the execution to continue at the current level as though old-eval was directly called from the original caller, i.e., the REP loop.

we want to cancel out going up and down needed to print traces.


Furthermore, they only report results for MIPS32 a simple, single-issue processor.

even with spill code optimization and ultimate coalescing our model scales as well as the model of Casta neda et al.


two firings can be executed in parallel only if they are independent.


Adopt a common runtime pro.le between OSG and XSEDE.

runtime discovery of scratch directories, CA certi.cates, and application areas are quite di.erent between the two grids.


To find a cooperative strategy which outperforms the unconditional defector ALLD, we consider the three optimality crieeria for the Turn-Taking Dilemma.

a successful strategy must be able to achieve turn-taking in games against its clone.


On average the total number of used registers increased by 4.

kernels in lud, nw, and srad showed the greatest increases in number of used registers by 17, 16, and 14, respectively but these increases did not a.ect occupancy (see Section 3).


Finally, a considerable challenge of this study after the data collection, was the summarization, integration and analysis of the data.

processing and indexing large amounts of log-data (e.g., the Mimec logs amounted for 1400 hours in approx.


In all the cited examples a modi.ed C compiler is used to program the processor and to extract candidate kernels to be downloaded on the FPGA.

the GARP compiler [4] and the related Nimble compiler [15] identify loops and .nd a pipelined implementation, using pro.ling-based techniques borrowed from VLIW compilers and other software optimizations.


The results show that GORE can provide a promising methodological foundation for the analysis of value co-creation.

softgoals and satisficing objectives are extremely useful in analyzing value co-creation and the representation of services as nodes in AND/OR graphs can elicit both the valuerelated and the activity-related properties of the notion.


Recent research has proposed to intelligently iterate over the optimization search space using predictive methods.

state-the-art methods in iterative compilation use characteristics of the code being optimized to predict good optimization sequences to evaluate.


t is an = .¯ improvement of s. We might conjecture at .rst that improvement of types is consistent with the type instantiation relation.

if s ' is an improvement of s, then P0 f s ' = s and P0 f s = s '.


The semantics of other primitives in Inv are generalized to propagate tagged values.

using a synchronization primitive for list values, theydemonstrate that it is possible to achieve a sophisticated backwards semantics for several intricate operations on lists, even in the presence of duplication.


3.2 Saturation At the end of each phase, we saturate the = relation until it satis.es a collection of closure rules.

we ensure that =is an equivalence relation: (re.)


Keywords-Geo-distributed data centers; electricity cost; carbon tax; bandwidth cost; request routing; VM scheduling I. INT RODUCT I ON Today, many pioneering Cloud Service Providers (CSPs) deploy geo-distributed Data Centers (DCs) worldwide for providing various services to their customers from different geographical regions.

software-as-a-Service (SaaS) platforms such as Salesforce.com [1] and Zoho [2] have been gaining prevalence in delivering software services.


assert ReachesLegal {all i: Legallnterface I i.reaches in Legallnterface}  //if interface i reaches interface j, does j reach i?

assert ReachesSym {all i, j: Legallnterface I i in j.reaches -> j in i.reaches} Figure 4: A variety of simple queries All conditions are consistent, all assertions ore invalid  Theorem 1 says that for any legal component, the identifiers known to any interface of that component are all the identifiers of the component every interface identifier of a component is accessible from every interface of that compo- nent.


By isolating the core GISS algorithms from the supporting functions (algorithms for reading input and writing output) and providing a single interface specifying parameters and initiating the analysis, ccc-gistemp seeks to improve the readability and maintainability of the software.

the temperature Series anomaly, which is the primary data object in most GISS algorithms, has differing representations in different parts of the code making it hard for new users to comprehend the code.


This paper shows how we use the block-recursive, cache-oblivious style to localize the base cases for ef.cient processing to support the communication and sharing of blocks over them.

the divide-andconquer paradigm leads to a much improved decomposition of Cholesky factorization that enhances memory locality within the processors, and simpli.es block communication among them.


This question is our primary motivation in this paper.

we approach this problem from an analytical perspective, and obtain some interesting answers for the in.uence of biasing mechanisms on the performance of RW through closed-form expressions.


CONCLUSIONS Awareness services are a very powerful aspect of structural computing.

they o.er multiple opportunities for increasing the e.ciency and reducing the size of domain-speci.c applications built using structural computing technology.


This paper is concerned with a subtle but costly problem which can arise when both the subject-and the meta-language are statically typed.

when the meta-language is typed, there is generally a need to introduce a universal datatype to represent values uniformly (see [48] for a detailed discussion).


As a result, we decided to limit the number of pointers that are visible on the shared display at any given time to six.

the shared display is allocated a pool of six pointers, which are assigned to different clients on demand.


The contribution of these edges to the iterated dominance frontier of uis, however, not captured by the loop containment relation.

uis not contained in any loop, and HLC(u)is empty.


Therefore .LVar is actually a family of languages, rather than a single language.

formally, D is a bounded join-semilattice augmented with a greatest element T. D has the following structure: D has a least element ., representing the initial empty state of an LVar.


STUDY SETTINGS Concern projection is a pre-requisite to measure properties of crosscutting concerns.

concern metrics rely on the projection of concerns to the software artefacts before they can be applied.


Consider the partial gradients .pi E =[.E/.pi,f]E = .E/.qo , f.F , .qj j,f f.F,o.O and the following system of ODEs: dpi = -.pi E +zD1 ,i.N , (10a) dt dqj = -.qj E +zD2 ,j.M, (10b) dt where zD1 , zD2 , de.ned formally in [9], are the minimum forces required to keep the evolution of the system within the constraint set D1 × D2 .

theODE(10) canbe viewed as a projected gradient descent for theRating Prediction problem.


.. and observing im(0) = vt(1)-vt(0) = 1, we have vt(c)=^c1im(i)+1 (10) i=1 The friendliness of a program is given by its .ll time function vt(c), which is the average time it .lls the cache of size c with newly accessed data and evicts the data from peer programs that have not been used in the last vt(c)time period.

the data access of this program leads to the survival window of vt(c)in size-c cache for the data from the peer programs.


2003]; the tool described here is able to handle large Haskell programs.

the tool is covers the full Haskell 98 language; works with multiple module programs; preserves layout and is embedded within Emacs [Cameron et al.


At each iteration a sample of thepopulation is selected for evolution, the probability of selecting an individual for the next generation is proportional to the value of its .tness function.

input values more near to cover the target path are more likely to be selected for contributing to the new generation.


These rules are somewhat analogous to the faceted evaluation rules of Figure 4, but with some noticeable limitations and restrictions.

the NSU semantics marks each raw value R as being either public or private: V ::= R public values |(k ?


These trends lead us to develop a framework to address the considerable challenges to the engineering of a continuous design/FLOSS approach to the design, development, maintenance and evolution of critical network infrastructure systems.

this paper contributes to tackle the following challenges in this domain: Integrating engineering principles and methods with the collective innovation inherent in continuous design/FLOSS development.


When child threads are spawned inside a require statement, they share the parent s guaranteed resources, and inherit the parent s limitations.

the parent thread, and threads spawned within the same require statement share evenly the allocation received through the require statement.


Two graphs are considered isomorphic when there exists a one-to-one correspondence between their internal structures.

they have the same number of edges and vertices connected to form exactly the same topology.


2) Program statements are related through true dependences or control dependences in atomic regions.

an atomic region does not perform multiple unrelated computa tions.


INTRODUCTION 1.1 Motivation The concept of virtualization or indirection is a basic concept in computer science.

perhaps one of its most basic manifestations is the invention of virtual memory.program variables (resp.


By pushing mappings to the SSD when they are going to be used, we eliminate the round-trip latency that a request-reply protocol would have required.

it is better for the host to push the mapping than for the SSD to request it.


3 Visualization Data Model Doing high-quality, program-speci.cvisualization in a dynamic environment puts strong requirements on data collection, data analysis, and visualization.

it means that All aspects of the system must be very ef.cient.The instrumentation must not signi.cantlyslow down the program.


Note that this approach represents a signi.cant departure from current data locality optimization models as these models try to improve spatial and temporal reuse of data by restructuring code, without taking into account the layout of data on the disk system.

the prior efforts optimize locality of accesses by improving data reuse at the application code level.


1 Introduction We want to be able to understand the behavior of our software.

we want to be able to understand what the software is doing when performance issues arise, when it undergoes unexpected behavior, and when it interacts with the user or the outside world in a particular way.


The ideas governing the design of ScmPkg are: Let users (i.e., Scheme programmers) continue to maintain their private practices.

let users keep writing their code using the language and its extensions they like or they are used to.


We assume that the goal of a misbehaving peer is to receive the best quality service possible while spending no money.

rather than being malicious,the peer is lazy.


Newly allocated objects during GC cycles are treated as described in Section 4.2.3 unless explicitly mentioned.

we allocate objects unmarked before the .rst termination check and marked thereafter.


As part of this research, we plan to investigate online planning techniques that address these requirements.

we intend to investigate the applicability of temporal planning, such as those described in [9], for implementing the Effect activity in FUSION.


Thiswouldhoweverbeawasteof the measured results, andthus ofthetime availablefor runningthe experiments.

in agiven amount oftime, we would getlessprecise results.


However, a direct implementation of shift/reset for the stack strategy is quite simple as it can use a contiguous representation for rei.ed continuations.

it does not have to deal with the stack-over.ow situation.


Properties of CONCHITA Our checker is sound; if it finds a trace, the trace does violate some confidentiality claim while matching the system specification.


We created a large virtual address space via an abstraction we called xvm, which provides an extended, customizable virtual memory, with little, if any, effect on other processes.

iCRs average a small 9% overhead, while full compiler bounds checking averages nearly 63%.


A real-time collector has to be incremental as not to cause deadline misses by suspending an application for too long.

a real-time collector has to relocate objects in the heap, incrementally and transparently to the application.


Analyzing the Behavior of Event Processing Applications Ella Rabinovich Opher Etzion Sitvanit Ruah IBM Haifa Research Labs IBM Haifa Research Labs IBM Haifa Research Labs ellak@il.ibm.com opher@il.ibm.com ruah@il.ibm.com Sarit Archushin IBM Haifa Research Labs sarit@il.ibm.com ABSTRACT Event processing application development is a relatively new discipline that poses challenges when applying state of-the-art software engineering practices.

the temporal semantics of event processing requires careful validation of the actual behavior against the expected behavior to avoid temporal fallacies.


A variant type de.nition type+ T = ... | C adds constructor C to existing type whose type name is T. In Figure 1, we have already seen an example that adds Sub constructor to the type t. The constructors added to a variant type by aspects often make pattern matching non-exhaustive.

a base program that originally de.ned the variant type usually has functions that process for each constructor differently (e.g., eval in the simple interpreter).


The architects decide to realise the system using a service-oriented architecture.

they apply an architectural mechanism where the business logic is encapsulated in services.


Conditional compilation was the variability mechanism used in the Java releases, which were used in turn with the goal of supporting an analysis of AOP.

the goal of our comparative analysis was to observe to what extent AOP mechanisms provide or not enhanced product line stability in the presence of change tasks.


We can then determine k for a particular workload based on the acceptable proportion of planning time from the overall runtime of the query.

we determine what number of feedback and re-planning operations can be conducted on a given planning time budget, and determine k accordingly.


5.2.3 Interchecking Subclassing is safe only if method overriding honors the usual subtyping rule.

if method C.M : T overrides method C..M : T .,then T<: T .


Furthermore, in Generic Haskell, a generic function is not a .rst-class citizen.

one cannot write generic functions operating on other generic functions, as our traversal combinators (e.g., everywhere) require.


Furthermore, extensive application across multiple types of information could lead to misapplication in higher stakes content.

if users find a marketing brochure doesn t meet their needs, there is little associated cost beyond a potential loss of a sale; if those same users have trouble understanding more mission critical single sourced information, such as medical documentation, more serious consequences could result.


o In the following, the Web-based programming abstractions are described in more detail: o Group is a HTTP resource formalizing a specific application which manipulates a specific BAN data source.

it is composed of three correlated sub resources: Collector, Data, and Contributor.


CONCLUSIONS This paper has presented hTrust, a trust management model and framework that simpli.es the development of trust-aware systems and applications.

hTrust relieves the programmer from dealing with trust formation, trust dissemination, and trust evolution issues.


13 14 15 Q4: How e.ective are the automatically generated integra 16 tion test cases?

to what extent can newly generated integration test cases substitute or augment 17 integration test cases that can be derived with tradi-18 tional techniques, and how many integration test cases 19 can be automatically generated?


In this work, the authors present a binary valued approach for prioritizing requirements that fuses benefits and costs of each requirement to provide a holistic approach to prioritization.

once requirements are elicited, a set of quality attributes is identified as evaluation criteria.


Inductive trace segment covers can be derived from HCFGs.

every HCFG H represents a unique inductive trace segment cover C(H).


INTRODUCTION Writing safe and robust low-level code is di.cult; writing safe and robust low-level multithreaded code is more di.cult.

it takes great care to avoid data races (one thread accessing data while another thread writes the data), but a single race can leave data in an inconsistent * This research was supported in part by the AFOSR, under grants F49620-00-1-0198 and F49620-00-1-0209.


As main contribution, we show that if the package signatures of a new component version Cnew specialize the signatures of the old version Cold , then Cnew type-checks in all contexts in which Cold type-checks.

we extend checking of interface types to the level of packages.


In particular, there is a lack of clarity on what 'usage' or 'effectiveness' mean in the context of agile development.

the relationship between agile usage and agile effectiveness has not been investigated.


It serves no other purpose to virtualize the underlying physical CPUs, since our sandbox kernels and their applications execute directly on the hardware.

a VCPU does not need to act as a container for cached instruction blocks that have been generated to emulate the effects of guest code, as in some trap-and-emulate virtualized systems.


J: the time stamp of t such that all operations in t at timestamp greater than or equal to J will always execute ' after thread t has joined.

no instruction in t with timestamp greater than or equal to J will ever ' overlap with any instruction in t .


Second, architectures for these systems will have to be more flexible than they are today.

devices are likely to come and go in an unpredictable fashion.


Thus, the number of the .nal log templates become large.

incorrect labeling of words generates unnecessary and verbose log templates.


Completeness : Documentation is said to be complete when all the requirements of the software are detailed.

each goal, functionality, attribute, design constraint, value, data, model, symbol, term (with its unit of measurement if applicable), abbreviation, acronym, assumption and performance requirement of the software is de.ned.


Second, the model checker can verify that, while in a particular context, an event adheres to the strictures of that context.

it ensures that while an event is in null context, it only performs functional actions and while an event is in anon context, it only reads service state and performs deferrable actions.


2)At a DEVS coupled model: i) there is no way to verify if the port connections among models are correctly de.ned.

the user should take care if the de.nition domain of a port is a subset of or equal-set to that to which is connected; ii) more evident, the user should avoid a recursive de.nition of a DEVS model by reusing the DEVS in current speci.cation.


To address this problem we are planning to provide user interface functionality capable of mapping the high-level concepts to the low-level ones.

we are going to provide an interface that would allow instantiating general theorems to speci.c collections of operators and speci.c languages.


Many on-line load management algorithms [1, 9] require global knowledge about the load of all tasks and resources, which is usually not available or prohibitive to obtain in terms of communication in a distributed environment.

lui and Chan [9] reduce load balancing in distributed virtual environment systems to a graph partition algorithm, and assume global knowledge of load and pairwise communication cost between avatars.


Error Scheduler The Error Scheduler sits between the Front End and the Error Injectors and is responsible for managing the Error Injectors.

it schedules errors to be injected as speci.ed by the user through the Front End.


For both generational and non-generational versions, the GC time of bitmap marking GC methods is shorter than that of copying GC methods.

the GC time of bitmap(gen) is the shortest in most cases.


Itisimportant to mention at thispoint that the approach in[2]is apure performanceoriented one anddoes nottakeinto accountthe network structure(though itdoes an excellentjob,in our opinion, in reducing the number of accesses to remote data).

this performance-oriented approach minimizes the number of nonlocal accesses but it does not care where the nonlocaldataresides orhowitisaccessed(i.e.,through whichlinks).Thelast twocolumns ofTable3givethe execution cycles and energy consumption results whenthe approachin[2] isfollowedby an energy-saving scheme, which turns off the unused links and scales down the voltage/frequency on others whenever there is an opportunity to do so.


: taking an industrial view, the relevant synonyms for benefit are time and money.

we attempt to demonstrate how AOP could save development time and thus money.


The bounds attribute is user-de.ned and can be speci.ed by declaring virtual predicate bounds, while the clicked attribute is maintained automatically by the library.

the selector predicate getClicked succeeds if the draggable area is currently clicked by the user.


2.2 Modular Reasoning about Flows of Exceptions Flows of Checked Exceptions As an example of modular reasoning about .ows of checked exceptions during event announcement and handling, consider veri.cation of a requirement Ff1 that says: the checked boundary exception RegDExc must be propagated back to the subject Savings, if thrown by any observer of WithdrawEv during its announcement and handling.

an exception RegDExc thrown by one observer of WithdrawEv must not be caught by another one of its observers in the chain of the observers.


over the past decade numerous solutions for alleviating the situation have been developed [12, 10, 16].

researchers and practitioner have proposed several frameworks for constructing such systems.


A require statement has the e.ect of carving out some resources from these shared resources for exclusive use in a block of code.

if nothing about a resource kind is mentioned in a require statement, then no change in sharing takes place for that resource kind.


CONCLUSION In this paper, we presented the DANS architecture for truly decentralized and adaptive execution of media processing work.ows in sensory/reactive environments providing ambient services such as ARIA [2, 3].

we show that the operator instance placement as well as the next operator instance selection tasks can be achieved in a purely distributed manner, without needing a centralized decision maker or a lookup directory.


In this section, we show how K-means, a popular clustering algorithm, can be adapted using the scalespace distance.

the concept of centroids will be replaced by prototypical multi-dimensional curves formed from a group of gene curves.


In order for such a request to reach all potential caches, Bob would have to .ll in all the attributes of m in the request.

bob would have to know m completely in order to issue an e.ective request to recover m. We propose to overcome this problem by once again relying on the information contained in the publication record.


In this paper, we revisit software quality attributes.

we introduce a generic taxonomy of quality attributes, the relationship between the attributes is argued, and .nally we devise future work leading to an attributebased methodology for evaluating software architectures.


For example, as we show below, App and Sub can be used to derive that f0 :tf0, x:{u:int 1 u = 0} .f0 x :unit & (S * , Ø) in the example above.

the call to f0 with a non-negative integer argument terminates.


A simulation is thus a set that is already saturated with respect to such a rewriting.

if we consider the statements of Lemmas 3.11 and 3.12 as inference rules for determining when a type is equal to 0, then ES is the set of immediate consequences of S , and a simulation is a self-justifying set, that is a co-inductive proof of the fact that all its elements are equal to 0.


The semantics of synchronization operations is parametrized by a predicate f and a function d, indexed by the operation s details.

thread t may perform synchronization operation op involving variable x so long as the heap satis.es the predicate fop,x,t;asa result the heap is transformed according to the function dop,x,t.If the operation requires additional parameters, they are passed to the function/predicate as needed.


RESEARCH METHODS In order to address the previously identi.ed research questions we follow the conceptual and constructive methodological approach.

the following steps are performed in the order listed.


In this paper we propose a technique for specifying pro.les within UML, aiming at a speci.cation and tool-supported enforcement of architectural constraints.

we show how pro.le speci.cations can be structured according to di.erent views on software architecture, and how a subset of UML can be used as a pro.le speci.cation language with a precise interpretation.


The question then arises, what are the real differences between programming using a statically type language and an untyped language?

what can be found in dynamically typed languagesto support the argument about being more powerful, and specifically more flexible?


Our contention is that a major prerequisite for self-management is the openness of systems [2].

to support self-management, it is necessary to have access to various aspects of the system infrastructure and to be able to reconfigure such aspects at run-time.


Here it is enough to say that, as usual in the automata theory, the aim of the equivalence check is to verify that S simulates C3 and vice versa, under a suitable notion of simulation (i.e., CB-Simulation).

s YNTHESIS automatically checks that S performs4 all the behaviors of C3 and vice versa.


In summary, we believe our aggregate score of 92% should notbetakentosay anything moreprecisethan there is a substantial effect .

this score does not al Code Base SubjectJ (hours) Java (hours) Difference SubjectJremodularization performed .rst (total hours = 63.4) Tetris 3.0 3.5 +17% TyRuBa 18.0 20.3 +13% JHotDraw 4.2 4.0 -5% Chinese Chess 3.8 6.6 +74% Sum(1) 29.0 34.4 +19% Java remodularization performed.rst (totalhours = 66.9) MineRay 0.7 2.3 +252% DrawSWF 2.0 5.8 +183% FindBugs 9.9 30.7 +210% JChessBoard 3.0 12.5 +325% Sum(2) 15.6 51.3 +229% Aggregatedresults (total hours = 130.3) Sum(1)+Sum(2) 44.6 85.7 +92% Table 4.


In addition to the basic .ow constraints from Figure 8, which propagate these taint seeds throughout the context code, we add new constraints to account for the subtleties described above.

to handle higher-order functions, we contravariantly (resp.


Indeed, a higher non-correlation probability entails more chances for an event ej to make obsolete a preceding one ei .

it is more likely that no events ek have been generated by other players which break the obsolescence relation among ej and ei .


However, these details are essential for accurate performance predictions.

the performance of software systems using message-based communication strongly depends on the underlying Message-oriented Middleware (MOM).


We add a type assignment rule permitting O to have any valid type, however we do not modify the predicate assignment rules.

this means that O must be assigned the predicate .. To formalise the notion of snapshot, we de.ne an ordering on approximate expressions: 3This is not strictly true, since we might also derive a method pred icate for a variable when it is mentioned in the environment.


Within aspect-oriented approaches,[8, 16, 18] propose solutions to deal with context-awareness atsource code level, without considering the more abstract designlevel.

these papers address the problem of dealingwith contexts defined as a history of events (called statefulaspects in [8, 18]), or with past contexts [16] that could affectthe present behavior.Some papers have also specifically considered how to adaptservice-oriented applications using an aspect-oriented approach.


Of course, the characteristics of research questions may be more comprehensive than in this study.

the synthesis and interpretation strategy chosen may bring some different insights, but we believe the underlying trends should remain unchanged.


The advantage of this intermediate language is a substantial simpli.cation of the implementation.

we no longer need to separately consider bounds on numbers of class instances or on collection sizes.


Constructive techniques are needed to guide requirements engineers in the incremental elaboration and assessment of requirements.

one should clarify when and where to shift from informal through semi-formal to formal; when and how to shift from scenarios to requirements models; when and how to shift from con.icting viewpoints to a consistent documentation; and so forth.


We assume that each cache state denotes a single cache set, where blocks are aged from left to right.

these states denote the RCSout of the predecessors.


Therefo ore, state changes are not instantaneous and information abou ut the new state may not be immediately available to other part icipants.

the participants do not share the same c clock and the state changes do not happen simultaneously on booth sides.


In addition, there is a preamble for copying values to temporaries and a postamble to commit the temporary values.

for each behavior we have committed values (x, y), .rst-phase values ( x, y), and temporary values for each of these (xt, yt, xt, yt).


These input artifacts are created using customized editors built using Eclipse plug-in facilities.

the CAD format has a textual editor, a graphical editor (to view sys- tems as graphs similar to style of Figure 1) 3, and a form- based editor that allows one to easily define different pro- jections of the component assembly (e.g., connections only, distribution and rate assignments only, etc.).


We use the priority inheritance protocol [17] to address the dependency between these two decoders and the X server.

the scheduler sets the scheduling priority of the X server to that of a decoder when the decoder calls the X library.


One or more agents can dynamically agree on a specific interaction pattern without them having any prior knowledge of the rules.

they can 'load' the politeness policies that are needed in order to take part in a conversation.


We note, however, that some of FRANC s unique features are advantageous when extending analyses to use adaptive instrumentation.

fRANC offers speci.c abstractions for pieces of analysis state.


Unfortunately, this shortened version of empty now always forces inspection of the second argument to $$, since function arguments are evaluated eagerly in a strict language.

our de.nition of empty has become too strict to be used in $$, which in turn has become too strict to be used in even right-recursive parsers!


(2) Our scheme needs to balance the bene.t (how much energy is saved) and the cost (how much .ash memory space is demanded).

it should identify and store the most valuable data in the .ash drive for energy saving.


Our results and .ndings con.rm that much of the data sync traf.c is unnecessary and can be avoided or mitigated by careful design of data sync mechanisms.

there is enormous space for optimizing the network-level ef.ciency of existing cloud storage services.


In order to cover topics throughout the book uniformly, and while they were still fresh in students minds, we had one-third of the students do each task in each round of peer-reviewed assignments.

for the first due date in September, we had one-third of the students do explanations, one-third do examples, and one-third do exercises.


We further examine how indexing contrasts to a simple tuple identi.cation scheme on real world races.

we examine previously discovered races in the MySQL database server [2] and the Apache HTTP server [1] as also explored in [21, 12].


We present two solutions, Basic Contributor and Enhanced Contributor that signi.cantly improve overlay multicast performance when compared with the Strawman solution, which does not utilize bandwidth resources at hosts behind NAT or .rewall.

internet experiments show that in the Slashdot event, Basic Contributor eliminates most of the rejections suffered by Strawman and Enhanced Contributor performs very well without suffering any rejections.


AGILE SOFTWARE DEVELOPMENT During the 1990 s, the agile approach towards software development started to emerge in response to problems in the software industry.

the agile software development approach, composed of several methods, formalizes software development frameworks which aim at overcoming characteristic problems of software projects (Highsmith, 2002).


to managing application systems at run-time.

policy rules guide a management engine to specifically re-configure the application system (e.g., allocating 30% more CPU to database tier) when a condition is triggered (e.g., request rate reaches 300).


.nding calls to error, then tries to prove that these calls will not be reached.

the one error call in risers4 is avoided under the precondition (see §3.4): risers4, x<-(:) all callers of risers4 must supply an argument x which is a (:)-constructed value.


These experiments support our conjecture that a dualmode protocol combining an epidemic broadcast of the entire message, along with a secure broadcast of short digest, may be su.ciently e.cient.

it seems plausible that a su.cient level of security can be achieved with a digest that is 1/10 the size of the original message, which would yield a slow down of less than a factor of 2 for providing Byzantine fault-tolerance.


Conceptual operations of interest can crosscut methods in one or more classes.

for one conceptual operation there can be n methods, and 1 method can be in n conceptual operations; i.e.


Sp2 )is a set ofstates (d1, ··· ,dn,y1, ··· ,ym) (respectively, (x1, ··· ,xn,c1, ··· ,cm))in Su such that for all possible valuations of (y1, ··· ,ym) (respectively, (x1, ··· ,xn))the valuation (d1, ··· ,dn) (respectively, (c1, ··· ,cm)) remains the same.

the image of s is a state predicate in Su.


To ensure .elds can be initialized to meaningful values, constructors are inherited only via induced inheritance, not via explicit ' inheritance.

the class T .C inherits constructors from T.C when T is a supertype of T ', but not from other superclasses of ' T .C.


[16] allows arbitrary memory locations to be treated .ow-sensitively, which is complicated by the combination of aliasing and mutation.

allowing the quali.er of a value to change .ow-sensitively requires proving that the value is not aliased (is linear ).


As a result, the events of e cannot be used for the same purpose as the events of EScala.

events can only be used as some very primitive form of join points.


The framework is designed so that each player has autonomous authorisation for the distribution of resources controlled by that player.

every player has ultimate responsibility for its own resources.


On the other hand, the stakeholder of the E-Media system need to make sure that the system will always be available for customers to buy, it can confirm the involvement of an entity in certain communications, and it can prove the identity of an entity.

the main security objectives from the e-media s stakeholder point of view are availability, non-repudiation, and authentication.


INTRODUCTION The concept of awareness, characterized as an understanding of the activities of others to provide a context for one s own activities [1], has been researched in the field of ComputerSupported Cooperative Work to facilitate coordination in group activities [2, 3].

in being aware of the activities of team members, an individual can relate their own activities to those of their colleagues, enabling them to identify and address a variety of coordination problems [1, 4].


In Figure 2, we have sorted branches by their bias and plotted the Pareto optimal trade-off between correct and incorrect speculation.

as we move away from the the origin, we are speculating on an increasing number of branches, yielding more correct speculations (y axis) as well as more misspeculations (x axis).


In this case, all the attributes covered by o2 are also covered by o1 .

for two objects o1 and o2 , if o1 = o2 then the row corresponding to the object o2 can be safely removed from the context table without affecting the size of the minimal subset of test suite that covers all the requirements.


APPROACHES TO DYNAMIC LOAD BALANCING Dynamic load balancing for distributed simulations has attracted much attention in the last two decades due to its potential for improving the performance of simulation execution.

it has been studied extensively in the context of both conservative [5] and optimistic [6-8] distributed simulations.


It is well known that the provision of general .xpoint recursion as is captured by the function .x from Figure 1 requires all rela tions used in the de.nition of the logical relation to be admissible.

in the inductive case for the .-type constructor the quanti.cation of R must be over admissible relations only.


2.3 Modeling We used Support Vector Machines (SVM) in order to build a binary classi.er.

we used the SVM implementation packaged in the e1071 library of the R statistical tool.


After executing a ctx instruction, the thread gives CPU to other thread (in a round robin manner) and is ready again.

it can resume execution as soon as the CPU schedules it again (after finishing one round of round-robin).


R1 and hence we need not discover R1 as i=1 there are other races (Si) that will be found.

the set UncoveredCandidates is the set of all races minus the set of races which satisfy the above conditions.


IMPLEMENTATION In addition to experimenting with VM programming and running VM programs on the supplied VM Emulator, students can also be guided to implement the VM abstraction.

they can be asked to realize the stack, the virtual memory segments, and the VM language on a given hardware or software platform.


From Decomposition to Composition  We want components to be combined in multiple ways into subsystems, and subsystems in multiple ways into systems.

we want composition rather than decomposition (see Figure 10), or a graph rather than a tree as design hierarchy.


While our approach allows a programmer to de- termine when updates will occur, much work remains for de- termining where such safe points lie.

things get more complicated with multithreading.


In order to implement the desired semantics these object must be organized to formally encode the relationships between tags and members that the semantics depend on.

we need to represent the following relationships between the abstract states that the tags represent: 1.


More concretely, we may require instances of Graph.Edge to hold references to instances of Graph.Node, and instances of CWGraph.Edge to hold references to instances of CWGraph.Node,as alsoargued in Ernst [12].

cross-group references such as an instance of CWGraph.Node being a source node of Graph.Edge must be disallowed.


The length of CruiserList is close to the count of live buffers on heap.

the percentage of dated nodes and zombie buffers is low, and on average it is negligible.


3.1 Identifyingdataobjectsbelongingtothesamememory block At compilation time, we know each data object s offset relative to the stack base pointer, but cannot determine which group of data objectswillbeloadedintothesamememory blockduringruntime.

we need to know which group of data objects belong to the same memory block.


This is because Briggs allocator coalesces nodes in the interference graph conservatively.

it coalesces two nodes only if the coalesced node has fewer than K significantdegree neighbors.


With reference to Figure 3, d(01000) = d(01010) = d(100) = d(1000) = d(10000) = d(10001) = 1, whereas other occurrences have depth 0.

d(0100) = d(0101) = d(10) = 0; what matters in computing the depth of an occurrence is the number of  s that precede strictly the end node.


This project is woven with the project based code, generating static and dynamic warnings or errors, supporting developers in the process of debugging and testing.

eclipse allows the violated static rules to be shown as markers in the left hand side of the code editor, providing guidance, when declared as warning, or preventing code compilation, when declared as error.


We apply a conservative approximation and eliminate all loops in our implementation i.e., every loop is unrolled exactly once.

every loop is treated as a conditional branch, except that nothing is present on the else part of the branch.


The number of prepaged pages to be evicted is the number by which the prepaged queue would exceed its target allocation after adding those f pages.

pages are evicted from the prepaged queue only if it would otherwise exceed its target allocation.


Firstly, it justi.es the need for a tracer driver in order to be able to ef.ciently integrate several dynamic analyses within a single tool.

it emphasizes that both synchronous and asynchronous communications are required between the tracer and the analyzer.


S, it must be the case that: * (s0, )) 9-.

(s, g.) for some stack g.. G a Dyck state graph is equivalent to a rooted pushdown system in which there is a legal path to every control state from the initial control state.4 We use DSG to denote the class of Dyck state graphs.


Given two disjoint relational schemas S (source) and T (target), a source-to-target dependency (std) is an expression of the form .s(¯x, y¯) .

.t(¯x, z¯),where .s is a conjunction of atoms over S and .t is a conjunction of atoms over T. If we have a source schema instance S and a target schema instance T , we say that they satisfy the above std if (S, T ) |= .x¯.y¯(.s(¯x, y¯) ..z.¯t(¯x, z¯)).we assume that new variables on the right are quanti.ed existentially, and the others are quanti.ed universally.


We instantiate the random oracle in the construction of [15] with the hash function h from Construction 3.1 applied to the permutation p given by Assumption 1.1.

on input Ix and randomness R, the obfuscator O computes (R, .)


To summarize, for the majority of methods, it makes sense to optimize on the server especially if we can avoid waiting for the server to optimize.

serverOptNoIdle is the con.guration of choice.


Thus, we aim to investigate the relationship between methodologies and the problems within the context of game design and evaluation.

we will run several workgroup sessions using real-world selected problems identified by experts in the field.


Results so far are also quite promising.

in these practical applications, the false positives which in principle can appear were not a signi.cant problem.


Static analysis is based on the abstract interpretation [6] of program behavior and typically overapproximates the set of program behaviors.

* This research was supported by The Israel Science Foundation (grant No 304/03).


2.5 Lazy Allocation Our observation is that many Java applications do not access different portions of objects uniformly.

some .elds are accessed much more frequently than the others.


Typically, the debugging task is most complex when the property refutation happens much after the root cause for failure.

the incorrect statements lead to a long chain of causal consequences through the statements executed subsequently, eventually leading to the failure of the property.


Finally, the wellformedness of the system is preserved under execution.

if the initial con.guration of the system is wellformed, it remains well-formed after the execution of an expression.


After that, we select two virtual processors vi and vj and construct a new mapping p ' fromp asfollows: ( p(v), if v .vi,vj; = p ' (v)= p(vj), ifv = vi; p(vi), ifv = vj.

we obtain a new mapping p ' by swapping the target physical processors of virtual processors vi and vj.


Methodology: We implemented the U-MAP system such that all of its new features can either be enabled or disabled.

we refer to the following four features: merging sibling relations (MSR), aggressive chase (AC), attribute grouping (AG), and usage-based con.ict resolution (UCR).


Itis evident from the illustration that the safe zone induced by the distant referencevectorincludesthesafezoneinduced by the estimate vector.

any drift vector that creates a monochromatic sphere with the estimate vector creates a monochromatic spherewith the distant reference vector as well, but there is also a large set of drift vectors that createamonochromaticspherewith the distant referencevectorbut not with theestimate vector.


The key axiom is that v if a1 = a2read(write(m, a1, v), a2) =read(m, a2) otherwise To successfully verify low-level code, we have found it necessary to model memory layout accurately.

when verifying software written in a high-level language, arrays are often assumed 1The relational translation may remind some readers of the wellknown static single assignment (SSA) form [13], but recall that the simulation is of a dynamic execution trace.


The linearization point of .nding the list empty is the reading of *head in line D1.

it is the linearization point of all Delete and Search operations that return false after .nding the set empty.


Be CPU conservative: This kind of program analysis is fully tractable.

there is no concern that the annotation will require some unbounded amount of time.


Seeker statically analyzes B6 and suggests B4 (in the Compute method) as a pre-target branch that could help cover B6.

the sequence that helps cover B4 can be leveraged to cover B6 as well.


Design errors are separated from implementation errors.

this reduces the level of expertise required in order to use (or reuse) a component correctly, inside or outside of a pattern.


This fast speculative execution support allows the CMS to perform data and control speculative transformations when it believes it is bene.cial [35].

a commit instruction is used to specify the successful execution of the previous speculative translation and the beginning of a new one.


Thus, the semantics of the abstracted program should approximate the semantics of any such concrete version.

any behavior the concrete program exhibits should also be exhibited by the abstract approximation of that program.


In more concrete terms, here are the rules implied by strict separation: 1. the view cannot modify the model either by directly altering model data objects or by invoking methods on the model that cause side-effects.

a template can access data from the model and invoke methods, but such references must be side-effect free.


The impact analysis derives the values of output metrics IArun , IAwait , and IAopt from the preceding metrics.

iArun = Drun /Dscn represents the performance impact of running time, and IAwait = Dwait /Dscn represents the performance impact of wait time.


Trait composition is declarative in the sense that the ordering of composed traits does not matter.

unlike mixin-based or multiple inheritance, trait composition is commutative and associative.


By default, an observing command can be .red only once.

once the response action is executed, the observing command will be automatically deleted from the system.


In SRS, we take advantage of the self-cleansing property in server programs to isolate the faulty user request from other succeeding benign user requests, without checkpointing or rollback.

in SRS, when a crash occurs, we do not rollback state to a previously saved safe state; on the contrary, we suppress the crash and execute forward.


The user can not take any further actions until the request is served, processed, and visualized.

there is atomicity between what the user triggers and what she sees.


Nevertheless, we don t observe this impediment since instruction sequences of most bytecodes do not exhibit high ILP.

instructions are in the critical paths and executed sequentially most of the time.


As a matter of fact, LazyFTL treats .lled cold blocks in the CBA and .lled update blocks in the UBA in the same way.

the relative size of the CBA and the UBA can be adjusted dynamically.


One thing that both distributed objects and remote evaluation have in common is that they assume an existing language and implement distribution as a library.

they don t consider what kind of language changes might be useful for distributed computing.


In contrast, had the developers always executed all available tests, we estimate4 that it would have resulted in a total test execution time of 23,806 minutes.

had the developers not performed manual RTS, their test executions would have taken about an order of magnitude more time.


We notice better performance for higher error thresholds.

we observer that the RMS error remains at a reasonable level for upto 600,000 time units for 3% error threshold.


Extending the idea, any two channel buffers can be allocated toallow sharing of physical memory locations (space) as long as the two buffers do not con.ict in time.

the two buffers must not need to maintain a token at the same memory location atthe same time.


Furthermore, Wrangler introduces a notion of a con.dence measure with these predictions to overcome the modeling error problems; this con.dence measure is then exploited to achieve a reliable task scheduling.

by using these predictions to balance delay in task scheduling against the potential for idling of resources, Wrangler achieves a speed up in the overall job completion time.


In a nutshell, all anti-degradation rules are translated to Prolog queries that use static source code information stored in the knowledge base to check their conformance.

we decided to focus on Java systems to evaluate the feasibility of our approach.


Examples of behavioral situations are: Compared to home care systems, outdoor living assistance systems have to cope with the following additional problems: While the type of context information collected via sensors in the home area is well defined based on body vitality checks and behavioral information, this is not true for outdoor living assistance.

outdoor living assistance systems may acquire context information that describes unforeseen situations (traffic jams, etc.).


Typing rules for .AC a Vect and its length.

the types we use express the relationship between values and their type and context membership.


However, modeling is mostly creative work, and sadly, current high end modeling tools do not support this very well.

they support the actual modeling work only partially.


One optimisation that we use in both candidate creation algorithms is to eliminate all the potentially corrupt bytes that do not interact with the last constraint, either directly or indirectly.

we compute the transitive closure of the constraints dependent on the last constraint; any bytes not involved in the transitive closure can be left unchanged in the .le.


In this paper, we develop a technique to apply n-wise testing in the model-based combination testing method, FOT.

we develop a technique to construct a test-suite for the n-wise testing from the test model represented by T(mex, req) in FOT.


The result of template instantiation may not be well-formed with respect to the target notation.

the result may violate the multiplicities of the metamodel and/or the additional OCL constraints in O.


This language can integrate a re.ective mechanism (analyzing an input program to extract its elements) with program generation.

the language can de.ne iterators over existing programs.


Also, in many cases the source of a class needs to be changed in order to let it use another class than it currently does.

classes are most of the time not programmed in a way that they offer extension, or rewiring of their dependencies.


During construction and deconstruction of an object, the value of a given vtbl-pointer may change.

that value will re.ect the fact that the dynamic type of the object is the type of its fully constructed part only.


Between these points, all operations are executed atomically.

it is easy to use safely shared mutable datastructures, such as hash tables, without using any lock.


Therefore, it is important to ensure that these artifacts are created as expected or defectfree.

it is necessary to detect and remove defects in the artifacts in time during various development phases.


i = .i/V (N ), (5) which expresses the percentage of the total value of the federation attributed to facility i.

following the Shapley value scheme, si = .


5.5.1 Implementation issues Some students were confused because continuous testing tool .ltered out some information from the JUnit output before displaying it.

it removed Java stack frames related to the JUnit infrastructure.


The second phase reads in all of these (object) files, unifies nodes corresponding to the same symbol or function from different object files, and reapplies the propagation step to obtain global points-to information.

the analysis algorithm is first applied to individual files and the internal state of the algorithm (which in this case is a points- to graph, and symbol information) is frozen and written to a file.


The dotted lines in Figure 4 are used to join concurrent links.

the two links leaving node so are concurrent, whereas the two links leaving sl represent a decision choice in which attackers have to chose from two available attack continuations.


Certainly, all three cases focused on the technical dimension of the system.

they make certain functional or operational aspects of the software system visible to enhance performance or usability.


If the complexity of today s computing infrastructure and of modern software introduces new problems for software engineers, however, it also provides new opportunities that may help in addressing these problems, if suitably leveraged.

many of today s software systems are deployed in a large number of similar (when not identical) instances, used by a multitude of users, and executed on powerful computers that are mostly interconnected.


It di.ers from our approach in that it neither supports hypermedia nor the ability to map proxy method calls using dynamic information.

in the RESTeasy Client Framework, proxy method calls are mapped to HTTP requests exclusively using static annotations.


The .rst is that nodes of the network are unlabeled.

we seek rendezvous algorithms for agents that do not rely on the knowledge of node labels, and can work in anonymous graphs as well (cf.


In particular, when 7 threads are allowed, for vortex and perlbmk, the best speedup is achieved by only using around 4 cores on average.

the main thread normally cannot .nd more than 4 versions with VCs above the threshold at runtime and hence saves the extra 3 cores without sacri.cing performance.


xf } (Not-Write-Fields) a variable or .eld must not be read (resp.


Otherwise, the function exploits a mathematical identity of the discrete Fourier transform, namely that it can be expressed in terms of two interleaved Fourier transforms of half the size of the original.

the input is split into two parts: one containing the samples with even indices and another containing the samples with odd indices.


To balance accuracy and coverage moderately, we combined our social recommender system using discovered communities with existing collaborative methods, called a hybrid approach.

if a user belongs to a community, a social recommendation algorithm is applied, otherwise a collaborative algorithm is applied.


On the other hand, if p1 was introduced before the collection started, then the corresponding object would have been marked as reachable in the root scanning phase.

at the time pointer p2 is introduced, the object is already guaranteed to be marked as reachable.


tended to hold for all possible environments.

to satisfy a speci.cation, the system should guarantee that all its runs satisfy the speci.cation, regardless of the environment s choice of assignments to input variables.


As we know, each model needs to advance time to progress the whole distributed simulation.

in the Type II IRM, the requested time forwarded to the RTI is possibly associated with a slight increase represented by the hidden fields.


As it will become apparent shortly, pipelines and other types of splitjoins do not need to make substitutions to the internal nodes of the AST to satisfy property (1), and therefore are not affected by this stage.

this transformation is not needed when compiling DropThird because DropThird has no splitjoins.


In the above listing the updateMetaInformation() only has effect on the first usage of this particular method.

the first usage per update of this method, because it needs to maintain an indirection level of one.


Rn is a new test or query document, then from (2) it follows that our binary classi.cation function is: T T f(q)= xopt Aq.

(6) given a new document q that we wish to classify, if f(q) > 0 then q is classi.ed as belonging to the class in question, and not otherwise.


17 due to fewer processors scheduled, resulting in lower cost.

the adaptive mapper selected only nearby processors for the robot task: only 4 of the 8 processors are used in linear array, so are only 5 of the 7 processors in the tree topology network scheduled.


The recovery procedure consists in sending ConstructionLink ants to other known neighbors of ni in order to reestablish proper connectivity among them.

ant agents try to connect all nodes with a minimal number of links by using a ring formation.


We believe, however, that the dif.culty of the programmer s .nal task is best measured by the number of candidate locations they have to understand, and not simply the total number of source code lines.

the number of source lines highly depends on the idioms the programmer uses rather than the fundamental nature of the candidate computations: a relatively simple sub-expression may span two or more lines of code or a complex computation may be expressed in a single compact statement.


We discuss work-in-progress to address these scalability limitations in the Semantic Web by designing and developing SHARD using the MapReduce software framework.

we describe initial results from deploying an early version of SHARD into an Amazon EC2 cloud [1] and running the standard LUBM triple-store benchmark.


Traditionalparsingsystemssuch asYACCgenerateparsersfrom declarative speci.cations; however, they are not particularly well suited for writing data descriptions.

such systems generally require users to write a separate lexer and construct inmemory data structures by hand.


More speci.cally, my contribute will be the de.nition of a middleware characterised by mechanisms that enable an e.cient asynchronous delivery of messages also in presence of intermittently disconnected clouds of hosts in the systems, by evaluating the available context information and predicting the evolution of the mobile scenario.

we agree with the current research trend which states that a cross-layering could be an e.ective way of designing more e.cient middleware for mobile computing [3].


Veri.cation is then tackled for the input-bounded version of the linear-time logic considered in [113, 114], extended with the possibility of referring to the previous input.

decidability of veri.cation for this logic over an input-bounded web service is decidable in EX P SPAC E (in fact, PSPAC E-complete when the arity of the service schema is bounded a-priori).


This sequence contains the initial values for the formal parameters of the program, and the sequence of values supplied by the environment whenever the program asks for input.

in addition to input values, the test vector also contains a sequence of return values for external function calls.


However, apart from the cross-functional work on design, the teams largely tended to work separately.

each team looked at the technical specifications provided by development, and created their own information, test, or usability plans, then worked toward the goals outlined in their individual plans.