Furthermore, we would like to address these issues within the boundaries of the syntacticsugar approach.

the translation should produce only valid (well-formed and well-typed) Haskell code.


Consistency is one such benefit, though users may be more in favor of it than manufacturers.

manufacturers may object to consistency because branding may be removed from interfaces, and, worse still, branding from a competitor may be added in its place.


the gathering of data should cover more programs and be more systematic.


Although the user does not explicitly mention the word loop , it would be her intention to use a loop.

smartSynth detects that there is a relation between the group {Joe, John} and SendMessage.NumberI , and generates a loop to send messages to both Joe and John.


The reason is that non-singleton sets are mostly caused by Boolean OR operations or nonstructural control .ow.

the value range of a counter we need for non-loop predicates tends to be small because they only need to distinguish elements in small sets.


Currently, the packages delivered in clinical fields may have a software component, but this software is part of the clinical domain, targeted to professionals providing treatment support.

the clinical software used has little or nothing to do with daily-living software applications that many of us take for granted, e.g., email, web browsers, digital photography tools, music-management tools, trip-planning tools.


if one replaced in Example 4 the references to symmetric monoidal structure systematically by references to symmetric monoidal structure for which the unit is the terminal object, as in Example 3, one would obtain the untyped contexts of the Logic of A.ne Bunched Implications [22].


(We note that a situation resides at the middleware tier.)

the faulty triggering condition is (E f -Ev > e).


That is, if s and s ' are two states resulting from any two executions of P from the same initial state, then Post(s, s ' ) holds.

the above construct could be rewritten in the following way: deterministic assume(s0 == s ' 0){ P } assert(Post); if any two executions of P start from initial states s0 and s0' , respectively, and if s and s ' are the resultant .nal states, then s0 == s0 ' implies that Post(s, s ' ) holds.


A network processor is typically implemented as a singlechip multiprocessor with high-performance I/O components, which is optimized for packet processing.

nPs provide a more suitable architecture to handle these workloads than conventional workstation or server processors.


To address this potential issue, we performed a code analysis on the versions that we used in the experiment.

we investigated each inheritance class hierarchy and ensured that our selected change tasks cannot be completed by creating new subclasses of an existing hierarchy without replicating various existing codes in these new subclasses.


The infrastructure of typical hospital environments is currently mostly device-oriented.

the components implementing a work.ow are statically deployed to .xed devices, which leads to overcapacity due to suboptimal usage of resources (resources are reserved for particular work.ows, even if not used); in.exibility in reacting to events; a multitude of deployment and maintenance scenarios; but above all, it requires users to go to the device that supports a particular task.


4 This condition is stricter than necessary.

an antidependence edge in Gi with no path connecting the edge nodes implying that the the antidependence is formed over a loop revisiting Gi is safely contained in Gi.


The major idea of proposed scheme is integration between the debugging/monitoring techniques of emulator and the interface testing describedin Section 2.

our scheme enables automatically to identify the interface, to generate the test cases covered the interface test, andto execute the test cases ontheemulator.


In addition, we would like to further investigate the modularity and composability of editor libraries.

we would like to explore scoping mechanisms for editor libraries that retain composability while providing clearer interfaces for explicitly coordinating services with staged editor libraries.


Regression test suites are an important artifact of the software development process and, just like other artifacts, must be maintained throughout the lifetime of a software product.

testers often add to such suites test cases that exercise new behaviors or target newly-discoveredfaults.


The protocol does not require the knowledge of N or n for operation, and it can be extended to items with different weights or storage costs.

this load balancing protocol can be used to store ordered data, such that the items are not hashed, but mapped to the DHT address space in an order-preserving way.


Since we separate the lexers and their speci.cation, the contract system does not have enough information to track the error back to the language lexer implementation in case of a contract violation.

from the perspective of the contract system, the contract dep-lexer/c is not between an untrusted lexer and its clients but rather between the contract region labeled new-lexer and its context.


Mutation testing su.ers from the problem of equivalent mutants [67].

mutants are generated syntactically by altering the source code, but this may not have any semantic e.ect, leading to a mutant that is syntactically different, yet semantically equivalent, to the original program from which it is constructed.


Our next goal is to deploy this system in a much larger and more realistic environment.

discussions are currenly underway to deploy CenWits in the Rocky Mountain and Yosemite National Parks.


The proposed scheme applies di.erent quantization step-sizes according to the magnitude of messages, where it uses the larger quantization step-sizes for the larger magnitudes of both intrinsic and extrinsic messages.

if the magnitude of message, |x|, is less than 2(q-f-3), then the message is quantized with (q : f) uniform quantization and its quantization stepsize is 2-f .


The term entrepreneurship was used, the concept, for the first time, by the economist Joseph Schumpeter in 1950, it was used to sinonim of a creative person that is Able to make a successful innovations.

entrepreneurship is a term used to describe or Specify, that 'an individual who holds a special way, innovative Activities, organizes and runs the business fits That Their interests and capabilities [6].


This declarative definition for problem-solving facilitates the knowledge acquisition process and allows the exploration of such knowledge through, for instance, explanation about the system reasoning process to solve problems [19].

the resulting AUI presented to the designer can be negotiated using an explanation mechanism that provides information concerning the steps taken to achieve the solution and other possible ways to reach different results.


It should be noted here that the WSN proxy is a single point of failure in this architecture.

if the WSN proxy is, for any reason, not available, then the entire sensor network is no longer reporting to the CMS.


QualityObjects (QuO)[7]provides a middleware platformsupportingtheexecutionof distributedcritical applications.

quO provides the ability to specify, monitor, and control aspects of the QoS in an application, and to adapt to changing levels of QoS at runtime.


Policy V, however, is fundamentally limited because how it determines the energy contribution by a software principal depends on how it estimates the system energy consumption.

the estimation can only consider resource usage that can be attributed to individual software principals; and the estimation must employ a linear model.


We propose to erase any block that stores the block remapping table with a two-step operation.

we should erase and update data to one block (for information updating) and then to the other block of the same block set (for information duplication).


The computation of all the clusters in C amounts to finding all the maximal subgraphs whose nodes are mutually strongly connected (whose edge s weight is = T).

if one creates a new graph G by removing all edges whose weight is < T from G, then the search for the clusters is similar to finding the largest complete subgraphs (maximal cliques) in G .


Preemptive vs. non-preemptive execution On GPUs, executions are often non-preemptive [14].

once a kernel starts execution on a GPU, it cannot be preempted by other kernels until its completion.


Micro-services make our architecture .exible and scalable since services can be changed dynamically according to users objectives.

if a service does not achieve a desirable performance in a given cloud provider, it can be deployed in another cloud provider without requiring service restart.


Its primary goal is to resolve human-readable host names, such as cnn.com to hosts IP addresses.

hTTP clients send queries for these resolutions to their local DNS servers (LDNS), which route these queries through the DNS infrastructure and ultimately send them to authoritative DNS servers (ADNS) that maintain the needed mapping information.


Moreover, lock time of BT with Solaris is 88%, lock time with Shu.ing is 74%.

with Shu.ing, there is 42% reduction in LLC miss rate and lock time reduces by 14%.


We apply this idea also with respect to the management of general agile software development projects.

in the teams with which we work, in addition to being a software developer, each team member plays an auxiliary role on their team.


Like most OO languages, Racket also contains stateful operations.Ingeneral,the combination ofpolymorphic contracts and state requires some care to ensure soundness.

the precise timing for key generation on seals is crucial.


One observation in favour of an event-driven approach is that modern device drivers are already partially event-driven for performance reasons.

all performancecritical I/O requests are completed asynchronously: upon receiving a request, the driver adds it to the hardware queue and immediately returns control to the caller.


Our results show that D OCREF detects more than one thousand detected real bugs that are previously unknown.

48 reported bugs were con.rmed and .xed by developers of API libraries within two weeks after we reported.


Alice ML is an extension of Standard ML [16] that has been speci.cally designed for open programming.

alice ML features a .exible system of components [25] that can be exchanged between processes as pickles.


given directly in requirement) or implicit (de-rived) are consistent, but may not be complete.

not all accesses for all subjects and Use Cases may be specified.


In both cases, the potential for the CakeML system to behave badly is limited to signalling a type error on a declaration that the programmer expected to pass type checking.

there is no possibility for the programmer to be deceived by the system appearing to returning an erroneous result of executing the de.nition.


2 This semantic model, however, is not su.ciently rich.

signals cannot have multiple values at the same 2A discrete subset is one that is order isomorphic to a subset of the natural numbers.


Figure 5: Initial Interaction Design Behavior Excerpt  4.3 Enactment of Macro-iteration Correcting this and the other .aws in the interaction design detected through the heuristic evaluation led to a macro-iteration, following the Integrate Interaction Evaluation Results path in our process.

an interaction designer added another loop into the Discourse Model of the interaction design to correct the confusing behavior described above as suggested by the usability experts.


The puzzle is: How many unique yearly calendars are there?

consider entire yearly calendars printed on cards by institutions such as banks etc.


Second, rather than conceptualizing a single relationship between leadership and motivation, our study has shown through both theoretical justification and empirical evidence that different forms of leadership could have differentiated impact on different motivations.

we posit and observe that transformational leadership (i.e.


Only a top-to-bottom traversal is enough.

for a structure container node in the hypertext network, find the resource versions it contains, and check out all these containees recursively.


Also, the suggested approach highly relies on the estimation performance of TARANTULA fault localization technique.

if the technique wrongly estimates the location of faults, FATCP cannot guarantee the reliable performance.


The invariants of these functions are then matched against a library of known data structures, providing a probable identi.cation.

dDT uses program consistency properties to identify what data structures an application employs.


We quantify the system requirements and its bene.ts in terms of download times.

we show that coding is feasible and incurs little processing overhead at the server and the peers (§4.6).


For completitude, we extrapolatethecurvetotheborders, butobservethatthedataare accurateand used onaninternal region([1%, 15%] for LR, and[1, 4] for the MLBS).

we can observe that quality is monotone in the two variables, and particularly increasing with the MLBS, meaning that humans prefer sequences where losses are concentrated over those where losses are spread through the .ow.


SCHEDULING Building a sequential control-.ow graph from a program dependence graph requires ordering the concurrently-running nodes in the PDG.

the children of each fork node are semantically concurrent but must be executed in some sequential order.


Note also that this algorithms .rst tries to compress as many SPM-resident blocks as possible, before starting to send blocks to the off-chip memory.

it utilizes the SPM space as much as possible.


The main di.erence between CloudScale and those commercial SaaS and PaaS solutions is that, when using CloudScale, developers retain full control over their application.

even though CloudScale hides some scalability-related issues from developers, they are still free to customize the way CloudScale works to their own needs, either by implementing custom scaling policies, adapting the CloudScale framework itself, or managing some COs in the application manually.


Similar reasoning can be used to show that the notion of a data race, as de.ned above, is equivalent to an interleavingbased de.nition.

if there is an execution with a data race as de.ned above (a type 2 data race in [2]), then there is an interleaving of the actions of the threads, such that no two threads hold the same lock at the same time, and the racing statements appear adjacent in the interleaving (a type 1 race in [2]), so that in a realistic setting, they might have executed concurrently.


In order to guarantee the desired budget ei to each job Ji, j the scheduler must actually budget ei +WCRT.

in order to guaranei (ei+WCRT) tee utilization ui = we must reserve utilization ui' = .


i=1 Obviously, it holds 0 = D(v1 ,v2 ) = n. Because the vectors v are randomly generated by RT1, we can consider D as random variable with the vector of probabilities pi as parameter.

in other words,given aparticularSUT with speci.cprobabilities pi for the testingtargetsin T, we wantto studythedistribution ofthe random variable D. we are interested in its expected value E[D].


As the table indicates, the overheads ranged from 0.31% to about 0.96%.

the runtime overheads attributable solely to hardware performance counters were under 1%.


, an) 1 : k = i or k = j where ak = { 0 : otherwise Given this notation, we de.ne for each wi, wj E W the following interaction predicate I1.

true : E(sij ) - E(si) > threshold, and I1(wi, wj ) = E(sij ) - E(sj ) > threshold false : otherwise si is the compiler setting which turns on optimization wi, sj is the compiler setting which turns on optimization wj , and sij is the compiler setting which turns on both wi and wj .


Scheme-VI: This scheme considers all cache layers except for the last one.

in Dunnington, it decides the weights by considering L1 and L2 layers only.


As overall impression, they both said they liked the prototypes and that the requirements identified during the analysis phase were correctly interpreted.

they appreciated that the system reflects the steps of the process they adopt in their work: 1) search, study and composition of heterogeneous information coming from various sources; 2) information revision, and 3) public disclosure.


In order to derive this information, we need to implement some of the functions that are necessary for network operating systems.

we need to consider realistic network processing applications, their partitioning, and the mapping of processing tasks to processing engines.


Note that no pages are mapped at all when execution begins; the system relies on page faults to force them in when needed.

the very .rst call to execContext will always cause a fault on the page containing the initial eip address.


BOP executes PPR instances in a pipeline and shares the basic property of pipelining: if there is an in.nite number of PPRs, the average.nishtimeis determinedbythe startingtimenotthelength of each speculation.

the parallel speed is limited only by the speed of the startup and the size of the sequential region outside PPR.


We .rst need to establish some terminology: De.nition 9 (Undirected path) For a directed graph G and vertices v1 and v2 in G, an undirected path from v1 to v2 is a path from v1 to v2, in which we are not required to follow the direction of the edges.

an undirected path is a path that exists when we pretend that the underlying directed graph is undirected.


However, the effective number of floating-point registers in Cherry is larger than the actual size of the register file 50% of the time.

it is more than twice the actual size of the register file 15% of the time.


The conditions of symmetry and full distribution are inter- esting also for practical considerations: in several cases it is desirable to consider systems which are made of copies of the same components, and have no central control or shared memory.

symmetry offers advantages at the level of reasoning about the system, as it allows a greater modularity, and at the level of implementation of concurrent languages, as it allows a compositional compilation.


A bundle is a group of classes and bundles can invoke each other for realizing services.

bundle A can invoke an implementation class method provided by Bundle B.


Finally, in order to preserve the consistency of the routing information, we assume that the elapsed time between two consecutive migrations of a subscriber s (to broker bj and then to broker bk) is greater than the upper bound of time required to propagate a message from s to bk using bj as its front-end broker.

the migrating subscriber cannot move faster than a message it emits, which is not a severe constrain in practice.


This paper describes our two years experience in designing and implementing SMILE-JS, the first SIP-based middleware for J2ME CLDC enabled devices, exploiting the open source MjSIP SIP stack [11].

section 2 provides details of SMILE operations and APIs, section 3 deals with transport of messages in SMILE-JS, section 4 discusses serialization of messages in J2ME.


Therefore, in the following, we analyze the di.erent kinds of variability present in the Core Component approach.

the analysis is performed independent from any particular variability language.


Fig 8 shows an algorithm skeleton of the invoke loop splitting function invoked in Fig 7, which serves to remove conditionals, e.g., those tagged with the split at begin and unroll check relations in Fig 4, from inside loops, by splitting the surrounding loops whose index variables are involved in the conditionals, so that the conditionals become either always true, in which case the check can be removed, or always false, in which case the entire conditional together with its body are removed.

step (1) of the algorithm removes all conditionals introduced by loop blocking by identifying each outer blocked loop that has been tagged with a symbolic name, e.g., n1, with some loop in its body tagged with tile(n1), and its body contains at least one of the relational tags, split at end(tile(n1)), unroll check(tile(n1)),or split at begin(tile(n1)).


The Oz language and the associated Mozart Programming System is another admirable combination of multiple paradigms [64], with applications in functional, concurrent, and logic programming.

oz supports a form of logical variables, and logic programming is enabled through uni.cation.


The M0assertional knowledge and the terminological axioms representing the M1 model were automatically checked by v a Description Logics reasoner to be non-contradictory .

quali.ed cardinality restrictions were used to check minimum-cardinality constraints de.ned for UR-DAD modelling constructs like that a requirement is required by one or more stakeholders (the unique name assumption is enforced for ontological individuals to prevent the reasoner from inferring their identity).


We found that the equational theory and the method speci.cations were not equivalent and none of them contained stronger speci.cations than the other.

while proving either direction, some lemmas could not be proven without strengthening some of the axioms or adding new ones.Four additional equations had to be added to the equational theory and one postcondition hadto be strengthened in the method speci.cations in order to prove their equivalence.


in each round, each node v is allowed to send a message of size O(log n) through each edge e =(v, u) that is adjacent to v. The message will arrive at u at the end of the current round.


Note that in this example, no specific (AM) elements are specified in the pointcut.

at specification time, it is not known which elements will or will not have an hasAgeRating property.


There exist some unusual grammars that are not relevant for any data, but can be extracted by IDEALIZED ANNE.

iDEALIZED ANNE can extract grammars with disconnected nonterminals.


The second assumption is intended as an assertion on the network realization.

if the network is realized through sensing or broadcast communication, it is assumed that the out-neighbors receive the same information.


We found that the choice of hardware platform greatly determines where accuracy is needed.

on some hardware platforms, such as the 64-bit Alpha, accuracy is not important for reclaiming objects.


This constraint is enforced when the cSubject interface is implemented.

a class implementing cSubject must satisfy the following constraints: 1) three public methods getState, setState,and notify must be de.ned; and 2) notify must be called under the control .ow satisfying the above constraint.


In our experiment, we seldom encounter this situation, because even though some apps indeed use re.ective calls, they are rarely located within the taint propagation slices.

these re.ective calls in general are not involved in privacy leakage.


The recent rapid advances offered by HTML 5 seem to have opened the road for web-based applications that will work seamlessly on any HTML 5 compliant web browser, on any mobile device.

we present some of the most important features of HTML 5 organized in different categories and their contribution in the deployment of MCC applications.


Our goal is then to show that this extra administration at the start does not get in the way of evaluation.

we can show that any administrative equality can be deferred past a proper standard reduction while still retaining a non-trivial reduction sequence.


Both clusters were in the middle of heavy read activity.

a had been sustaining a read rate of 580 MB/s for the preceding week.


For generality, we would like weak requirements for isEq.

we would like to admit call-by-value re = specting equivalences, since the operational semantics of .


This is guaranteed to produce the right frequencies for the contentsof rangesof rolesusedin frequency constraints,since for each such range RA, ..., RK , we have r = fmax · rab...k, or r/rab...k = fmax, and similarly for fmin.

in producing r complete tuples, we are guaranteed to repeat each sub-tuple in role range RA, ..., RK at least fmin and at most fmax times.


Contained in the JSEF package, this class contains the definition of attributes and methods that will be common to all classes defined in 3SEF.

it defines attributes which maintain basic descriptive information about JSEF objects, such as a name for the object, a description of the object or the resource it represents, the date/time of object creation, the date/time of the beginning and completion of the resource's processing/creation, and the name of person creating the object.


The memo/miss rule evaluates a memoization expression memo e and yields a trace memo e ·T ' ,where T ' is the trace of the evaluation of e. A present reuse trace T is itself a computation trace from a previous evaluation and is supplied to change-propagation to guide the update.

evaluation may reuse computations memoized in the previous evaluation: the memo/hit evaluation m rule uses the memoization judgement s; T ; e .


The optimizations arecrucial to reduce the size of the resulting code.

figure 11 illustrates how a GDSL library is synthesized.a generic runtime template is specialized forthe input GDSL program by adding declarations for themonadic state, constructors, and heap allocation functions.This bespoke runtime is combined with the generated codeand compiled to a library.


The scheduler in the VMM should keep fairness in resource sharing among VMs.

the amount of the CPU time obtained by a VM is controlled.


In this section, we focus on the different options for connecting distributed components.

in the platform integration design space these design decisions are especially relevant for the connections between applications and the service-based integration platform, connections between the servicebased integration platform and the platforms, distributed connections between the platforms, and connections among distributed components within the service-based integration platform.


MA inspired ants are responsible for collecting information while traversing the network and enriching the MaGate resource discovery service with the information.

mA inspired ants exploit the fact that each node keeps an instance profile and cache (of information on other nodes).


We compare the programming e.ort and analyze the potential for parallel programming errors.

we look at the following metrics: Lines of code (LOC).


The .rst part (lines 2 23) inspect the arguments object to determine which of the many possible ways it is being used.

this sets target to the object being copied to, and i becomes the index of the .rst parameter containing a source object.


To allow for a low-overhead, hardware-assisted implementation of the approach, we make several key technical and engineering decisions in the de.nition of our technique.

we use a con.gurable, low number of reusable taint marks instead of a unique mark for each area of memory allocated, which reduces the overhead of the approach without limiting its .exibility and ability to target most memory-related faults and attacks known to date.


16 } 16 }  3.3 Implementing PageRank On Multi-GPUs Based on the strategy of paralleling PageRank computation on graphics card as mentioned above, we need to divide data (the web graph) into GPUs to execute the algorithm on multi-GPUs system.

we aim to distribute computing PageRank values on multiple GPUs for take advantage of GPUs computing power of the system as well as gain more speed up.


Moreover, determining such tra.c classes and the associated demands requires a global view of the network, something hard to obtain in practice.

even the problem of determining the inputs of the OCBR problem, i.e., the tra.c classes with their associated demands, during the period of observation .t, is intractable if we consider the entire network as a whole.


4.2 Weak Semantics Weak MTS re.nement also de.ned by Larsen [24] allows comparing the observable behaviour of models while ignoring the possible di.erences that they may have in terms of internal computation.

this notion of re.nement considers t-labelled transitions di.erently from other transitions.


We will typically explore algorithms at the end points of a dimension.

we consider the sets to be either U or Ø.


In this paper, we present M-ECho, a middleware that provides support for continuous system adaptation and evolution, termed system morphing.

m-ECho focuses on data streaming applications in pervasive domain.


We can still gain useful insight, however, by comparing feeds to each other.

for coverage and timing, we combine all of our feeds into one aggregate super-feed, taking it as our ideal.


However, not surprisingly a model trained on data of release n-1 does not provide as accurate prediction results for a future release n than for the same release.

in some cases the values for the recall and false positive rate are rather unsatisfactory.


MOTIVATION AND RELATED WORK: FROM ELEPHANTS TO MICE Due to the growth in the bandwidth of networks, the volume of network traffic data is often too large for analysis using traditional data mining techniques [4].

it is difficult to collect, store and analyze huge amounts of network traffic data.


E V E N T WAV E events can execute in parallel as long as their behavior corresponds to the atomic event model: the behavior of each event should be consistent with an execution where the events executed sequentially according to their timestamp order.

events appear to execute atomically, in isolation, and in timestamp order.


to compare two or more studies, we need to consider two facts.


As illustrated in Figure 6 however, some of these weakly-biased branches still exhibit phased behavior that is interesting to an opfimiTation system.

figure 6 looks at phased behavior in the bias of a conditional branch (labeled b99) in the SPECint92 benchmark compress.


We do not ask the reader to understand the algorithm in Figure 2; we merely want to point out the essence of what complicates modularization.

note that the memory location current.children[current.idx] serves two roles: on the right-hand side of the .rst parallel assignment, the location stores an edge of the graph; on the left-hand side, it serves as storage for the backtracking structure.


The partial-evaluation work that seems closest to ours is Bechet s Limix partial evaluator (Bechet 1994).

he handles sum types as well as products, and he identi.es the reboxing problem (Section 6.1).


On the other hand, one practitioner viewed CB2 as the easier one to estimate because the hardware puts physical constraints on CB2.

new hardware needs to be purchased before it is possible to improve the quality beyond this level.


The population size, stopping criteria, crossover and mutation rates were empirically determined as it is usual when no guidelines are available.

we observed that increasing them did not allow us to improve the estimation accuracy while wasting computation time.


RACECAR does not solve the POP problem for individual work metrics, but instead creates the parallelization graph to inform parallelizing implementations of how to partition computation for any work metric.

a parallelizing implementation may perform a lookup within the parallelization graph based on the invocation parameter s work metric to determine how to efficiently apportion the computation and resources between the implementation s recursive function calls.


The de.nition of reducibility predicates in each case differs only in type annotations.

the logical relations for call by value are de.ned as follows: RU b (v):= True RU S.T (v0):= .v1.


For other 16 patterns, AspectJ and Eos implementation were the same.

eos constructs did not offer any additional improvements for these patterns.


In addition to industrial projects, also descriptions of research ideas that initiate and forward the technical underpinnings of DSM are addressed.

the importance of metamodeling is highlighted in this workshop.


Instead, we propose to make type annotations rigid.

f..a. e.G = F.e.G when a programmer writes a type annotation on an F.e s.G = F.e.G argumentorthebodyofa lambdaexpression,wewilltakethetype F..(x : s).


However, of these three server directories, 87.77% of the total set of servers observed appeared in all three server directory lists.

most server operators tend to register with all three server directories.


Bugs with a degree greater than zero are variability bugs, thus occurring in a nonempty strict subset of valid con.gurations.

if the degree of a bug is greater than one, the bug is caused by the interaction of two or more features.


Crucially, the set of level-1 data cache (L1D) indices associated with the base addresses of the blocks within such arrays is restricted to just 16 instead of the full complement of 128.

given the way virtual addresses map to cache indices and because of the regular consecutive spacing of the blocks in the array, blocks of that particular size-class (128 bytes) can start on only 16 of the 128 possible indices.


This concept has a semantics related to the size of a set, but it is not the general cardinality notion.

given n variables X1,...,Xn with domains D1,...,Dn, a cardinality constraint for a domain element d is a bound k on the number of Xi that can be simultaneously instantiated to d. It is therefore a constraint associated to the availability of a .xed number k of resources of a certain kind d. 7.


In this paper, we describe our experience of applying the COMET /UML method into developing the intelligent service robot for the elderly, called T-Rot, developed at CIR.

we focused on designing an autonomous navigation system for the service robot, which is one of the most challenging issues for the development of service robots.


However, this is a great time for introducing the kind of thinking that needs to precede any programming.

students are presented with an algorithmic problem that they solve by doing computations on paper and then verify by observing a program that uses their results.


This can be translated into an assumption that monitorBegin and monitorEnd events are correctly nested within one control .ow.

every monitorEnd joinpoint should .nd at the top of the stack a Resource object that has been put there by a corresponding monitorBegin joinpoint (i.e., one that has been de.ned within the same sub-aspect of AbstractMonitor).


Part (ii) of Theorem 4.1 allows us to estimate the performance of LMS.

for r, s : k, the probability that a search fails is of the form exp(-D(rs/k)).


However, we .nd it convenient to virtually run EC and PO-algorithms A on multigraphs F with the understanding that the output A(F, v) is interpreted as if we had run A on a simple lift of F and then mapped the solution back to F according to (2).

to determine A(F, v) where F is a multigraph, do the following: 1.


Another problem with shifting code is control-.ow dependency.

if a callee is moved, then all callers of that function must be updated with the new address, and these callers may reside on several different pages.


Less sophisticated users do not have Visa's resources, and seek simpler, more general, but no less effective solutions.

while redundant hardware may often be present to support fault tolerance, we would prefer not to require it for updating, since it adds cost and complexity.


Note, however, that this behavior is only achieved if the action of the transition to DoneA that writes B is performed before the trigger of the transition to DoneB reads B.

there is a race condition on AB A  A, O1 B, A,B, B,O1 O2 O2 (b) Two possible execution traces, with true-valued inputs above the tick time line and (c) Normalized SCChart ABO-norm.


We do not use any form of static typing either.

we do not exploit any directional types (modi) or algebraic types [Mycroft and O Keefe 1984, Boye and Maluszynski 1997].


Our respondents initially seek a deeper, but not expert, knowledge that they can apply quickly, and they want to test their understanding and application of knowledge with peers or experts.

they want access to gain a familiarity with the subject, and they master it through practice guided by expert knowledge.


Core issues that limit the portability of TinyOS-2.x are identified, and suggestions made as to how these might be addressed.

tinyOS s reliance on the GNU Compiler Collection being available for the wireless sensor network device, the use of connection-dependent abstractions and their impact on system-on-chip devices, and the reuse of components within chip families.


MOTIVATION Although the previous work pointed out the common structure shared by di.erent AOP mechanisms[19], the commonality is described in an informal manner.

there has been no single model to capture di.erent AOP mechanisms.


Furthermore, there are many practical and logistic problems associated with .eld testing, which are much easier handled in the lab.

.eld experiments are both more di.cult and more costly with regard to time and manpower.


Our proposed scheme is flexible in hiding capacity.

the proposed scheme can meet the needs of the user who wants to embed a large amount of secret information in an image and the user who desires a compact final output.


Additionally, using up and down knobs in the Probe API, applications can force on-demand fast re-aggregation of updates to avoid staleness in the face of recon.gurations.

if an application detects or suspects an answer as stale, then it can re-issue the probe increasing the up and down parameters to force the refreshing of the cached data.


The rewrite rules use meta-variables in the code fragments.

ps* , c , x , e and bstm* are Stratego variables, used directly in the Java code fragment.


Because the Subtext UI is largely textual, scaling techniques proven for textual languages can be applied.

traditional hierarchical decomposition ought to fit well with the tree structure of Subtext.


3.1 First, the Documentation Tec-Ed used the opportunity provided by this internal project to experiment with the design of the Tracker documentation.

we were interested in where employees would look for various types of information in the print documentation, the online help, or the user interface itself and which of these formats was most effective for the various types of information.


We will demonstrate how JavaConnect implements language interoperability through such a transitive combination of FFI s and how Smalltalk s dynamic and re.ective features permit a high-level integration of Java objects in the Smalltalk environment.

we describe and explore the concept of language shifting objects where Java objects migrate across the language barrier into Smalltalk such that a part or their entire set of methods of their class e.ectively executes in the Smalltalk environment rather than in the Java environment.


4 Virtual User Interface Evaluation Since a XIML model of the virtual world is maintained internally to Envir3D at any time, this model can then be exploited for other activities that are traditional to model-based design, such as, model checking, consistency checking, automatic verification of properties of interest, both on the presentation and the dialog, automatic evaluation of the model quality.

we are interested by testing as automatically as possible whether the current virtual world is compliant with usability guidelines that may be recommended [Smith & Walker, 2003; Wood, 99].


We would like to see MLF more widely used.

we believe that MLF with quali.ed types can be seriously considered as an underlying type system for the Haskell programming language.


Indeed, while plans were initially designed to re.ect components making up an application, we demonstrated in [12] that plans can also re.ect other kind of artifacts, such as Service-Oriented Architectures (SOA).

we proposed a component-based architecture for discovering, negotiating, and planning application con.gurations supporting SOA.


Interpreted type checks in a short run of SpecJVM98  5 PERFORMANCE The following numbers were derived by instrumenting the VM and running the interpreter only (-Xint mode) with all type checks redirected to the runtime.

(the old interpreter's two-element subtype caching logic was disabled.)


preserve the relation state_mint (x.signed L rx Iy.unsign rk ry Id) (lines 7 8), for any association list d with no register in common with the code (lines 3 6), provided the initial conditions from line 9 hold.

these initial conditions specify that register rk contains the length L (line 10) and rule out potential over.ows (line 12).


FINDLD checks whether the leaves Lpre of the tree Tpre are dominated by some vertex of Lpre in another tree, Tpost , or vice versa.

fINDLD computes the set LD (LD pre post ).


We compare the performance of the partitioned cache structure against a number of typical LI cache configurations in modern em- bedded processors.

our comparison configurations in- dude: 4K direct-mapped and 2-way set-associative LI cache with line size of 4 words, 8K direct-mapped and 2-way set-associative LI cache with line size of 8 words.


This liberty is visible in the typing rules, shown in Figure 5.

rule 4 does not have any premise regarding v. If pickles may be malformed, how can we establish soundness?


and a.dt both satisfy DTL, then so does aßu.dt.

(ßu does not affect the correctness of dt.)


Bayesian networks (BNs) are part of the family of probabilistic graphical models (GMs) that are used to represent knowledge about an uncertain domain.

each node in the graph represents a random variable, while the edges between the nodes represent probabilistic dependencies among the corresponding random variables.


We show how these middleware-level services have been applied by specific communities to manage scientific data and workflows.

we highlight and introduce Chiron, a portal facility that enables the interactive use of the virtual data system.


Note that there is no requirement that m is a monad; any type transformer is .ne.

id can be used to translate an effectful program into a pure function.


clone instances that were not consistently changed) are detected by checking if a method that is added to a clone family has been part of that family before.

late propagations are located thanks to the separation between the clone family and the clone instance location.


We evaluate a number of standard benchmarks.

we show that the direct implementation is an enabling technology for shift/reset-based thread systems, avoiding some of the pitfalls of call/cc-based implementations.


As both .gures show, additions make the bulk of changes, deletions being comparatively few and small in size.

there are hardly any deletions in candidate releases, with the notable exception of the plugins deleted in 3.3RC3.


For barrier interval, one can follow a canonical (sequential [3]) schedule.

we symbolically execute one thread from one barrier to the other, then switch to the other thread and do the same, etc.


From Table 2, we find 252.eon, 168.wupwise, 177.mesa, 178.galgel, 183.equake, 187.facerec and 189.lucas benefits from the type re-assignment algorithm.

187.facerec gets an improvement of 7.42%.


Equ Notation Description (1) Instructionb Number of instructions in BB b (1) Lengthb The length of BB b (1) FU Number of functional units (1) Reschedulabilityb Re-schedulability of BB b (2) Weightv The weight of variable v (2) F requencyv The execution frequency of v (2) Degreev Interference degree of variable v (3) PB The priority of basic block b (3) Weightb The weight of basic block b (4) Cost The required latency of OPs (5) Reg Number of remaining registers (5) PD The priority of destination d CF G Control Flow Graph ILP Instruction-Level Parallelism  4.2 Strategy for Local and Global Variable Allocation Since we consider the basic block based register allocation, the differences of local and global variables need to be taken into account due to their different effects on register resource and the allocation choice of other basic blocks.

register assignment of a global variable would limit the allocation choice of variables in other basic blocks.


In general, we would expect the empirical precondition and the standard precondition to be incomparable.

we would expect some inputs to satisfy the standard precondition but not the empirical precondition and vice-versa.


and the related criticisms, and to formally de.ne a protocol that incorporates them and does not su.er from the previously mentioned limitations.

solutions to the problem of binding the static and dynamic parts of a mobile agent have already been sketched in [6] and proposed in [7], while, for what concerns resistance to truncations, this paper shows how animprovement canbe achievedby forcing the agent to securely store the addresses of the next hosts to be visited, as long as they are computed or become available.


Soundness of type system The type system enforces security.

if a program is well typed, then it is secure.


In this context, our aim is to experiment with the integrationofprediction modelswithinaspeci.cautonomic framework in order to assess the feasibility of such integration in a setting where the characteristics of dynamicity, decentralization, and cooperation among nodes are important.

we base our work on the SelfLets infrastructure that we have presented in [13, 6].


Having the student draw the memory diagram not only helps the student directly in learning the object-related concepts, it also aids the instructor in assessment.

the diagrams provide a means of identifying what the student understands by a distinctly different medium than merely examining the code that the student has written.


ELEMENTARY CONSTRUCTION In this section we survey the constructions and results featured in the rest of the paper, using only elementary terms and techniques.

we give an elementary statement and proof of a special case of our Schwartz-Zippel type lemma, used here to show that a speci.c instance of degreelifted AG codes has good distance, and an elementary de () v m Tower of curves (hypothetical construction, see below) 1 - d - 1 q n any scription of our correcting methods and their relation to the local correction of RM codes.


2.2 Hardening Distributed Applications Refactoring an existing centralized program for distributed executions should preserve its original execution behavior, so that a distributed application would provide the same or equivalent functionality to the user as the original centralized version.

distributing an application should not only improve its performance, availability, scalability, and ef.ciency, but also furnish the original functionality to the user.


In an interactivegame, the players will get frustrated if theyhave to wait for several seconds each time a leader is lost.

one may ask whether we can ensure that leader loss does not cause the simulation to pause while anew leaderis elected.asthegamegrowsin population, the probability that a leader will be lost also increases.


Properties that are simply captured within the context of interest and that are easily described by natural language may result very hard to specify in LTL.

there is a substantial gap between natural language and the LTL syntax.


Recall that the only reason why we want to accurately state what set-theoretic model of types is, is to precisely de.ne the subtyping relation for syntactic types.

we do not de.ne an interpretation of types in order to formally and mathematically state what the syntactic types mean but, more simply, we de.ne it in order to state how they are related.


2 Goals In listening to the radicals describe their vision for a new CS 1, I find myself wishing that my CS1 could satisfy some of those radical goals.

i would prefer that the programs I ask my students to write: ) have a GUI front-end occasionally involve some concurrency use many objects and many classes  use "real" objects (not procedural substitutes)  be dynamic, not static  It can be useful to read the list above more as an indictment of the course you get when you directly translate a Pascal CS1 course into Java syntax.


The debugger has full control of the debugged JVM.

it can suspend and resume the JVM, read objects from the stack frame and the object heap and can force an early return from a method execution.


It builds on the results of the Fox project,where Standard ML was used for systems programming.

it includes FoxNet, an ef.cient implementation of the TCP/IP protocol stack [2].


For example, containers sometimes provide optimized implementations for particular argument types.

the C++ vector, optimizes storage of bool to a single bit per value via the vector specialization [25, §23.2.5].


Moreover, it uses the data reuse information provided from the DDRG for exploiting the CGRA s DFM in order to reduce the burden of buses [23].

values which are used multiple times are transferred through the CGRA s DFM instead of using the buses.


Secondly, the slow motion bene.ts those applications that exhibit (high) sequentiality and/or locality of reference.

moving the sled slowly allows for quick inexpensive seek to an already visited region, if new requests demand further data from this region as we observe in our simulations show presented next.


Because the ~S-cons algorithm needs to cope with those mistakes, it has the following in- teresting features:  The ~S-cons algorithm preserves safety even if neither of strong completeness nor eventual weak accuracy is satisfied.

even if crashed processes are never suspected and correct processes are permanently suspected by all, (a) no two processes ever disagree on a decision and (b) no process ever decides on a value that was not proposed by some process.


Otherwise, R installs its documents and fragments as usual.

involution captures this two state existence elegantly: Dot-Involution : R · R = 1 (15) all colors (base and interaction) are the inverses of themselves.


Some of the problems that web services could have with respect to authentication include: Spoofing, Forged Claims and Man-in-the-Middle.

spoofing refers to tricking or deceiving computer systems or other computer users by hiding one's identity or faking the identity of another web service.


Both approaches free up virtual andphysical memory by transferringhighly stale objects to disk, and both preserve safety by returning accessed disk objects to memory.

unlike Melt, LeakSurvivor cannotguarantee space andtimeproportionaltoin-use memorybecause referencesfrom staletoin-use objects continueto use space evenif thein-use objectsbecome stale.entriesinLeakSurvivor sSwap-Out Table (SOT) (similartoMelt s sciontable)cannotbe eliminatedifthetargetobject moves todisk, sinceincomingpointersfromdisk are unknown.Incontrast,Meltusestwolevelsofindirection, stub-scionpairs,to eliminate scions referencingobjectslater moved tothe stale space(Section2.2).Forthethreeleaks evaluatedinLeakSurvivor,theSOTgrows only slightly,but it is unclear if they grow proportionally to the leak since the experiments are terminated after two hours, before the leaks would have .lled the disk.


Several approaches to co-design have been proposed, differing on the specification language, the mechanisms available to perform design space exploration, and the supported target architecture.

[1] and [2] target control-dominated applications and system specification, while [3] is oriented to data-dominated applications.


The most general approach for laying out the stacks is to allocate global GPU memory for each threads stack where items are arranged such that if two adjacent threads are at the same stack level their accesses are made to contiguous location in memory, providing the best oppor-6.1 Evaluation Methodology tunity for memory coalescing.

the threads stacks are interleaved in memory, rather than having each thread s stack contiguous in memory.


We check completeness using parallel composition of multiple .le system checkers.

we run different implementationsof.lesystemcheckers(possiblyfordifferent .le systems) and comparetheir results when started withthe samesemanticstate(i.e.,alogical representationof the .le system state that abstracts away the differences in the data and metadataphysicallayout) and the samedata corruption.


To give an example of basic ehandler functionality, the following code snippet presents a useful handler in the context of channel EEC1: void ehandler() boundto(EEC1()): withincode(public void F()){ ... } This advice handles exceptions flowing through explicit exception channel EEC1.

the handler is activated when such exceptions are raised within method F().


This part, along with the event queue, constitutes an important part of the uni.ed interface provided by the SBRT environment and mentioned in Section 3.

the SBRT environment uses an event-based, publishsubscribe interface for allowing new services to extend the runtime environment.


4.2 Specifying Alternate Outcomes Though existing techniques can parallelize the applicationsin Section4.1,manyarestillleft unparallelizedbythis framework.

the dependences that prevent parallelization or lead to excessive misspeculation are often a resultof arti.cial constraints imposedbythe sequentialprogramming model.


The proposition below guarantees the usefulness of the transla tion HT for implementing functional bisimulation on .-ho-term graphs.


We roughly conclude the same when considering commits.

we .nd 33 preprocessor-based syntax errors, out of which only 24 happen in valid con.gurations.


Luckily, no further mechanism is needed, GHC s standard support for separate compilation is suf.cient.

gHC generates an interface (.hi) .le with type information for each compiled module s exported values.


The generated JAVA class for the class de.nition in XTR A ITJ can be used in any JAVA program and can be itself subclassed.

one can override the original method m: public class CExt extends C {@Override public String m() {return super.m() + ", Redefined"; }} If we execute the following JAVA snippet System.out.println(new CExt().callM()); the string "a String, Modified, Redefined" will be printed on the screen.


The TMS320C6000 compiler invokes the ABC algorithm whenever the default partitioning algorithm, a variant of BUG, does a less-than-optimal job.

the theoretically best steady-state cycle count (TBSC) for the loop is computed before and after the default partitioner runs.


As a result, many exception paths can be collected for some logically equivalent exception path.

the number of exception paths can increase because of compilation and recompilation, while Edo normally reduces the number of exception paths.


It aims at obtaining semantic interpretation of signals (messages) going to/from the VIEW2 SCADA system (http://www.view4.rs/) which is the Mihajlo Pupin Institute s proprietary system for supervision and data acquisition currently installed at the airport Nikola Tesla.

it is used to identify to which device/system an incoming (outgoing) signal belongs, which geographical location the signal is coming from, what its characteristics are, relationships with other devices/signals, etc.


Because ultimately C foreign functions will see the physical representations of OCaml types, the tool resolves all types to a concrete form.

type aliases are replaced by their base types, and opaque types are replaced by the concrete types they hide, when available.


In this paper, we argue that transparency is suf.cient to make pipeline synthesis compositional, requiring the analysis of just pairs of features to determine their relative order in the overall pipeline.


At 20 ms, when ports read by both tasks t1 and t2 are updated, and ports written by both t1 and t2 are read, a time-safety violation occurs unless both tasks have completed.

an execution of the program is time-safe if the scheduler ensures the following: (1) each invocation of task t1 at 20n ms, for n = 0, completes by 20n+ 20 ms; (2) each invocation of t2 at 20n ms completes by 20n + 10 ms; and (3) each invocation of t2 at 20n + 10 ms completes by 20n + 20 ms.


CONCLUSION 6.1 Summary In this paper we have looked at the problems inherent in accessing relational databases from object oriented programming languages.

we have investigated the shortcomings of communicating with database engines through call level interfaces.


Since all processes execute within the same runtime system, the detection of a terminated process is of course perfect.

a process reported terminated will never reappear.


Thus, this insecure component usage can lead to serious vulnerabilities.

the disabled FEATURE_ZONE_ELEVATION and the missing LMZL make the test subjects vulnerable to cross zone scripting attacks.


Each directed arrow points from a centroid to the two centroids closest to it.

edge (i,j) means that of all cosine correlations (i,k), centroid j was one of the two closest to i. pages.


The same holds for proofs of type soundness, the guarantee that the desired run-time behavior of a language, typically preservation and progress, is enforced.

proofs of type soundness for FJ are altered when the Generics feature is added: new proof cases are added and existing lemmas may be altered.


On the other hand, if the minimum computation is not on the critical path, then the communication of values from one core to another, will also be a part of the critical path.

if t2 < t3, then the total execution time becomes 2n × (t1 + t3).


7.4 Inheritance Consistency Lastly, for sake of completeness we discuss a problem which, although not of.cially addressed by the Java language speci.cation, appears to already be addressed by javac.

the type Numbers poses an interesting problem.


Such conditions are called invariants, and are required to hold at times when no method call is active.

methods can assume invariants when they start execution, may break them temporarily, and have to re-establish them upon exit.


Consequently, we used pro.le information to guide the insertion process.

(the application was run in pro.led mode to obtain frequently-executing paths.


Though the context of business documents for standardized information exchange is not considered as a traditional domain within Software Engineering, we argue that concepts from Software Con.guration Management (SCM) may be applied for dealing with business document model variants.

one aspect of SCM [22] addresses dealing with di.erent versions of software systems whereas versions are di.erentiated into revisions as well as variants.


datatype constructors in capturing program invariants.


As shown in Figure 3, a read to a shared variable (5.14) that follows a write to the same variable (5.03) may exist in an atomic region.

atomic regions of a program may contain shared dependences.


is an abstract operator, and g{i,j}(x) is a function denoting the impact from element i to element j.

processor i pushes value g{i,j}(vi) (instead of vi) to processor j, and on processor j, these g{i,j}(vi) from any processor i and cj can be aggregated (by .


Such approaches are therefore inher ently limited to the framework s capabilities.

they do not provide general support for explicit distribution in the aspect language or weaver technology, for instance, to support automatic deployment, state sharing and remote execution.


The .rst phase carries out type inference after erasing all rational numbers from the type system.

the types inferred in this phase are: s := int | s.s ' | s .


Such integration enables the memory allocation for processes and .les from the same source.

processes can take advantage of a large amount of physical memory used for both main memory and storage.


To support formal analysis, our specification patterns may be formalized in a first-order, real-time linear temporal logic [22] augmented with epistemic constructs for security-related predicates.

the epistemic operator KnowsVag is defined on state variables as follows: KnowsVag (v) = .x: Knowsag (x = v) ( knows value ) Knowsag (P) = Beliefag (P) .


dim Name(long, short) in dim Rep(rel,adj) in let T=Name(Node,N) in type T = Int type Graph = [(T,Rep(T,[T])]) ... With the let binding we need only one choice and can reuse it many times.

if we want to extend the choice of names, we can do this easily and safely at one place and have the effect systematically replicated through the variable reference.


These transformations allow to build from raw PCMs, corresponding PCM models that can be then enriched with further editing and validation services.

we develop a comprehensive PCM editor; 3.


Controlling the environment in this way maximizes the likelihood that two testers building and testing the same component can share and combine their test results.

any di.erences in results should be attributable only to differences in how the components were tested, not in where or by whom they were tested.


CONCLUSIONS In this paper we have presented a basic framework for the introduction of services in a business process model.

we have considered the use of workflow technologies during the enactment of business processes involving many business partners that provides and consumes service.


In our case, given two architectures or states in the previous transition system, the decision is to .nd a path between them, if it exists.

decide the sequence of recon.guration actions that transforms the current architecture in the goal one.


The manner in which local label variables are replaced de.nes the contours of a concrete class analysis.

differentinstantiations of the ' type create unique types that distinguish different method invocations.


It may also provoke an unnecessary number of intra-block synchronizations.

we notice that all sequential sections must be followed by an intra-block synchronization, which may represent a signi.cant overhead when there are many such sections.


However, those results are for a GOLDILOCKS implementation written in compiled C code inside the Kaffe Virtual Machine, and target programs were interpreted by this modi.ed JVM.5 If GOLDILOCKS were implemented inside a JIT, then target programs would run signi.cantly faster, and so the GOLDILOCKS slowdown would appear larger but would be more directly comparable to ROADRUNNER tools (in which both the target program and checker are optimized by the JIT).

to compensate for this effect, we estimated the corresponding GOLDILOCKS-JIT slowdown from the experimental results of [14] as: (Goldilocks-Time - Interpreted-Time)+ JIT-Time JIT-Time we compute the cost of the Goldilocks analysis based on the running times of the unmodi.ed Kaffe interpreter and the Goldilocks-aware Kaffe interpreter, and then estimate the slowdown that this overhead would have on the running time of the target program in the Kaffe JIT.


FsaveP wd) AESEncr: PEAESEncr = true PIAESEncr = Spectative RAESEncr = G(call encryptDES  .

x((G ¬encryptedDES) .F(encryptedAES))) Req&EncrPwd takes care of requesting a password and calling the encryption algorithm and assumes the existence of DESSave, an aspect that guarantees that eventually the encrypted password is saved.


The user could also manipulate the output such as to repeat any selected sounds as an infinite loop, to play the sound either faster or slower etc.

the same result of the acoustic parameters transformation can be further manipulated and displayed as different sound representations.


We focus on extracting information related to levels of clustering, network transitivity and strong community structure.

we visualize the detected communities from the mobility traces as well as progression of the connection map along the community formation process.


In [17], the authors discuss resource provisioning and anomaly detection for multi-tier applications.

they use a linear regression model for estimating CPU utilization demand.


The NAL provides connection-oriented communication primitives that simplify message passing and fault detection.

the NAL generates connection-lost events which indicate potential remote node failure.


Si which is a (potentially empty) subset of the resources.

si is the power set of the set of resources: Si = P (M).


The results that we present in Section 5 show that a new, directed test-generation technique based on path-constraint similarity yields the smallest test suites with the same excellent fault-localization characteristics as test suites generated by other techniques.

when compared to test generation based on the concolic execution algorithm of [4], which aims to maximize code coverage, our directed technique reduces test-suite size by 86.1% and test-suite generation time by 88.6%.


Scala also incorporates some less common concepts.

there is a concrete notion of object, and interfaces are replaced by the more general notion of traits [Sch¨arli et al., 2003], which can be composed using a form of mixin composition.


Rather than attempting to reclaim all unreachable objects, we will only reclaim a subset of unreachable objects.

we will assume that any object not hinted with a deallocation hint is live and will not attempt to reclaim it.


Finally, we provide a set of generic programming tools that query the data (Q) for analysis, taking advantage of type information of the data.

surveyor is a domain-speci.c embedded language (DSEL) in Haskell, presenting a way to design surveys that is strongly typed from the ground up.


Besides, such instructions are removed after decoding.

for all pipeline stages after decoding, they do not exist.


The extreme resource constraints inherent to WSNs, the in situ deployment in harsh environments and the lack of run-time support tools make debuggingand maintainingWSN applications very challenging.

run-time debugging tools are required to detect and diagnose complex run-time faults such as raceconditions, which occur due to unexpected interaction with the real-world environment.The ability to repeatedly reproduce the failure by replaying the execution from the trace of events that took place can play a crucial role in debugging such faults.


However, since we are restructuring the code, the impact of our transformations on other aspects of the code (e.g., cache behavior) should be studied as well.

an important question is how our code modifications interact with other compiler optimizations.


When the tests for either the existence or the non-existence of identi.ers fail (a SAT-test succeeds) then we have found an error in the feature model, the feature modules, or both.

when feature R is selected, its precondition(s) can be violated.


7.4 Polymorphic Views It was also interesting to witness a form of visual polymorphism in the course of designing the system.

the development of views that were able to visualize the same data in multiple ways came naturally as part of the architecture.


One of the main orientations of our future work will be to carry out a number of user-centered evaluations to explore how collaboration occurs in the type of multi-user multi-device environment that we have described in the Design Considerations and Example Use Cases sections.

we want to explore issues of which type of browser representation is best in which contexts to best improve the collaborative experience, and the degree to which collaborative web browsing of the type we propose improves the collaborative process when compared to collaborative browsing using more traditional means and methods such as the backseat driver or divideand-conquer.


Our case study showed that Titanium indeed supports what interpreted apps are promising.

we managed to create a simple rss reader application using JavaScript without any knowledge of the target Android and iOS platform.


She uses a partitioning algorithm, which is based on a Program Representation Graph (PRG), but PRGs are de.ned only for a limited subset of programming languages.

it only supports scalar variables, assignment statements, conditional statements, while loops, and output statements.


A complex mapping is indicated by the implicit relationship between the semantic association among the labels VehicleSearch , Price: , and Make: on the form and the thick-lined connection among the concepts in the ontology.

the Price: label together with VehicleSearch on the form correspond to the path in the ontology from the concept node gr:Offering to the concept gr:PriceSpeci.cation through --gr:hasPriceSpecification-->-, where we use the notation --r-->-to represent a many-to-one (functional) relationship r in an ontology, and --r--to represent a many-to-many relationship.


We demonstrate that na¨ively-injected faults do not have a uniform consumer-perceived severity, and thus that standard fault seeding metrics are misleading for web application test suite evaluation.

the assumption that all seeded faults have the same severity, and thus that a test suite that .nds more faults is necessarily better, is not always true when considering consumer-rated severity.


Among them, 432 forked the repository, while the others may have been merely interested in updates to the project [4].

the number of project s watchers represents some aspects of interest in the project6 .


This can be achieved by reducing the reuse distance between two iterations that are mapped to two different cores that share an on-chip cache.

our goal is to come up with a schedule for each core such that, if two cores share a data block, they share it within a short period of time, thereby increasing chances of catching the reused data block in the shared cache.


It means thatpolymorphism is limited to simple types.

programs can manipulate values of several types that di.er in their monomorphic parts but must have the same polymorphic shape.


Subroutine threading handles the branches that are induced by the dispatch of straight-line virtual instructions, however, the actual control .ow of the virtual program is still hidden from the hardware.

bodies of opcodes that affect the virtual control .ow still have no context.


Please recall that we have to detect con.icting changes, regardless whether they result in inconsistencies or not.

deletion of an object invalidates all operations applied to that object.


3.3.3 When to Apply Patches A critical component of assuring patch correctness is the timing of an update.

it is possible for a well- formed update to be applied at a bad time, resulting in incorrect state.


INTRODUCTION For several application domains, the runtime behavior of the code is relatively independent of the program inputs.

the executed code paths are typically the same, so the hot spots do not change much from run to run.


However, the scope of these tools is limited; they are only able to expose violations of certain architectural constraints such as inter-module communication rules in a layered architecture.

they do not provide means for expressing system constraints.


The aspect implementation ignores several details, and is shortened for presentation.

a gaping omission is that the service always trusts that the .rst alternate object for a failed object is alive and ready to receive invocations.


In addition to generic device-class interfaces, one must also specifygenericbusinterfaces(seeFigure3) for various types of I/Obuses as wellasgenericinterfacesto commonOS services such as timers, synchronisation, andDMAbuffer management.

design of the DMA buffer management interface raises someinterestingissuesduetothedifferent waysin whichthe testbench and theOS manage devices access tophysical memory.


Note that the encoding used in this section only works for regular datatypes.

families of (possibly mutually) recursive datatypes cannot be expressed in this way.


Piernot and Yvon s AIDE system [7, Chapter 18] provides developersasystem substrate for creating application-independent PBD so that developers can add advanced macro capabilities to Smalltalk applications without re-implementing everything from scratch.

aIDE adopts a hierarchical representation of the application history and AIDE generalizes arguments in different events of the same class.


Since this particular optimisation is a tricky one anyway, it is quite easy to omit!

in our static contract checking, we can safely omit fin and the rules [E-.n1-4].


Note that while the shape of the curves look about the same, different dispersion levels affect two things; 1) the rate at which productivity decreases as you increase your quality expectations.

highly dispersed teams will have to spend more time to create high quality code relative to less dispersed teams.


A property model is an explicit model of dependencies between parameters to a command.

it maintains which dependencies are currently in effect in the model.


We inferred the requirements of a validator by manually inspecting the generated inputs that were accepted and rejected by the validator.

we wrote input transformers for phone-number, SSN, and zip-code validators.


GUF can provide feedback to the load balancer to inform it about the nature of GPU requests from different applications.

the RMO component monitors the GPU time and total execution time of each application mapped to a certain GPU.


The logic is expressive enough to capture much of the behavior of an object-oriented program.

it can express the mutation of shared objects that is the cause of much complexity in object-oriented programs.


However, part of our research agenda includes sound ways to extend the probabilistic aspects supported by our approach without altering its theoretical and methodological basis.

the current results of property preservation requireone of themodelstobenon-deterministic.


If these parameters are tuned to obtain E-di.erential privacy, then we show that the accuracy that can be achieved is (b, O( v1 ).

the accuracy E bN radius depends inversely on the privacy level (E) , the square root of the number of agents (N), and the probability (b).


The simulation results analyzed in the following are obtained with reference to the following architectures (see Section 2): SA, M/S_2, MC, MC_PS, and P2P.

as the M/S architectures have almost equal performances, M/S_2 has been selected as representative M/S architecture.


The unusual-profile hypothesis provides guidance for these choices.

it suggests that: (1) dissimilarity metrics should emphasize unusual aspects of profiles; (2) the number of clusters formed should be a non-negligible fraction of the population size, so that unusual executions will be separated from other executions; and (3) the sampling method should ensure that small clusters, which correspond to executions with unusual profiles, are sampled.


Because of type inference, g can only be a type constructor that is a constant or a constant applied to type constructors [13].

we cannot represent the type constructor (.a : ..a .


4.3 Control Flow Control .ow mainly dictated by loops, function calls, and branches constructs.

loop boundaries and branch outcomes often remain unknown until the run time.


Unfortunately, their technique is application-speci.c.

a genetic algorithm has to retrain for each program to decide the best optimization sequence for that program.


A number of authors have recently observed [24, 20, 17] that these two approaches can play complementary roles in the veri.cation of general trace based program properties, expressed in temporal logics: type systems can be used to compute program abstractions, which can in turn be used as inputs to model checking [26].

type analysis can serve as a technique for model extraction [16] in this setting.


We plan to do further runs to evolve robustness to floor friction inaccuracy, hoping to attain a walk that does not rely on the particular errors in the simulation of floor friction made by the simulator.

the simulator is inaccurate if the robot drags its feet on the floor.


in the type system and statically distinguishing cases from other functions lies in the fact that this makes it very easy to use different runtime representations for the two.

we can represent MLPolyR cases as records of functions.


Our experimental analysis shows that the proposed approach is very successful in practice and reduces total disk energy on average by 18.17%, as compared to an execution without any power management, and by 11.55%, as compared to an execution that employs disk with low-power capabilities without our approach.

providing compiler support can bring additional savings over what could be achieved using hardware-based power management alone.


Strawman, on the other hand, ranks all holes.

uncovered takes into account not only the absolute number of uncovered tasks in a hole but also, indirectly, their percentage.


If the max-blocksize is n bytes then an n-byte block cannot be allocated beyond I(n) bytes of the heap.

an address-ordered binary buddy allocator cannot use beyond I(n) bytes of storage when the max-blocksize is n bytes and the maxlive is M bytes.


Security engineers and legal experts should be able to start from the organizational model and derive from there the points where security and privacy problems may arise and determine which solutions best .t the (legal) problems that they face.

we investigate the methodology needed to capture security and privacy requirements for a Health Care Centre using a smart items infrastructure.


5.4 Embedded Values Because abstract code is a regular ML value, and binaries are written by pickling, code is not restricted to sequential form but can be arbitrarily structured.

code can contain structured values as immediates loading an immediate value simply loads a node, whether scalar or not.


While this cannotbedirectlyinducedwhen only these operators are assumed, it can be induced when consideredjointly with otherpredicates alongthepathtothe predicate.

the equivalence can be inferred from the path conditions.


While these assumptions may be reasonable when a single transformation is applied, once a multiple transformations are applied over the same model the situation may change.

the characteristics assumed from a model by one transformation may change if another transformation from another concern is applied on it.


Fault tolerance is achieved via timeouts and keep-alive messages.

if a child does not hear from its parent for some timeout period, it sends a new subscribe message to the root and is spliced to the multicast tree.


In their .rst article on delimited continuations [13], Danvy and Filinski brie.y described a variant of shift and reset, known as shift0 (S0) and reset0, where the operational semantics of the control delimiter reset0 coincides with that of reset, but shift0, when capturing a continuation, instead of resetting it, replaces it with the inner-most delimited continuation pending on the metacontinuation.

in contrast to shift, shift0 removes the control delimiter along with the captured continuation, which makes it possible to use shift0 to access continuations arbitrarily deep in the metacontinuation by repeatedly shifting continuations.


4.2 Relevant Properties The key property of relevance analysis stems from the following essential property: if a grammar is relevant to a string then a programmer can use IDEALIZED ANNE to extract it from the string.

the programmer does not need to annotate with assertions.


Furthermore, we use this characterization to deal with some algorithmic problems related to this notion.

we show in Section 4.2 that the order 1S is decidable for the class of mappings speci.ed by CQ = -TO-CQ dependencies, that includes the widely used class of st-tgds.


The beanplot uses a Gaussian kernel density estimator to show the shape of the distribution for the CE values of test suites resulting from a speci.c prioritizer [10].

the beanplot employs the non-parametric kernel density estimator to create a smooth curve where a wide area indicates a concentration of values, such as a CE score, and narrow regions suggest the relative dearth of points.


#include  #ifdef WORLD char * msg = "Hello Worldn"; #endif #ifdef BYE char * msg = "Bye bye!n"; #endif main() { printf(msg); } Figure 1: Example C program generating all variants.

we want to check types before running the preprocessor with a speci.c feature combination but still guarantee that all variants compile after generation.


This reference framework has been applied on the development of two opensource platforms, Hulotte and FraSCAti, to validate the acquaintance of the introduced concepts.

we demonstrated that the adoption of this reference framework leverages on the integration of domain-speci.c requirements from the perspectives of the domain expert and the application developer.


Given the level l, l =1, 2, ···,L, and the chunk c, the corresponding chunk delay is   [() ] Sc Sc - 1 d(c, l)= + ceil + l - 1- (14) RSWR This delay will be periodic of period S, as a burst of S chunks will be received at the same time by nodes at same level.

the most recent chunk of the burst will experience the lowest delay, the oldest chunk of the burst will experience the highest delay and the delay di.erence among two next chunks in the burst is T .


Future work has to complete our current implementation with the missing features in both interaction diagrams.

message selection and message interval selection seem to o.er useful analysis options.


If 10% of a program s execution requires holding a speci.c lock, no amount of parallelism can ever result in more than a ten-fold speedup [1].

if a single lock protects multiple variables, the lock itself may cause a false con.ict: two tasks using di.erent variables may not execute concurrently as they require the same lock.


We have implemented several techniques from both classes.

we implemented forced context switches via calling yield() method both in all threads accessing a critical variable v as well as only in those who are about to start using v while somebody else is already using v. We also implemented the healing by changing priorities and by adding new synchronisation locks.


Figure 3(c) illustrates that this approach to FSA encoding naturally allows for hierarchical automata since composition of tasks yields new tasks.

t is a task whose terminating event is given by the subtask t6.Thus t can be used as a node in a higher-level FSA.


Under PAST, the current interval is predicted to be as busy as the immediately preceding interval, while under AVG, an exponential moving average with decay Nof the previous intervals is used.

at each interval, we compute a weighted utilization at time t, Wt, as a function of the utilization of the previous interval Ut-1and the previous weighted utilization NxW...tu... Wt-1.


Subclassing exceptions The JAVA language specification dictates that exceptions must remain subtypes of Throwable, and unchecked exceptions must remain subtypes of an unchecked exception.

subclasses of Error and RuntimeException must not be changed to extend Throwable or Exception directly, unless all throws of such exceptions are either caught or declared.


In contrast to the parameter recon.gurations, the adaptive infrastructure must .rst prepare the system before a Server is added or removed at run time.

servers must be guided toward quiescent states to guarantee that recon.guration will not leave the system in an inconsistent state.


We have presented the rules in Section 3 in such a way that they can easily be extended to work with summaries.

the through at least one Ne edge, we can conclude that there are no paths from states in .0 to states in .k.


The theoretical model that we explore in this paper is restricted in a number of undesirable ways.

the lack of a special security level for this places a number of constraints on FJifP.


In addition to Nygaard and the authors, a large number of people have been involved in the development of BETA and the Mjølner BETA System including colleagues and students at Aarhus University, The Norwegian Computing Center, Oslo University, Aalborg University, and Mjølner Informatics A/S.

the contributions of Dag Belsnes and Jørgen Lindskov Knudsen are acknowledged.


Optimally partitioning the work metrics between the two endpoints may be described by first visualizing two fictitious pointers that initially start at the left endpoints of the two segments and then trace the sub-parallelization graph as the pointers move towards the right endpoints of their segments.

if the pointers are assumed to have coordinates (x1 ', y1 ') and (x2 ', y2 '), then the corresponding point in the sub-parallelization graph would have coordinates with a work metric of x1 '+x2 ' and an execution time of max(y1 ', y2 ').


In Idris, it is especially important to reduce the size of the subterms being scrutinized when possible, because the coverage checker can take signi.cant time when checking deeply nested patterns.

the constructor for references to global names contains three subterms: whether the name is a function, constructor or type constructor;  the fully-quali.ed name; and  a full type annotation.


The key is to specify when computations can proceed in parallel in a way that is (1) simple enough for programmers to reason about and rely on, and (2) .exible enough to accommodate implementation limitations.

we are interested in starting with an implementation that was designed to support only sequential computation, and we would like to gradually improve its support for parallelism.


5.4 Automation We now present a quantitative evaluation of the bene.ts of Weevil s automation features.

we measured the e.ort involved in switching between di.erent experiments with Chord performed on PlanetLab.


By the induction hypothesis, there exist placements Ri for every subtree Li, as good or better than both Pi and Qi.

each Ri is a correct placement for Li, therefore they enforce all dependences not carried by L and not lying in the body of L. We can extend the local placements Ri to a placement R for L by placing a barrier after each statement in the body of L (this is brute force, but enough for what we want to prove).


No additional constraints must exist on what is possible in a regular JUnit test.

the test must still be able to store references to objects it creates into itself, and the setup and tear-down methods must still be able to usefully create and destroy the context for the test.


The essential property that makesit possible the safe introduction of a circularity is Law 3.3, which states that the computation of the second component of type z is independent of the particular algebra that is passed to g. This is a consequence of the polymorphic type of g. Therefore, we can replace inF by another algebra and we will continue producing the same value z.

we can take k asthisother algebra,andinthatwaywe are introducing the circularity.


Furthermore, it appears that CWE provides multiple categorizations of vulnerabilities.

multiple CWE entries can describe different aspects of a vulnerability.


Experienced Offshore Team Model As the projects moves on, the offshore development team gains more and more experience in designing solutions, whence more and more responsibility is shifted to the offshore team members.

the high-level design and the low-level design are primarily done offshore, although the onshore team can still participate and support this activity.


One of the central properties of multistage configuration trees is that any connected path from the root node to a leaf node must be a monotonically decreasing (i.e., monotonically not increasing) sequence in the space of available feature choices.

children must honor the feature decisions made by their ancestors and may optionally decide to make additional feature decisions that further constrain the space of available feature choices.


To illustrate this, we consider a classic game Stag Hunt [3], [4] as shown in Table I.

two hunters have two strategies: remain attentive to the pursuit of a stag or catch a hare.


4.3 Semantics Jacques s semantics is like that of ClassicJava,with some modi.cations and additions; the changes are de.ned in .gure 11, with additional supplementary functions de.ned in .gure 12.

many of these rules perform the additional run-time checks necessary to ensure that acquisition is well-de.ned.


We design it in such a way that an execution goes 3 sz is the stack size actually consumed by the program starting from main, but we have to account for the return address of the caller of main wrong if the program tries to access more than sz bytes of stack.

stack over.ow becomes possible in ASMsz .


Both types of rules are not applicable to all instruction types as shown in Table 1.

the operator replacement rule is not applicable to three instruction types: move, compare, and other.


We believe that re.ection for AOP should be limited to adding new kinds of join point types, pointcut designators, and computation strategies.

parameters such as eval-program should not be the target of re.ection.


We have provided a generic notion of UI families, have presented tool support, and have evaluated our approach by application to a commercial real-world UI family.

we have demonstrated the bene.ts for evolution of UI families: Modi.cations need to be performed just once on the abstract product family model and can be automatically propagated to numerous individually customized products without loss of customizations.


While any syntax could be used, our approach uses Java style syntax for this extension.

the agent keyword is used to denote an agent class and the extends keyword to specify the parent agent class(es).


4.If a ThreadStack is allocated in scoped memory, the scope stack for any spawned thread inherits from the allocating thread.

the outer-most scope of a spawned thread descends from the inner-most scope of the parent thread at the time the ThreadStack allocation is performed.


These rules mostly ignore timestamps, since they operate on unary transactions that are by de.nition serializable.

the merge function ignores timestamps when searching for a representative step sj that (nonstrictly) happens after steps s1, ..., sk.


While JXTA aims at providing interoperability, platform independence and ubiquity for P2P wired networks (where connections are normally stable), Expeerience introduces management of intermittent connections and of multiple physical interfaces, increasing the potential of resource discovery, and providing a code mobility service, in order to give better support to wireless mobile ad hoc networks.

resource discovery is based on the mechanism of publishing/discovery of advertisements containing the information that each peer wants to share.


The key elements of C2 are components and connectors.

the style mandates that components cannot directly interact with other components, but must do so via connectors.


Consider the case of Green Destiny a cluster of Transmeta processors which consumes less energy than a conventional supercomputer.

green Destiny consumes about three times less energy per unit performance than the ASCI Q machine.


Statistical methods such as Analysis of Variance (ANOVA) [24] and Principal Component Analysis (PCA) [25] can be used to analyze the data in this space and measure correlation among data samples.

pCA can .nd a principal component (a vector in the d-dimensional space) that along this vector, data points are highly correlated.


The next section takes up the task of understanding how the software system was put in place and what the main components of the system were.

i show how the software sysstem is at the center of the higher-level bureaucrats vision.


Many system classes are used in the implementation of the JavaSplit runtime modules.

we make extensive use of classes from the java.util, java.io,and java.net packages.


Many occurrences of overriding methods (4 occurrences) strongly connect the sub classes to each other in the tree.

since many of them invoke the same methods de.ned in their super classes, the connectivity and dependency among the classes are much stronger.


The patterns can be used to assess the design quality of a DSL and structure its implementation.

we show a complex DSL example illustrating each principle and the corresponding patterns.


The intuition behind our approach is conceptually simple: if the ENV THREAD operation commutes with all of the MUT THREAD s operations, then we can shift the ENV THREAD s operation to not interleave with the MUT THREAD.

we can always produce a linearization of the concurrent history by simply moving all of ENV THREAD s operations before or after the operations in MUT THREAD.


To cut down on repetitiveness, we also use some notational shorthand for list kinds.


Our applications tend to produce multiple such .les concurrently.

n clients append to M shared .les simultaneously where both N and M are in the dozens or hundreds.


The arrow is in call by value, by which we mean that in t u, the argument u is evaluated .rst, when it is not already a value: ) (te u+ || p> > p u+ µ x+ .

(te || x+·p> if u+ is not a value ] (te V || p> >p (te || V ·p> contexts of the type A .


Additionally, rely/ guarantee clauses in reasoning about a concurrent program are normally developed using knowledge of the behavior of all the processes.

in this approach, when reasoning either about the base code or about the aspect, one uses the knowledge of the behavior of the other.


class D{} class C{ D f; C(D f){this.f=f;}} ... c1=new C(new D());c1.f becomes D d1=new D(),C c1=new C(d1);d1 the value new D() that was originally owned by c1, is now an independent value d1.


In this paper we describe Poli-C, a language extension and runtime that exposes new OS resource management features to application programmers with the goal of allowing applications to tailor resource management to their own needs rather than relying on the one-size-.ts-all approach supplied by modern operating systems.

we have added a powerful new statement to C that provides resource guarantees and limits in such a way that programmers can set resource management policies for, and among, hierarchically parallel applications.


Despite the benefits offered by DSLs, there are several limitations that hamper widespread adoption.

the state of the art for DSL tools, in general, is several generations behind tool support provided by general-purpose languages like Java or C++.


In instances where HCI specialists workin collaboration with SE researchers or practitioners, special considerations can and should be made.

care can be taken to ensure that the bridging representations chosen can serve to help coordinate HCI and SE processes.


However, SAA may impose a rejection problem.

it is possible that all subtrees at a certain level are rejected by SAA, so we make an adaptation to SAA.


Because the Java virtual machine understands the structure of the program, it can be queried by a program to know information about itself.

a Java program can understand its own structure at run-time because the run-time infrastructure understands and rei.es the structure.


As we previously observed, the validity of a schedule is determined by the dependencies described in the recursive function.

a valid schedule is one that ensures that any dependency between two elements is ful.lled by executing the dependent before the dependee.


Equivalently, b has as a su.x the sequence ¯'' '' (a,f+ f ' ).b where the size of ¯b is i-f.

if the block-fragment at position i is (a,f,0) then ¯b has as a su.x the sequence (a,f).


Furthermore, both backends share the same database schema.

if an X10 program is compiled to both Java and C++ backends, both of them will share a database schema and thus can interoperate with respect to their persistent state.


Between these two extremes, other formulations are possible; an excellent discussion of plausible de.nitions of determinism is given by Lu and Scott [27].

the executions are SyncOrder deterministic if they, in addition to agreeing in the .nal result, contain the same synchronization operations, executed by the same threads in the same order.


On the other hand, in August 2010, the Pex team added a new feature, Test Promotion, to allow developers to easily turn an automatically generated test into part of the traditional unit tests manually written by the developers.

when the developers like a generated unit test, they can click on the Promote button to turn it into a manually written unit test .


5.2 Information loss In this scenario we simulate a failure a.ecting the information that nodes store, but not the network topology.

the information disappears in some nodes but the nodes continue moving in the system and they can be used again to store the information.


In general, each method uses a subset of the features of its class, i.e., it could be a method of a auperclass, that is a more general class providing only that subset of features.


FraSCAla therefore provides a versatile and homogeneous approach to design the structural model of an ADL before deriving the associated language.

we illustrate in this paper how FraSCAla canbe usedtobuild ageneric component model that is then re.ned towards an ADL for the Service Component Architecture (SCA) industrial standard.


As we will illustrate through examples, the consequences of this additional .exibility can be powerful and subtle, allowing the behaviour oftheimplemented system todifferdramaticallyfrom that of the atomic system.

the adversary can manipulate executions so that low-probability worst-case results in the atomic systembecome much moreprobablein theimplemented system.


Because b is well-aligning and v bx, there exists a j such that v ~xj and b xj .w = bx / xj <w for any w. In fact, that j must be i, by the same argument as in the proof of Lemma 19.

fs = xi bx, a fact that we shall use below.


It is associated with branch instructions and contains as many operands as outgoing edges.

conditional branches will contain two operands, one for the true value of the conditional, another for the false value.


We observe that a signi.cant fraction of the pages are remerged.

the pages are not primarily write-once in nature.


Those applications have gone far beyond the pure textual group editors in which OT was originated [3].

it has been shown that OT is a powerful tool for implementing selective undo [9, 14] mainly because it is able to transform any pair of operations to commute.


We found that it may be possible to apply the more narrowly de.ned identi.er .aws as screening tests at the method level.

the absence of poor quality identi.ers in a method is largely indicative that the source code is more readable and that there are no defects associated with the method.


In case compaction is allowed, avoiding reuse is more dif.cult.

a sparsely populated chunk can be evacuated and reused by the memory manager.