All such interaction took place through IM.

our experimental setup consisted of one participant collaboratively solving a given set of tasks in a threeperson team in which the other two team members were confederates.


Spatio-Temporal Queries: in a mobile environment, answers to user queries can vary with location [11].

query results depend on a query s spatial properties.


However, we are going to ensure that anylet-bound expression has a principal type through the rule LET-FG.

the constraint minimal(s1) should ensure the we can infer a unique principal type for the let-boundexpression.Wehave some choice here for the de.nition of this constraint.


Similarly, 8 out of 17 days for Soc have RelCSmax greater than 50%.

the set of top10 videos were strongly related.


We include a frame rule on M, WI T FR A M E, to simplify our presentation, which together with WI T SK I P allow us to isolate the parts of the query that a block of code may affect and to ignore irrelevant statements.

any statements that cannot affect the memory state in the query can be skipped.


This phenomenon is qualitatively worse than ambiguity, since it means that the derived functions inj and prj do not satisfy the INVERSE law.


Since after normalization, a loop cannot have only uses in it without a de.nition, that further means there is a de.nition at an inner loop level.


These tests are preliminary micro-benchmarks and therefore call for further measurements.

benchmarking re.ection on sizeable applications, while reifying various operations, would be of great interest.


At the beginning of each test, the SLICE algorithm uses the con.icting information in the con.ict database and the collected slices to devise an execution order with the goal of minimizing database resets.

if the con.ict database contains a con.ict information of (S).Ti (where S is a slice of test traces), and there are no known con.icts between Ti and any of the test traces in S, SLICE should arrange Ti to be executed before S. At the same time, SLICE does not change the order in which the test traces in S are executed because these test traces can be executed in that order without requiring a database reset.


Students have indicated that seeing the links being set correctly (or incorrectly) as they step through their code is extremely helpful with respect to their understanding of exactly how the implementation relates to the abstraction of the data structure itself.

seeing a node added on the blackboard as links are redirected is easy, but when it comes to understanding how this happen in the actual code, it is suddenly not so easy.


In many cases the execution speed of the generated X10 code was comparable, and sometimes slightly faster than the original MAT L A B code.

the results with the native backend were quite encouraging.


Families of setoids form a category FamSetoid which is .bred over Setoid in the same way Fam(Sets) is .bred over Sets.

the objects in the .bre EA are families of setoids B : A .


So, for example, if the function invocation f(a) returned b at a certain time, then in all successive moments the call f(a) will return b again.

stateless services can be modeled with deterministic service calls.


Using the opt-in model the application developer has to be aware of those aspects that are supposed to be woven into the bundle s classes.

the aspectreferences have to be explicitly specified by means of Import-Package or Require-Bundle directives in a bundle s manifest file.


Centralized schemes rely on a central entity that either has or is capable of retrieving the information necessary to configure eNBs with adequate PCIs.

the central entity has a global knowledge of the system.


Inner) { Insert explicit null check for C at the exit of basic block n; } 4.2.2 Algorithm for Explicit Null Check Elimination The goal of this stage is to eliminate explicit null checks that are known to be substitutable.

they are redundant because they can be checked later in the control graph.


In this paper, we propose an architectural optimization of MB-A with the objective to achieve green-ness in the architecture by reducing its total computational cost.

we use ensemble-based architectural design in which, on the lines of Weighted Majority [10], we train an ensemble of prediction models for each server, and periodically learn and update the meta-attribute of each prediction model.


The concept of satis.ability plays an important role in the following sections.

we say that a set of predicates P is satis.able if Ø..SP for some substitution S. Equivalently, we say that P is satis.able if LPj= Ø,where LPj= {SP |Ø.


This means that after 24 hours of not using the cup, the association was deleted and the cup got freed.

you would have to associate the cup typically once a week.


However, security engineering approaches for embedded systems can build on a large body of work in IT Security.

a large variety of security mechanisms already exists and is ready to be deployed for embedded systems.


Our Tactic Topology Model (decision view) can also be considered as a compact representation of a pattern, because the fewer constituent tactics denote what the pattern is and what it is not.

constituent tactics denote what quality requirements are addressed and what quality requirements are not addressed in a pattern.


One primary advantage of using BDD is that point-to graphs need to be maintained for every procedure, each of which may share many common edges.


All three techniques draw from traditional approaches to fault localization, but their incremental algorithms and visualization strategies are unique to the requirements of end-user programming.

all three techniques seamlessly integrate incremental visualizations into the spreadsheet environment.


Finally, because of the adherence to the original execution, the predicted executions share the complexity of the original one.

the predicted schedules that PENELOPE synthesizes can have hundreds of thousands of context-switches.


3.3 Combining Approaches Along with discussion of implementation of FA-MPI using ULFM, ULFM routines can be used in conjunction with FA-MPI for failure management of blocking operations.

fA-MPI can support synchronous fault-tolerance with the help of ULFM.


The videos selected by the recommendation algorithm in the current period must be downloaded before the next period starts.

t can be considered as a deadline of video downloads.


The interfaces for integral and other quantum chemistry computations are defined from a chemistry algorithm point of view.

the interfaces for data and methods performing electronic structure calculations are defined, but not for the procedures to improve code efficiency, such as using of screening.


Adding abstractions to the type language, such as in F., would require more signi.cant changes.

our de.nition of type equivalence would have to be extended to include ß-equivalence for these abstractions.


3.2.2 Domain-Catalog Inheritance What applies to the application can also apply to the domain (or industry) level.

an entire software catalog containing several applications can be inherited by a more complex or larger industry.


believe that cities should be subdivided into local transport areas by highways and these transport areas themselves should be further subdivided into communities and neighborhoods by streets.

highways are like main arteries in a body while streets like capillary vessels.


The message variables ArgS 11, argS,1,2 and cC ::= argS,1,3 .

the key KC contained ArgS 12 and ArgS 13 stand for the server receiving messages in the signature matches the one transmitted in the clear.


Two have the form BB(xT ) ( binding begins ) and BE ( binding ends ) and are related to terminal variables.

for a pattern of the form var xT as P , we add the mark BB(xT ) to the starting state of the sub-automaton for P and BE to its .nal state.


A number of other MOP-based systems are worth mentioning.

chiba introduces OpenC++ [4] which is very similar to OpenJava and shares most of its relavent strengths and weaknesses.


Another possible threat is due to the employed tools.

bugs may influence the generation, compilation, executions and determination of the killed mutants and thus, affect the reported results.


Special forms of the insertion and extraction methods are provided to simplify their usage.

the method ins1All(a), applied to a list l,where a is an array of elements of a type t, returns a list obtained from l by adding all elements of a as the head elements of l,respectingthe order they have in a.


Unlike the de.nitions of the Core language, module bindings must have a strictly hierarchical structure: the dependency between modules can never be cyclic.

although de.nable within the con.nes of a single module, de.nitions of mutually recursive types and values can never span module boundaries.


In such a context, by exploring Internet capabilities, distributed features of applications have been strongly strengthened, enabling the development of innovative distributed software systems in several domains including: interactive digital television, elearning, cooperative work, and videoconference.

interactive digital television (iDTV) has becoming increasingly relevant.


In addition to porting ScmPkg to new Scheme hosts, we also have to add an additional feature that is not tackled by the .rst version: currently ScmPkg does not allow the programmer to specify packages that export types!

currently an interface may only export functions, variables, and syntax.


But none of these work aim at de.ning a new language and a graphical interface for abstracting the problem of the SCV testbench speci.cation for ESW application, as the present work does.

the proposed TSL-based approach allows complex generators to be synthesized from concise representations of the stimuli.


We implemented the cluster algorithm using Weka clustering algorithms including the EM (expectation maximization) algorithm [12].

the EM algorithm returns a set of clusters by determining whether the distribution of instances to clusters is acceptable or not.


Thus, all streams accessed by a kernel must be made available in the SRF before the kernel is executed.

no live range in the IG should be spilled during coloring spilling has already been done in live range splitting.


For simplicity, we adopted many of the same conventions used by jvm2ada (the tool that translates Java class files into Ada specifications).

we used the same techniques for handling interfaces, circular type dependency, and constructors.


Indeed, we can treat a SubRegion witness as a monad morphism, and a call to newRgn as reifying an effectful computation.

for one region to spawn another is for a monad transformer to apply to the parent region s computation monad.


Therefore our framework should be applicable to a wider class of medical diagnostic problems that require data-intensive computations.

it meets the medical experts demands for feasible and accurate diagnosis of mild HCM in athletes.


The widespread adoption of multi-core processors signi.cantly exacerbates these problems, both by increasing the degree of thread interleaving and by making memory model and cache coherence issues much more prevalent.

relaxed memory models cause programs with intentional race conditions to behave in ways that even experienced programmers .nd subtle, complex, and counterintuitive.


Once the execution of this method has ended, these permissions are handed back to the caller.

the caller loses full access to this.f and partial access to y.f for the duration of the call.


= 1, at the cost of a sub-optimal rate growing to 1 - e -1 as N tends to in.nity [17].

some redundancy must be added to the original stream so as to recover from the loss of chunks.


In addition to tools that provide formal coordination mechanisms within teams, software developers use informal devices and develop processes to support their task management activities.

they use annotations to manage their tasks.


This syntax, where the temporary variables and .elds are not distinguished syntactically, makes the compilation of code context dependent.

the meaning of a line of code can be different depending on the existence of local bindings.


Finally, we conclude this section by collecting together some rules which are common to all the examples presented in Section 5.

we have two rules for the environment: e1) ..-.


Since we were working speci.cally with the use of design Patterns, the team .rst tried to identify an existing example of success.

they tried to identify some example where someone had writer s block and something helped.


Because the basic design has to accommodate universi.ty structures and processes across many countries, much of the functionali.ty can be configured in more than one way and the overall functionality is likely to be much wider than that required for any one count .ry.

because the system was in~nded for general release to a global market its design had taken on something of a 'baroque' character, encompassing the processes.


In this case, the bound of AnyShape is insuf.cient to constrain the function intersectMany.

the function may encounter pairs of shapes for which no Intersect instance can be selected, which is clearly inconsistent with static typing.


With a suf.ciently aggressive optimizer, one might hope to eliminate the pre-normalization requirement and still get ef.cient code when the actually argument has been normalized.

the compiler should perform the following optimization (interprocedurally).9 normalize (normalize v)= normalize v Rather than wire this domain-speci.c optimization into an otherwise domain-independent compiler, Vertigo performs simpler and more general rewrites.


When the data is non-linearly separable, a technique similar to the idea used for kernel PCA can be employed.

a nonlinear transformation is applied to the training data points xi .


3.1 Real-time Performance Real-time is a property that allows reasoning about time and temporal characteristics of the system.

for this DP system, the approach adopted in the DP architecture to implement realtime was to use a periodic task set that repeats execution at speci.c moments in time.


This paper posits that mobile devices are not just infotainment platforms, but are also powerful distributed sensing devices.

continuous sensing and processing of a variety of deviceembedded sensor streams (such as accelerometers, gyros & microphones) represents a distinct application class, that provides invaluable real-time context for a variety of consumer and enterprise applications.


The Intel IXA NPU family of network processors (IXP) is such an example [2] Effective compilation of sequential packet processing programs for execution on the Intel IXP requires that the compiler perform an array of program transformations for the effective utilization of the various forms of concurrency available on the machine.

multi-threading is required in order to mask the relatively long latency of accesses to off-chip RAM [1][7].


The average energy savings in this case are 18.3%, 9.7%, and 25.8% for the CPU-only, link-only, and CPU+Link schemes, respectively.

even when all the overheads incurred by our approach are included, combined scaling of both CPU and communication links leads to signi.cant savings.


We compared the response time of queries by considering several con.gurations.


The approach presented in this paper facilitates techniques and methods of the view-based modeling framework (VbMF) [15, 16, 17, 19, 18].

vbMF Core model is derived and extended, on the one hand, to describe concepts in the domain of business compliance.


One of the most dif.cult properties to prove about the decoder was the uniqueness of parsing.

we needed to show that each bit pattern corresponded to at most one instruction, and no instruction s bit pattern was a pre.x of another instruction s bit pattern i.e., that our x86grammar was unambiguous.


For any timed automaton A of De.nition 2.3, we can obtain a corresponding timed automaton without acceptance invariants AT by adding a new location that is the single accepting location and adding transitions from all accepting locations l of A on the spe v cial symbol that are required to meet the clock invariant o .F (l).

for A= (L,L,S,X,.,E,LF ,.F ), we de.ne the timed automaton (without acceptance invariants) AT as o (L.{f},L,ST ,X,.,E1 ,{f})where f is a location not in L, v and E1 = E .


An important point to note in these tables is that only the intrinsic type semantics are captured without any attention to shape.

tables 1 and 2 tell us how the intrinsic types map, assuming that the arguments are shape conforming.


To identify t, we canformulatetheproblem as sequential change-point detection.

at each time point t, we want to know whether there is a beep signal present and, if so, when the beep signal is present.


Note that the generation of events from the run of a program leads to a notion of pattern-matching of variables in our speci.cations.

the state2 S. denotes the extension of S with the binding from variables, occurring in the pattern matching of ev, to their corresponding program values.


Summary of user feedback for OSF As noted in the figure, most of the features were evaluated positively.

subjects found it very useful to be able to display or hide at will the visual representations of the various ontological levels.


Since it is at an early stage of development there are still several open issues to solve.

the following questions deserve closer attention: Overhead An open question is how much speci.cation overhead does our approach cause for the developer.


Conclusions This paper has drawn a novel analogy between microeconomics and memory management.

we have introduced the allocation curve as a graphical model for an application s interaction with the GC.


The primary contributions of the paper, however, are not these end results (linear time algorithms are already known for these problems), but the means used to achieve these ends.

the paper illustrates for these two problems how arbitrary problem instances (including those based on irreducible graphs) can be transformed into equivalent problem instances based on acyclic graphs.


The important experiences of Peer-to-Peer (P2P) computing- based software systems, which have come to maturity with systems like Napster [6], Cmutella [7] and Freenet [8], have inspired our work, but our system is essentially new, in the sense that it allows a reliable and distributed song sharing service over mobile UMTS devices.

in order to ensure both the availability and the responsiveness of our music-on-demand service, we have structured our system according to the special technology of the "replicated Web servers" [9, 10].


It is often the case that the effect an action is modi- fied by another action executed concurrently by another attacker.

the result of a joint action, executed simultaneously by several attackers, could go beyond the sum of individual actions.


Another important issue regarding the scheme in Figure 1 is that the test set on which the evaluation is made may have no relationships at all to the project being estimated.

applying the scheme in Figure 1 would mean that we would make a decision about which model is best without taking into account what we are trying to predict.


In some cases, the approximation is too conservative, creating long-lived regions in which many items are no longer needed.

items referred to by global variables are placed in a region which will be kept until the program exits.


They are analogous to virtual methods in traditional object-oriented languages: they follow similar rules of de.nition, overriding and reference.

virtual classes are de.ned within an object s class.


This allows to bind,at run time,a service oriented system with a set of services that,among those providing the required features, meet some non functional constraints,and optimize criteria such as the overall cost or response time.

qoS aware composition can be modeled as an optimization problem.


Many teams either develop too much, too little and/or outdated documents.

answering the question How much documentation is enough?


This heuristic tries to offset the effect of lower-priority tasks on higher-priority tasks.

the WCET of high-priority tasks affects low-priority task response times, so reducing high-priority task WCETs should bene.t response times for a set of tasks.


In our prior comparative study [56], global algorithms based on Hidden Markov Models (HMM) are the most accurate for o.ine map matching.

the best performers are the HMMs whose transition probability incorporates the length of the shortest path between two consecutive candidates [34, 40].


it follows that the instance message m1 must be greater than the leader message m of v2, which in turn means that p2 cannot have pass Line 16 in round r2 by receiving m. (Case 3 ) p1 used Line 21 and p2 used Line 44: This implies that p1 received a leader message mv from node v1.


It also implies that any research done on human-seeded faults should be carefully interpreted, since we see that by using the example programs used here which have been widely used in previous research [8] one would obtain conservative results when assessing the fault detection rates of test techniques.

this would lead to underestimating the effectiveness of test techniques.


As further evidence of the lack of great models, the Agile Software [1] community believes that too much documentation (modeling) is worse than too little.

when in doubt, they would rather you attempt to write the code than create another model that describes what you want the code to do.


3.1 Expressiveness of Generic Ownership Comparing Figure 5 with Figures 1 4 shows that it is slightly more complex than the individual type genericity or ownership examples, but rather simpler than the straightforward combination in Figure 4.

figure 5 s declaration of the Map class has only three parameters (the same as in Figures 2 and 3).


The remaining two forms can be solved by standard techniques.

the quali.er constraints in F form an atomic subtyping constraint system.


The instances at this level are the result of the rei.cation.

the base-level is the set of objects that forms the mediation application (i.e.


The .nite variability restricts [24] that within any bounded interval a discrete-valued state can change only .nitely many times.

we assume that for a discrete timed trace, an interval is classi.ed into two groups: (1) the discrete timed trace is constant over the whole interval; or (2) the interval can be decomposed into a sequence of sub-intervals, and the discrete timed trace has different values in any adjacent sub-intervals.


This yieldsqualityproblemswithrespect to thedevelopedlanguages;atrendthatalsohits uncontrolledsoftwaredevelopment.Existingstudiesindicatethatabout 30%ofdeveloped DSLs aretoo narrowortoo broadtobeuseful, orthat about 40%ofalldevelopedlanguagesdo not re.ecttheprocesses thattheywillbeappliedin(cf.

[8]) We therefore developed a DSL development approach that transfers well-proven concepts of software engineering tolanguagedevelopment.weusetheconcept of design patterns and traceability to improve language development.Design patterns capturelanguage development bestpracticesbyconservingprovensolutionsand documenting theirproperapplication.Traceability ensuresthatdecisions are documentedandlinks partsofthelanguagetothe requirementsthatthey originate from.Bothdonotonlyincreaselanguage quality,but also enable developers to better understand DSLmetamodels,which both enables quality controlactivitiesandmaintenanceactivities.


In our investigation, we use 1S to compare the amount of information transferred by two mappings from the same source schema.

if M1 1S M2 and M2 1S M1, we say that M1 and M2 transfer the same amount of source information, which is denoted by M1 =S M2.


Modemachine and Traceability In fact, constructs ifEq and modeMachine are themselves abstractions.

we use Haskell as our macro language to express these constructs in terms of more primitive EDSL constructs.


Mae provides an opportunity to alleviate this problem: its system model contains all the information necessary to automate architectural differencing.

mae integrates the architectural entities that change with the versioning information that describes the changes.


public X getMin() { ... } } class C supports method store only when type parameter X is a serializable type.


The properties are all possible method invocations of this class or trait.

these are methods that can be invoked by sending messages to self within the class or trait.


If the operation Al of a failed transfer (Al(inp)) becomes repeated, the work ij .ow does not need to know about that the underlying tool uses its own records to continue a previously failed operation.

we model the Ai actors as atomic operations that either succeed or fail.


Thus, elimination forms of sums (e.g., match or case) correspond to introduction forms of records.

record extension (an introduction form) corresponds to extension of cases (an elimination form).


For c = k or c = k+1,there is a run of A such that c is the .rst clean round and some process decides in round c+2 or later.

5.3 Extended results For loquacious consensus algorithms, we have shown lower bounds in terms of c, and there are existing early-stopping lower bounds in terms of t and f. let n = 3 and t<n-1, and let Abe a loquacious algorithm for (n,t)consensus.


2.1 Cost study Before we describe how we address these challenges, we brie.y estimate the cost to users if services such as Facebook were implemented in a confederated manner.

if each user contracted with a cloud provider to pay for their use of services such as Facebook, what would the per-user costs be?


Such a technique consists in the measurement of radiated near EM .eld close to the device under test (DUT).

an electric .eld probe scans the DUT surface and the electric .eld is picked up in several points.


<rdf:RDF xml:lang="en" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:serv="http://localhost/RDF/servizio.rdfs#">  <serv:ServiceProvider rdf:about="provider ...">   IDFP1SOM   TRANSPORT     Check_Hotel_Availability   SM01   Service providing a check for hotel availability     arrival    IN  STRING      departure   IN  STRING      category   IN  STRING   <serv:Parameter rdf:about="result parameter">   Ris   OUTPUT  STRING     Figure 5: SDL specification for the check_hotel_availability service Our future research will be focused on the implementation of all the components of the framework.

we plan, first of all, the development of the Process and Services Integration Manager, to provide an effective means for integrating the framework proposed with a workflow management system developed in our research group [2].


We conclude that a notable social cost due to free identities is incurred only when a penalty on all newcomers is unnecessarily imposed.

the cost is incurred only under high turnover rates (d) and only in conjunction withintermediate contribution levels (tm)and low system bene.ts (a).


This paper is not meant to make a technical contribution to the area, but to propose and motivate a research endeavor based on a review and classi.cation of feature interactions addressed in the literature.

we make the following contributions: A discussion and classi.cation of different kinds of feature interactions addressed in the literature.


In the .rst week of testing, most effort was spent in dealing with ambiguities of the POSIX standard.

handling the instances where Linux (or Solaris) gave a different, undesired, error code, producing spurious divergences, was a substantial one-time effort.


5.4 Solicitation Pattern 5.4.1 Context Some essential information is needed by a party to make a decision that will affect the flow of some interac ction that is yet to start.

information about the chara acteristics of other participants service offerings is critical to makin ng a decision as to which participant is to be selected for the interaction.


We assume a model in which processes do not fail stop outside their remainder section.

if a process is active, then the adversary must eventually allow it to perform its next step.


By analyzing the source code implementing the sin function, this machine-learning based approach may predict that this function has an MR whose input change and output change are both additive3 .

for the sin function, this machine-learning based approach may infer metamorphic relations like sin(x) + c1sin(x + c2) = 0, where c1 and c2 are constants and x is the input parameter of the function sin.


As it is shown in Figure 1, the metrics considered in the measurement framework can be brought to the essential aspects involved in a process model.

the evaluation of the metrics involves: - Activity: referring the lowest level of details of the performed human tasks with reference to the business process - Resource: regarding all the resources involved in the activity execution, including both human resources (Actors), and inputs/outputs data required to perform the activity (Artefacts).


[2]) among the fractions should be handled correctly.

it may be necessary to add/remove these component fractions in a certain order.


However, ensuring that updates to local state are protected by locks is the programmers responsibility.

as both completion operations and local operations can update local state, all state accessed within completion operations must be synchronized appropriately.


Instead, we will want to obtain inductive-recursive de.nitions by appropriately instantiating a single, generic theory of induction-recursion.

we will want to instantiate a uniform, axiomatic approach to inductionrecursion that is widely applicable, and that abstracts over the speci.c choices of index and the codomain of the decoding function.


ii) to identify OO-Method conceptual primitives as concerns.

iii) to propose an optimized transformation tool, aspect-based, that should improve the current model transformation techniques provided by the method the paper shows how this would work for a selected subset of the introduced OO-Method-based concerns.


We believe that the use of (partial) scenarios is a key strategy in dealing with the problem of expressing event-based properties.

our approach consists in graphically describing those generic scenarios of the analyzed model which violate the requirements.


In this paper, we consider the memoization problem for a higher-order concurrent language in which threads communicate through synchronous message-passing primitives (e.g.

concurrent ML (Reppy1999)).Asynchronizationevent acknowledges theexistenceofanexternal action performedby another thread willingto sendorreceivedata.Ifsuchevents occur withinafunction f whose applications are memoized, thenavoiding re-executionatacall-site c is only possible if these actions are guaranteed to succeed at c. using memo information requires discovery of interleavings that satisfy the communication constraints imposed by a previous call.


(ii) Is the additional e.ort paid back by an improvement of the software requirements comprehension?

the adoption of screen mockups in the requirements engineeringprocessshouldkeepintoaccountthecosts it introduces.


In the second and last phase, I plan to extend the approach towards .ner grain coverage criteria.

i aim to cover data .ow criteria, since I expect the ARC approach to be particularly suitable for these criteria that su.er greatly from the presence of infeasible elements.


2.3 Peer-to-peer In the peer-to-peer architecture (P2P), each peer has an SLT (Surrogate Location Table) which contains the location information of all the peers and their respective contents.

for each peer surrogate an SLT has an entry formalized by the pair , where CZ (Content Zone) is the space of the identifiers of the contents potentially stored in the peer identified by SId.


Migrations are handled at thread level for accuracy.

migration of responseawaiting-services is handled based on the communication behavior of the service.


The fast deployment of networks like Wi-Fi, 3G and LTE makes phone users more easily and widely connect to the Internet.

most smart phones are equipped with modern web browsers like Mozilla FireFox, Apple Safari, Google Chrome, Opera, etc.


tween concepts used on both sides to stress the relationship between refactor to understand and program comprehension.

concepts like rename attributes/methods/variables and extract methods or local variables in refactor to understand are associated with introduce beacons and introduce chunks in program comprehension respectively.


Then, a requirement on the translator is to perform exactly the same type inference as Simulink.

every model that is accepted by Simulink must also be accepted by the translator and vice versa.


We believe indeed that the internal state of the decision process is a variable to consider in the implementation of autonomic solution.

it seems interesting to be able to change the behavior of the manager based on the results and performances of previous executions.


The underlying idea is to exploit the advantages of MDE [27] to build tool support for the methodological proposal presented in [1] that provides formal definitions about the evolution of Web Services and the conditions for Service compatibility.

this work has introduced the use of a bunch of DSLs and model transformations that allow: to inject WSDLs file into Abstract Service Descriptions (ASD); to check whether two different ASDs representing two versions of a given service are compatible; and to generate randomly different versions of a Service in order to check the functionality and performance of the compatibility checker.


Here x appears free in the argument to f, which appears in an antiquotation and is some metalanguage function that manipulates object language fragments.

we would like the programmer to be able to reason about this fragment without knowing the implementation details of f. the programmer should not have to know what object language context f might place its argument in in the process of building a new object language term even if that context might bind a variable named x.


Tanter [9] similarly advocates the use of cross-cutting techniques to reduce the expense of reflection.

he identifies that MOPs typically reify every object in the system, however the majority of these meta-object are rarely used; this increases memory costs, and adds unnecessary levels of indirection (as invocations pass through the meta-level).


It can be shown that, after all generated operations have been executed, if the S and M conditions are satis.ed, all sites will have exactly the same set of characters and they are in exactly the same order.


For example, if (A OR B) AND C is a decision, MCDC requires that each of the conditions A, B, and C be demonstrated to independently influence the outcome of the decision.

each condition can be toggled to vary the outcome while holding all other conditions constant.


Intuitively, given a speci.cation SPEC , the hard-masking tolerance speci.cation of SPEC is identical to SPEC .

the occurrence of all faults are masked.


In the example just mentioned, any pair of arrays that can be passed into the procedure are not regrouped.

array regrouping guarantees no need of code replication in the program.


The Cactus runtime system provides a variety of operations for managing events and event handlers.

operations are provided for binding an event handler to a speci.ed event (bind) and for activating an event (raise).


Section2provides background onexploiting redundancy 1 - 1 N of the total capacity, while RAID1utilizes only 50%.

given the same individual disk capacity and the target total capacity, RAID5 uses fewer number of disks than RAID 10.


Second, security patterns should include enough detailed information (down to the level of reference code), e.g., to help automate the implementation phase.

security patterns are tools to provide additional guarantees that a software product is correct.


The two rules for well-formed methods enforce thatthetypeofthe methodbody s termisa subtypeofthe declared return type, that a method of a superclass is being overridden appropriately, and that no subsequent re.nement introducesa method with the same name.

override considers methods that are overridden by the given method and introduce considers methods that are introduced later and establishes whether they replace the given method or not.


One simple strategy is to fall back to a representation of argument lists as list of tagged unions at least internally.5 Danvy s approach is to make use of continuation-passing style in the implementation of the interface.

type a va_sig is the type of continuations that expect a list of arguments (in NLFFI s internal representation) and map it to a result of type a.


In addition, the presented system can be used as an instructional tool for teaching students about collaborative systems.

students can use the system to experience the impact on response times of processing architecture, multicast, and scheduling policy.


LIFE CYCLE OF LINES In order to investigate the life cycle of lines for the complete ECLIPSE project (snapshot 2005-11-23) we annotated all text .les with information about all past changes.

we collected the revision identi.ers and the authors.


This, in turn, has transformed the characterization of the Tolsum tablet's meaning away from one recording the sale of an animal.

the classicists re-read Vollgraff's original 'BOVEM' in line 4, as 'DQUEM'.


However, it requires that the nesC compiler replace all field accesses by offsets, replace uses ofoffsetof, and many other issues.

c arrays behave differently from other C types, so all assignments, casts, pointers involving network types (note, e.g., the declaration of pCmdMsg 5 For completeness, we also provide little-endian versions of the base types, named nxle .... in the example above) require special handling.


number of cores (default configurations) number of cores (default configurations) Figure 1: PDF vs. WS for parallel merge sort compared to WS.

bandwidth-limited irregular programs and parallel divide-and-conquer programs present a relative speedup of 1.3 1.6X over WS, observing a 13 41% reduction in o.-chip tra.c.


The GigE and 100Mb/s host clients need very different optimal local:remote ratio, which can be derived approximately at store time using our throughput model, or with a diagnostic test similar to these experiments when a workstation joins FreeLoader.

in both cases the peak throughput with asymmetric striping is signi.cantly higher than the local I/O rate, motivating the use of FreeLoader even when users do have enough local disk space, for higher access rates.


T ' ) represents a candidate group between two statements.

if two statements belong to the same candidate group, there is an edge connecting them, e.g., S1 and S2 as shown in Figure 5.


We require that,by the end of every constructor of class C (including the default constructor,if any),every non-null .eld declared directly in class C has been assigned.

we require that every path through a constructor to a normal return include an assignment to every non-null .eld.


Finally, we would like to explore applications of our inference for program analysis.

cheaper or stronger formulations of alias analysis seem promising.


Spatial links, when combined with particular arrangement policies for grouped classes allow depict in an emphatic way component crossdependencies.

our tool allows inspecting calldependencies and crossinvocations from different perspectives via automotion flying cameras.


The key design principle we have used is to optimise for the common case, rather than for the worst case.

while our algorithm handles multiple inheritance, it exploits the observation that in practice, multiple inheritance is used relatively infrequently.


We can make reasonable changes to the system without breaking all the pieces of the system.

a small change in one class only causes a manageable number of changes in other classes.


(ii) Replace tuples and tuple operations with maps and map operations.

replace tuples of more than two components with tail nested tuples of two components, e.g., [XYZV ] becomes [X [Y [ZV ]]]; then, for each 2-tuple Z and map M,replace  while exists Z in M ... Z... with while exists X in dom(M) while exists Y in M{X}... [XY ]..., replace for-loops in a similar way, and replace M = {}with dom(M) {}; .nally, replace [XY ] notin M = with Y notin M{X}, and replace M with := [XY ] with M{X} with := Y .


For example const int bufsz = 256 * 4; int main() { int buffer[bufz]={0}; // bufsz is constant 1024 // ... } This de.nition of constant expression in C++ [2] is quite conventional.

a call to a (user-de.ned) function with constant expression arguments is never considered a constant expression.


In Figure 6 the process schema related to the ELDA-based methodology (see Figure 6) is shown.

the process starts with two parallel activities: -Simulation Model Definition, which provides an ELDA based simulation model for the considered Agent-based High-level System Design produced by using specific phases of available agent-oriented design methodologies [2].


In fact, experience with a commercial Windows application of over 100,000 SLOC developed in this style shows that real software is not only feasible but also of notably higher quality than software built using traditional methods [4].

this proposal for how to specify iterators is not based on an unrealistic closed-world assumption; it also is not based on business-as-usual in C++ or Java.


The .rst is philosophical: pointFactory is an object, and the central tenet of objectoriented programming is that objects are encapsulated behaviour.

the only thing that we can do to an object is request that it execute a method.


Interestingly, though, such loops that are recognized automatically ful.ll the data-.ow and control-.ow constraints that we mentioned.

loopsAJ will never match loops that break or continue to outside the loop or return abruptly.


The implementation runs both RatRace and A in parallel, in a round robin fashion.

each process executes a step of RatRace in every odd step, and a step of A in every even step.


TimeStream manages to combine the best of both MapReduce-style batch processing and streaming database systems in one carefully designed coherent framework, while at the same time it offers a powerful abstraction called resilient substitution that serves as a uniform foundation for handling failure recovery and dynamic recon.guration correctly and ef.ciently.

timeStream makes the following technical contributions.


For instance, WebSplitter [19] redistributes portions of web pages, WinCuts [34] redistributes window viewports, DistriXML [17] detaches and attaches toolbars depending on the current task.

the granularity of UI distributed elements is often very high.


interaction among LSCs) is a part of the operational semantics of the LSCs.

it is embedded in various use case scenarios scattered throughout the whole system.


In order to minimize the average time complexity, we adopt a hierarchical technique by choosing to schedule statements at one level in the abstract syntax tree (AST) independently of the other levels.

we schedule a list of statements that might include compound statements, treating the compound statements as atomic statements that are not schedulable.


But sometimes, only a speci.c portion of the parameters, usually dependent of the rank of the member in the group, may be really useful for the method execution, and so, parts of the parameter transmissions are useless.

in some cases, there is a need to transmit di.erent parameters to the various members.


The success of this technique says as much about the nature of software as it does about genetic programming.

it highlights the strong analogy between software and living, complex evolving systems.


For each generated interval-timed trace, we automatically checked that the trace satis.es all the intended properties of the HBM described in Section 4.1.

we automatically constructed a UPPAAL timed automaton whose language is exactly the singleton set consisting of the given interval-timed trace.


This situation is unsatisfactory at best, since the resulting systems may be unreliable and difficult to revise and extend.

the reactive nature of event-driven systems (such as a GUI) makes them much more difficult to test, since the output values strongly depend on the interaction that may occur during the computation.


Likewise, the individual system cost can approximate the upper bound on the hardware cost of the system.

if the system were entirely composed of hardware then the system cost would be the hardware cost.


This program is security unsafe, since observing the communications on port p, even if the communicated data is hidden, reveals information about h. Our solution to implicit information .ows is standard except that we have to treat send actions as having the lowest security level.

we ensure that the label of each instruction is at least as high as the label of the program counter when the control reaches the instruction.


The problem with this approach is that the discrete transitions that model the crossing from one convex polyhedron to an adjacent one do not preserve the di.erentiability of the trajectories.

there are trajectories in the modi.ed system that do not correspond to any trajectory in the original system.


For Models 2-4, the average percent of identi.ed faults exceeds the average percent of lines of code in the .les.

there is potentially a 12% saving for Model 2, a 27% saving for Model 3, and a 24% savings for Model 4 when averaged over all available releases.


Given these findings we suggest, in the case in using XP for product development, that users are a contextual concern to development work.

knowledge about users is formulated and brought forward in ways that shape and enable development work to be done.


We have shown that packages may depend on other packages that are not required to share the same implementation dialect.

it is possible to blend packages regardless of their implementation language.


However, software developers were the ones who actually talked to their colleagues and negotiated the exposition and/or implementation of new services in an API.

although APIs were organizational practices to deal with software dependencies, the communication, coordination, and negotiation to make them useful were actually performed by software developers.


We found that these two models may not model the collusion attack well.

they do not address the situation when the attacker is in fact in possession of the private key of the signer.


[1,|S|]is the smallest integer such that S[i+k]=S[i].

a phase is a subsequence of S that starts with the speci.ed actor (S[i]) and ends before the next occurrence of the same actor (i.e., there are no intervening occurrences of S[i] in the phase).


Although such an overview of code smells does not exist for FOP, many situations such as evolution or increasing maintainability require refactoring.

we argue that we can even adopt code smells for FOP as in traditional refactoring.


Java is at JPL mostly used for ground software.

software that executes on ground-based computers in mission operation centers, for example receiving telemetry from and sending commands to the rovers.


Adding this product to the product line is challenging, since the Managed Account PL has been designed without foreseeing the possibility of having an account without fees.

the deduction of transaction fees is build into the Basic feature.


Dijkstra s method: Upon installing pointer p2 in object B we mark C as reachable.

we prevent the introduction of a pointer that resides in a scanned part of the heap to a part of the heap that has not yet been scanned by the collector.


The results are not fully in line with the results of the 2007 instance of Plat Forms .

pHP had then shown a very high and impressively consistent level of productivity, which is in obvious contrast to the 2011 results.


easy to see that T 2 T 1||0 holds, since P 1 and P 2 r r the leftmost b bits in common.

after the r-th swapping, · have = r it must be that P 2 C2 = C1||0 or C2 r r P 1 = +1||0 or P 2 = r P 1+1||1 holds.


Sugar* supports incremental compilation for both base-language modules and extensions.

sugar* keeps track of module dependencies to initiate recompilation whenever a required module changes.


This analysis suggests that these values and practices make the development process clearer to the software developers, and consequently, they are able to carry out the task of software development in more confidence.

it is illustrated how XP helps reduce part of the cognitive complexity inherent in software development processes by making the development environment more comprehensible to the developers.


AspectJ does it in a way that seems to be very useful for practitioners: it allows the encapsulation of these forms in modules that can be added to or removed from the applications with a compilation switch.

writing a tracing aspect is like writing a different chapter, or section, in a book.


So, participants signi.cantly pay more attention to the instruction when using our assistance system.

6participants experienced the system neither usable nor non-usable.


The general trend that can be observed in these plots is the reduction in block distances as we go from Default to GPART, and also from GPART to GPART+.

in the case of Default, the fraction of block distances that fall in the [1-24] range (recall that the last level cache in Harpertown is 24-way set-associative) is 17%, whereas the corresponding numbers in the cases of GPART and GPART+ are 28.4% and 49.1% in that order.


Yet our design naturally generalises the basic intuition behind dynamic binding, beyond the ordinary case where the execution context is accessed as a stack or a tree: at any point during execution, the dynamic bindings in scope are those in the context, a pre.x of which can be delimited by a control delimiter such as reset, removed by a control operator such as shift, and reinstated by invoking a captured delimited continuation.

we add dynamic binding to the language DC by manipulating the evaluation context, following the footsteps of Cartwright and Felleisen [9].


Thebasicideaoftracing connected componentsofthesilhouettes is that silhouette pixels in the image are neighbors on a silhouette segment if theyhave similar depth.

two neighboring silhouette pixels a and bare depth continuous if cont(a, b) := Idepth(a) - depth(b)I < .n.


Figure 8 shows the number of devices, identified by subdirectories, in which a process may block in each version of FreeBSD.

it shows that in v2, of the 7 devices total, 3 of them sleep, and 2 of those 3 (shown in the list of subdirectofies) sleep without timeout; in v4, of the 69 devices total, 27 of them sleep, and 11 of those sleep without timeout.


copy of the best individual in the next population at each generation) Pop Size: 500 individuals Initialization: ramped half and half with maximum depth equal to 6 Other Parameters: maximum depth for crossover 17, swap mutation probability 0.1, shrink mutation probability 0.1, sub-tree mutation probability 0.1 [14] Maximum 500 Number of generations:  3.2.2 LS2-GP The second version of GP that we present uses the same parameter setting as stdGP, but a different fitness function.

the fitness of a GP individual k is obtained by executing two steps.


2.1 Tree patterns with attribute value comparisons Classic tree patterns in [3] and [23] are a query formalism which is attribute oblivious.

they extract a set of nodes from a tree disregarding the properties of attributes of the tree.


JDEvAn implements a fact extractor based on the Eclipse Java DOM/AST model [28].

it implements an abstract syntax tree (AST) visitor to visit the appropriate source code entities and relations as the Java program is being parsed.


Software-de.ned power meters provide real-time and accurate power estimation of software processes.

our solution automatically learns an application-agnostic power model, which can be used to estimate the power consumption of applications.


D In essence, solutions are all the types which a presolution expands to, plus all the instances of those types.

the set of solutions is closed by instance.


Our research is part of the aforementioned issue.

we define an architecture to support the development of collaborative maps in the SBTVD.


We thank all the colleagues and reviewers who challenged our view on modularity over the years.

we thank Shriram Krishnamurthi and the anonymous FOSD reviewers for their constructive feedback on this submission.


The parameter bypass threshold for the algorithm is relatively high; most data will be stored in the last level cache.

only in special cases all the 16 cache lines in the cache are predicted to have higher temporal locality than the data that are on the way from main memory.


By reusing all forms of proven experience, including software artifacts and knowledge, development time, e.ort, and redundant work can be reduced and, as a consequence, a higher productivity and better quality can be achieved [11].

the reuse of software architectures has also been widely investigated [6].


Theorem 2.3 stated below strengthens the above theorem by making sure that the number of rounds needed in the direct communication is small.

it says that if there is a fast E-error algorithm for computing function f on any network G(G,., .


An important characteristic of flash memory is that flash memory has erase-before-write architectures [11].

when an update on the physical location of flash memory occurs, if it is previously written, the block containing it has to be erased before writing.


An oracle is a mechanism for deciding the verdict of a test-case.

an oracle decides whether the outcome of the testcase has passed or failed.


Industrial languages enable engineers to define objects (program source), but offer little or no help in defining and composing arrows (e.g., deltas).

common languages do not provide AHEAD-like refines declarations to define deltas that update existing class and method declarations and that allow such deltas to be composed.


To ensure the security of a system, if the response from a PDP is NotApplicable or Indeterminate, the request is usually denied.

all of Deny, NotApplicable, and Indeterminate can be treated as opposite decisions of Permit.


(let ([x "outer"]) x)  The interpreter in Figure 1 speci.es such strati.ed namespaces of identi.ers by associating identi.ers with the stage at which they are declared.


Moreover, objects were not considered instantiations of a type but were simply procedure invocations whose activation records were not destroyed upon return and which hung around for questioning afterwards.

it was only by accident that the class provided a facility for programmer-defined data types.


Furthermore, the experiment also indicates that domain knowledge is important, because the estimation results are affected by the false positives detected.

if many false positives are detected overestimates will be the result.


As said before, our focus is on DFT sizes that cannot be computed using exclusively the Cooley-Tukey FFT (5), since for these sizes, close-to-optimal code is already available from vendor libraries, FFTW, or the original SPIRAL.

we focus on DFT sizes that require at least one Rader step (7) that is not unrolled in the recursion.


The initialization time validator, as with Eventrons and Exotasks, performs its checking for reference (or full) immutability in a data sensitive fashion.

it maintains the set F of .eld signatures (static or instance) found to be referenced (for reading orwriting) in any method, and the set O of objects residing on theglobal heap but accessible to Flexotask code.


Next, AL ETHEI A is applied: Each of the candidate classi.ers (ZeroR, OneR, etc) is trained on the n training-set instances,  policy.

the choice of which classi.er to use is context sensitive, and so a general .ltering strategy would not be appropriate.


5.2 Abstract interpretation of the heap The operational semantics de.nes functions to navigate a heap and compute mixin lists of objects.

encl navigates to an enclosing object, WalkH follows a path starting from some object, and Mix computes the mixin list of an object.


Otherwise, the barrier inside Worklist.pushall may hang (since all the threads are not participating in the barrier).

a client GPU program using a Worklist library cannot make arbitrary calls to pushall, but has to maintain discipline across threads.


Acknowledgements The author would like to thank Jim Hook for many conversations about the logical structure of .mega.

the discussion in Section 18 stems from Jim s deep insights.


Without appropriate support,  the bene.ts brought by the expressive power of the mobile agent abstraction are somewhat hampered by the extra work required to the programmer.

the availability of ready-to-use building blocks had a rather perverse effect on the community.


Gridkit is an experimental reflective middleware for grid computing, which supports adaptive grid and pervasive applications by dynamically combining middleware behaviour (composed as component frameworks) based on application requirements and changing environmental context.

we illustrate how the Genie toolkit improves the development of the Gridkit middleware through the modelling and automated generation of middleware policies; that remove the complexity of handling large number of adaptive policies.


As a first step, we aim to demonstrate that the modules that rewrite the Ada program are correct.


RELATED WORK The MPI speci.cation offers considerable leeway to implementers about when to force the waits in an epoch.

an access epoch opening synchronization call does not have to block if the corresponding exposure epoch is not opened yet.


If we imagine that there is an oracle function traverse that generates the sequence of cells accessed while processing a particular particle, we can rewrite the accelerated BH code as shown in Figure 1.

we can view the algorithm as a simple, doubly-nested loop.


about 100.000 JUnit test cases are reported by the Merobase search engine), expanding on the idea of discrepancydriven testing one step ahead is certainly interesting.

even if we do not want to apply the approach to a component, we can still extract the knowledge that is stored within the numerous test cases available for similar components.


A key goal of our approach has been to reduce the added bur- den as much as possible.

we wish to simplify the process of constructing patches, and we wish cleanly to separate software development fi'om patch development.


When the method returns, however, no permission to that element is returned to the caller, because we have created a unique .eld reference to that element in the FullBuffer state, and returning a permission to the caller would violate the uniqueness invariant.

the caller may still have a reference, but it does not have permission to use it.


An instance of the k-median clustering game with integral edge distances has a weak Nash equilibrium if and only if it has a weak Nash equilibrium con.guration in which centroids are placed in half integral locations on edges.

in order to guarantee the existence of Nash equilibrium, we add a rule penalizing a node whose move to a cluster C changes the location of the centroid of C. the cost of a node u performing an improvement move will consist of two values: The distance from the updated centroid of the new cluster, d(u, c(C+u)).


RELATED WORK Systems in digital rights management (DRM) support protecting digital products.

they facilitate the speci.cation of preconditions like users or circumstances to access these products [12].


Nevertheless, there are issues with traits as a library, especially with the design of traits.js.

binding the this pseudovariable of trait methods to the trait instance, to prevent this from being set by callers, requires a bound method wrapper per method per instance.


Complex storage-data-path optimizations: Secure deletion needs to retrofit legacy asynchronous optimizations.

storage requests may be reordered, concatenated, split, consolidated (applying one update instead of many to the same location), cancelled, or buffered while in transit.


Results of instruc- tions executed out-of-order are committed to the architec- tural state in program order.

although in- structions within the window execute out-of-order, the win- dow entries are managed as a FIFO where instructions enter and depart in program order.


The performance gains of our algorithms are evident even on graphs with millions of vertices.

our idempotent LIFO algorithm outperforms the existing algorithms in nearly all cases, sometimes by a factor of 3 and gains of 40% are common.


take a measurement)  Configuration data enable to provide XML-based input to a component in Jazz  Events - allows components on the server to register to server based events  While RTC provides the necessary building blocks and plumbing to define and control its operational model, some extensions would be required to provide a full governance enactment solution.

rTC doesn't support RACI roles and responsibilities and consequently can t enforce or track them in the team interaction.


Each place instance (each color) in the place instance set IP of the colored Petri net N corresponds to a place of the Petri net N*.

the colored tokens in the colored Petri net are now distinguished by different places in its corresponding Petri net.


The main contribution of this paper is that it shows a way to design and implement a source code browser which combines the advantages of a hierarchical browser with the flexibility of a query tool.

our design succeeds in combining the following advantages into a single tool: Like any hierarchical browser, our tool provides an ex- plicit representation of the exploration paths followed by the developer.


However, this is only a practical solution for few parts of most applications (e.g., framework-generated code), or most parts of few applications (e.g., SCADE-generated code).

it does not seem to be a solution for applications involving complex data structures and data processing, such as a Flight Management System, for instance.


It would be convenient if instead the compiler would perform a check to see if a mapping is actually necessary.

the compiler could simply check if a type has the required types and operations.


Let ExecT ,X denote the set of all executions over threads T and entities X .

a execution is a lock-valid sequence of actions such that its projection to any thread T is a word divided into a sequence of transactions, where each transaction begins with T:., is followed by a set of reads and writes, and ends with T:..


These properties are important in practice since they allow selective recompilation.

we show that they are guaranteed when the type system has principal typings and provides sound and complete entailment relation between type environments.


In general perspective, our method of dividing the heap into sub-heaps of .xed size segment shares the same motivation with these previous works.

obtaining a bit pointer from an object address mentioned in Subsection 2.5 can be regarded as an instance of encoding object meta-data in BiBoP.


This, in turn, enables adequate stressing of the servers in order to determine their individual limits.

the developed application is able to perform more parallel requests than a concentrator or MDS component (running on a physical machine) can process.


In this case, we demonstrate making GSM measurements available on a laptop, thus achieving virtually ubiquitous location sensing of the mobile phone platform [12] on a device with considerable computational power and GUI capabilities.

we extended Place Lab to provide a GSM-over-Bluetooth spotter.


Most aspect-based tools execute advice bodies upon intercepted join points in a synchronous manner.

each program thread synchronously invokes advice while executing woven code.


As Ganesh has explained, the same action populating data when performed by two different agents (system and user), follows mutually exclusive paths.

the system performs different functions depending on whether the user or system instigates the action (populates data).


If the controller resides on the telephone, then the telephone controls the views possible and must have some knowledge of the input/output devices.

placing the controller on the telephone forces the design of the software toward the first extreme rather than the second.


In what follows we demonstrate the use of this criterion by analyzing Extreme Programming (XP) which is the most prevalent agile software development method.

we explain how the XP values of feedback and communication, as well as several of the XP practices, support gradual construction of knowledge related to the development of software systems.


The proposed compiler-directed reliability approach super-poses on top of all optimization performed by naïve compiler and does not incur any performance penalty, since it only reallocates the VLIW slots (slips the scheduled instructions from one slot to another) within the same scheduling and order determined by the naïve compiler.

this dynamic binary optimizer guarantees the iso-throughput execution of the healthy kernel.


(a) where a is the address of n. This is a collapsing injection [26]whichmeans that everydifferent term is represented bya unique sub-DAG.

when .already contains a node equivalent to n, . '


2.1 Containment-Based Filtering The property of subscription containment (also called covering) has long been used for content-based .ltering (e.g., [3, 4, 10, 11, 13, 19]).

essentially, we say that a subscription s contains or covers another subscription s 0, denoted by s w s 0 , if any event that matches s 0 also matches s. s is 0 more general than s .


The statistical significance of 0.05 means that we accept 5% chance of rejecting the hypothesis about the equality of the fault-proneness of new and modified code when the hypothesis is actually correct.

selecting 5% significance level means that we are at least 95% confident that the hypothesis regarding the equality of fault-proneness of new and modified code is false before we reject it.


It is reasonable to assume that the utility is increasing in the download rates.

when the download rates are higher, the user gets the .le sooner and is able to download more .les in a .xed interval of time.


This tagging is necessary in order to implement the case construct.

the representation of any value of type t1 + t2 must carry enough information to determine whether it was created with inj1 or inj2 and recover a representation of the injected value.


If the class D has superclasses which themselves contain associated types, each of these associated types needs to appear as an argument to the dictionary D, too.

similar to how the dictionaries of superclasses must be embedded in a class s own dictionary, the associated types of superclasses need to also be embedded.


Thanks to the bootstrapping, large parts of REPLi, namely REPLi step, exist in the form of veri.ed bytecode.

much of the effort involved in constructing the x86-64 implementation of REPLi boils down to producing an implementation of the bytecode that the compiler targets.


The function removeRedundantEvents() eliminates events at the beginning of these lists when their VCs are found to be smaller than or equal to the VCs of all the cuts in the current level.

to process an event, a good implementation of the algorithm in Figure 4 would take time O(|Threads|).


On a multicore chip with intricately shared hardware resources, however, chipwide environmental factors also affect per-core power accounting.

the maintenance of shared multicore resources (including clocking circuitry, voltage regulators, and other uncore units [21]) consumes some active power as long as one core is running, which does not change proportionally with core-level event rates.


The rule (25) checks that the sealing construction (E : S) is type-correct.

the third premise is for ensuring that the module expression E inhabits the signature S; it checks that the lazy signature T1 of E1 is a subtype of Subst(T1,S).


Rather than perform substitutions to generate a new fragment consisting only of de.nitions (which would be closer to the semantics of the actual C preprocessor), our semantics constructs an accumulator A that contains both the core language de.nitions and other information needed to enforce CMOD s rules.

the preprocessor is de.ned as a relation among states of the form (h;A;.


A further filtering step is to determine the components that exist in the bug hunk but not in the fix hunk.

code characteristics that are common between the bug hunk and the fix hunk are not saved, since they are unchanged.


HiLPR: Pretty Pictures for Pretty Complicated (Parallel) Patterns Donna Kaminskyj LongUniversity of Victoria dkj@cs.uvic.ca Nigel HorspoolUniversity of Victoria nigelh@cs.uvic.ca ABSTRACT Users of parallel patterns need to carefully consider many subtle aspects of software design.

implicit relationships with hardware realities coupled with aggressive strategies for optimization are daunting in this domain.


Since wedo not use an instrument to measure the absolutebattery consumption, we rely on the speci.cation givenin[16] and[10] toestimatethetotalpower consumed.

theWiFiinterface consumes1120 mWin theCAM and72 mW in the PSM; the Bluetooth interface consumes 120 mW in the active mode, and 25 mW in the idle mode.


Second, many systems may be insensitive to modest reductions in peak agreement throughput because of limited demand or other bottlenecks.

many services peak demands are far under the best case throughput o.ered by existing BFT replication protocols.


RELATED WORKS Traditional tuple spaces The issue we faced while devising the presented model can .rst of all be framed as the problem of .nding the proper coordination model for enabling and ruling interactions in emerging pervasive computing scenarios, which are intrinsically distributed, mobile, dynamic, and call for self-organisation.

our idea of mediating agent interactions by a shared space has been proposed by the pioneer work in the Linda [7] tuple space model, in which coordination is achieved by coordinated processes inserting tuples (records of primitive values) in the global shared space and retrieving (and removing) them based on templates (records possibly including wildcards).


3.3 IP Protocol The currently implemented IP support is the minimal to have a working end point in the communication.

the stack does not support forwarding (although it would not be a dif.cult feature to be added).


Future work includes further empirical studies in understanding the impact of open innovation on requirements engineering processes, tools and techniques.

it would be interesting to apply some of the grounded theory principles to further analyze the qualitative material from the interviews.


As a result, only one path is taken through the second conditional, and so the value of flag is known.

the correlation between the property state and flag is preserved.


(2) The safety condition requires that the state trajectory of each cooperative agent is contained in the interval formed by the initial states of cooperative agents and that the limit exists, despite the in.uence of the adversaries.

if we de.ne the interval I0 =[minxi(0), max xj (0)], i.Vc j.Vc then the safety condition requires that given q = F adversaries, xj (t) .I0, .t .


This theorem is a straightforward corollary of a standard type preservation lemma.

preservation tells us that the wf judgment is preserved by evaluation.


This may involve introducing new ways of interaction so that a programmer can select the clones to be compared, and new ways of displaying the differences of one clone with respect to any other clone within the clone group.

a side-by-side view like the Eclipse Compare Editor employs would be highly desirable [19].


Unfortunately, a detailed cost-bene.t analysis of each dynamic predication case requires the collection of per-branch pro.ling data obtained by emulating the behavior of a DMP processor.

determining the probability of each misprediction case, the number of dynamically predicated iterations, and the number of extra iterations in the late-exit case requires either pro.ling on a DMP processor (with specialized hardware support for pro.ling) or emulating a DMP processor s behavior in the pro.ler.


It is therefore of considerable interest to understand if the Johnson bound is tight, namely whether one can improve the bound and show that Hamming balls of radius even larger than the Johnson radius always have a small number of codewords.

is the Johnson radius the best possible bound on list decoding radius in terms of the minimum distance?


Although it is important to illustrate the potential bene.ts of the tool to the target users, the tool will typically have limitations, and these limitations must be clearly communicated to the target users and how the target users can deal with such limitations.

the target users should be informed and trained on helping the tool to deal with those faced limitations in a cooperative way, as advocated in the cooperative testing methodology [72].


The DES Clusters working group has set out to characterize the projection e.ects measured in some optical cluster .nders.

for the redMaPPer cluster .nder [32], we have started to measure how a large target halo can be a.ected by nearby halos.


The results presented in Figure 7 also reveal that it is not a good idea from the energy perspective to work always with the maximum number of processors available.

for the best energy results, the number of processors should be changed adaptively.


It is embedded into the Scheme programming language, allowing arbitrary computations to be used in transforming input programs.

program transformations are implementedas Scheme programs,with subroutinesavailableto simplify the de.nition of equations over the program s control .ow graph; those equations are then solved by a .xpoint algorithm.


Since our cluster has fast communication, we did not obtain data for the case of communications with relatively long latencies.

for F(ll), speedup with pre- fetching was 0.51 of optimal; whereas without pre-fetching, speedup was 0.54.


Figure 4 suggests that maintaining a large number of idle AppServs on a machine causesdiskthrashing.

appServsdo notseem idle to the operating system despite the fact that they are not processing any user requests.


If the developer changes the .eld name, MyLogicalAddress, the aspect will not compile, and the aspect must be rewritten.


This is a very interesting situation because, based on the proposed analysis, we show that before selecting a model as best we should take into account uncertainty, as well.

our analysis says that NASA should use LogLinMode if they care about uncertainty, while NASA should use LogLin if they care about accuracy.


The main idea of the McErlang tool is to replace the part of the ERTS runtime system that implements process concurrency with a new runtime system suitable for model checking.

the model checker replaces basic Erlang operations such as process spawning, communication and process linking, and corresponding data structures for recording processes, with its own data structures for recording processes and its own code for interacting with processes.


The software architecture should be able to represent all the activities of the model.

the design core has to support any surgical procedure, taking into account that, although these procedures can present many common situations, each procedure is specific and totally dependent on the exact moment of the whole surgery.


of Information & Software Engineering George Mason University Fairfax, VA 22030 +1 703 9931640  dwijesek@gmu.edu Mark Hartong * Federal Railroad Administration 1120 Vermont Ave Washington, DC 20590 +1 202 4936000  mark.hartong@fra.dot.gov ABSTRACT Misuse cases are a way of modeling negative requirements, that is, behaviors that should not occur in a system.

they can be used to model attacks on a system as well as the security mechanisms needed to avoid them.


the y-axis of Figure 2 records the ratio of the faults that are effectively localized in the score ranges recorded by the x-axis.


requires prior specific permission and/or a fee.

pODC 2000 Portland Oregon Copyright ACM 2000 1-58113-183-6/00/07...$5.00 ters used by either long-lived adaptive renaming or collect must be a function of n. for any constant d there is a large enough nd such that every long-lived adap- tive read/write implementation of collect (and renaming) with nd processes must use at least d MWMR registers.


4.2 Design Tools As shown in Figure 5, we used the Eclipse Modeling Frame work (EMF) to support such a process and to create our tool suite design editors: (1) we create the model s Ecore .le (MM) and then (2) we use the code generation techniques of EMF as a transformation engine to build DSLs editors.

we derived the EMF Generator Model (genmodel) .le based on the model s Ecore .le to make use of the code generation techniques of EMF.


More speci.cally, a conditional assignment is created to determine whether a variable vi contributes to the unreachability and should have its behavior changed or not.

when the select line Vi s is 0 (note that we use uppercase names for symbolic traces and lowercase for variables), the symbolic trace returned by symbolic simulation uses the original trace Vi, which means symbolic conditions will not be changed by vi.variable vi does not contribute to the unreachability and has its behavior unchanged.


Note that, there is no ordering between Si and Sj in the candidate group.

the ordering of the statements inside each group is ignored at this phase.


If some relationship exists among members inside a group e.g., in Graph we have that instances of member Edge should hold a reference to an instance of member Node then we want it to be preserved through extension.

the same relation must automatically hold in class CWGraph as well.


2.2 Recovering Isolation A key insight of our approach is that converting an isolated reference to writable does not require permanently surrendering the aliasing information.

if the input type context for an expression contains only isolated and immutable objects, then if the output context contains a single writable reference, we can convert that reference back to isolated.


Over the architecture-recovery iterations, the participants generally moved to more encompassing architectural models.

they started with a small proportion of their system and added more component nodes, reflecting more of the underlying system, as they iterated through the process.


GOAL STATEMENT The purpose of this research is to design a programming language, named G, that improves on the state of the art in language support for generic programming.

the focus will be on improving modularity.


This is necessary because without some idea about how these ideas are embedded in the problems of sending bit messages it is difficult to understand whether or not the ideas are relevant to software engineering.

we discuss in detail the notion of excess entropy since several software researchers have suggested that excess entropy can be measured on system designs and that designs with low excess entropy are to be preferred to those with higher excess entropy.


In this work, we analyze theproblem of scheduling a workload composed by hard, soft and non real-time tasks on a multiprocessor platform.

we will improve and adapt to multiprocessor systems apreviouslyproposed tech * This work has been partially supported by the IRMOS (FP7/2008/ICT/214777) and ACTORS (FP7/2008/ICT/216586) projects.


In order to ensure reliable simulation results, several measurements were conducted.


Introduction The study of the theoretical foundations of memory management has not been very extensive.

not much is known about the theoretical potential and limitations of memory management functionalities.


On the other hand, a sampling rate in SO that can maintain the same overhead is as effective as a sampling rate of 9% in Pacer.

in order for Pacer to detect the same number of races as that of SO, it needs to sample at 9%.


As can be expected, the BDD sizes in general grow with the complexity of the benchmark.

the sizes of the interprocedural .ow information do dominate.


Claim 2.5 If algorithm A .nishes in time TA =1.l.. then j r> 1.l.. - 8TA/(1.l.).

the number of rounds Aliceand Bobneed to simulate A is 8TA/(1.l.)


Participants in all five application areas reported good levels of usability for all three tools, with the findings showing a mean usability score difference that lies predominantly in the difficulty of the VERITAS tools as defined by their use, content and complexity.

t1 and T3 were reported to be quite easy to use across all five targeted domains, while T2 was rated as slightly more difficult.


To investigate the e.ect of System, we applied the Bonferroni correction [8], [9].

we used two tests to analyze whether the e.ect of System is statistically signi.cant.


In our experience, customers are reluctant to rewrite their builds to attain speedups.

de Jonge s technique does not apply to the builds discussed in Section 5.


This enables Star to reify the context of an asynchronous continuation.

when a synchronizing computation needs to block, it returns immediately instead of blocking the underlying JVM thread.


This work is a continuation of our previous work [1] where we have presented and discussed an inline approach to include SOAP structure information in the SOAP message and to validate the information by the receiver of the message.

we can attach SOAP Account information into the  header in the WS-Security standard [2].


These check rules encapsulate all of the above concerns, and adhere to the following idiom: check: context -> (target, $[error message]) where assumption where require(constraint) The rule checks whether for the given context (the term under scrutiny) the constraint is satis.ed, given that the assumption holds.

the require(s) operator is sugar de.ned as follows: require(s) = not(s) the check rule succeeds (producing the speci.ed error message), if the assumption succeeds but the constraint fails.


Together, these de.ne a set of relations (one for each class) either as the solution of a set of (mutually recursive) equations or, equivalently, as a proof system generated from the instance declarations.

a key insight here is that this set of relations can be interpreted, viewed, and manipulated as a relational database.this means that we can leverage interesting results and tools from database theory (such as those in Appendix A) to help us specify and use multiple parameter type classes more effectively.


All suf.xes share the output variables of the pre.x and can use them as input variables for suf.x calls.

all suf.xes share the CUT instance created in the pre.x.


We also added a weight parameter to formalize the intuitive sentiment that one of the measures is considered more important than the other.

let the rank be an integer in the range [1,N] where 1 is the best item and N is the worst .


CONCLUSIONS AND FUTURE WORK In this paper, we present our experiences in codifying and enforcing different types of software constraints in production software.

we present a set of primitive aspect rules, and illustrate their use within the context of a software project largely used within SIEMENS.


Using these activities, Scribe converts nondeterministic asynchronous interactions that are di.cult to record and replay e.ciently without additional hardware support into synchronous interactions that can be recorded in software with low overhead.

the timing of an application execution may be perturbed in a manner that makes it easier to record e.ciently without sacri.cing correctness or performance.


As for interrupts, because of their asynchronous nature, they are always handled without any rollback.

processor execu- Reversible I I I I Conventional ROB I ] J J i I i i :11 Head (oldest) Reversible Irreversible ...."Y-:-I I I I I I I I I I I I _-:_-12 Cherry ROB ...... t ......


In a series of papers Olivier Danvy and his co-authors have used defunctionalization and other techniques to establish correspondences between interpreters and abstract machines, among other things [1 4, 8, 9, 11, 14].

one key step of their correspondence is to defunctionalize continuations to get a .rst order representation.


We use K-anonymity parameter of ers, each ShardStorer can observe only a small fraction (i.e., 1 K=100, and normalize the results relative to CF.BestSeller ( )) of the stored shards and as depicted via P3.Blind=ON  N2 as the lower-bound, and CF.AllPairNNS as the upper-bound.

(A=ShardStorer), this results in the success rate becoming if the clustering metric of an approach is x,zero (thereby not visible in the logscale plot).


4.3 Creating Disjoint Data Bullet s ability to deliver high bandwidth levels to nodes depends on its disjoint transmission strategy.

when bandwidth to a child is limited, Bullet attempts to send the correct portions of data so that recovery of the lost data is facilitated.


Moreover, it is equality that is of course at the very basis of our use of equational reasoning when proving theorems about abstract datatypes.

to have a stable basis for equational reasoning, one requires an abstract datatype s notion of equality to be compatible with its operations.


Conclusions We have proposed a combination of techniques aimed at improving analysis ef.ciency in type inference and veri.cation for modular Prolog programs.

we have presented a type analysis which optionally reduces the accuracy of inferred types during the analysis process by using only the types de.ned by the user or present in the libraries.


Even program, We consider two types of statements: (1) assignment statements are of the form x := e where x is a variable and e is a side-effect though these examples are simple, they illustrate common patterns exhibited in large programs (see Section 5): some parts of large programs are more amenable to may analysis while other parts are more amenable to must analysis.

for functions with many paths due to nested calls, conditionals and loops, but simple postconditions established in a post-dominator of all paths (such as the last statement before return), not-may summaries can be easy to compute.


To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.

aCM Multimedia 2000 Los Angeles CA USA Copyright ACM 2000 1-58113-198-4/00/10...$5.00 multimedia file systems must have high I/O bandwidth to support the number of concurrent clients isochronously[l].


In this regard, MAS for WSNs should attempt to achieve a balance between the degree of functionality incorporated into the actual code interpreter, and the one provided to the agents in accordance to the intended WSN application.

we argue that it makes little sense to provide agents in WSNs with excessive control of the system s functionalities if the tasks to be performed in the WSN are consistently repetitive.


After copying, all subsequent accesses to the variable, including both read and write accesses, refer to the variable s image in the private space.

the thread can manipulate the value of the variable in isolation, free of contention with other threads.


A SHOCK message sent this way is embedded into a standard email message that can be sent to any user.

the XML is hidden as a comment tag in the HTML message.


G.  4.4 Completeness After formalizing the individual refactorings, the question arises whether, in combination, the refactorings are complete.

we want to show that every possible program (given the syntax and sanity rules of LJAR) that uses any combination of feature modules and/or annotations can be refactored into a pure virtual separation (with annotations, without feature modules) and also into a pure physical separation (with feature modules, without annotations).


One of them is the ability to check the connection and re-instantiate it, if needed; indeed the library avoids some protocol errors such as the brutal closure connection , which occurs when a login is not performed within a timeout after establishing the connection or when, due to a long period of inactivity, the server unilaterally 7 It can assume the value ok , not or bad .

8 for the fetch command, it is a list of proplists .


Thus the refactorings we are looking for here split functionality from a class into a newly created subclass, or merge a subclass with one or more of its subclasses.

we look for the creation or removal of a subclass, together with a number of pull-ups or push-downs of methods and attributes.


Our argument is that we cannot completely exclude the possibility of P1 or P2 being the error.

even though the path is infeasible in the faulty program, it may be feasible in the correct version of the program.


In the long term, we plan to scale our approach from C2 style architectures to generic architectures implemented through component-based and middleware technology.

we would like to expose the Siemens C.N.X.


Strong links Next, we introduce strong links.

again, the type e.f is a precise type for a name: it is more precise than e.f - and (therefore) more precise than Name f. If x has type e.f, -then x is guaranteed to be fresh for the world e. a strong link represents the introduction of a binding for a fresh name, and (in contrast with a weak link) cannot possibly shadow an earlier binding.


To address RQ1, we .rst use an automated rule to determine whether the discovered patterns represent high-impact driver behaviors.

we determine that a contrast pattern is of high impact if at least one of its executions in trace streams exceeds Tslow .


Furthermore, semantic links speci.ed among ADL1 and A0 and among the MM and A0 enable the possibility to inherit the graphical annotations (and hence the graphical representations) of the A0 linked elements.

a0 substitutes ADL1 or MM if they do not have annotated Ecore metamodels.


To validate the above step of .ltering sentences based on signal words, we examined a randomly selected contract.3 We identi.ed 66 sentences describing norms in this contract, of which 63 sentences included signal words.

signal words yield a coverage of 95% on this contract.


a data mining algorithm and has no physical counterpart.

figure 2: The DBSA system architecture a logical device is a device that exists only as a software component within the framework, performing a processing task.


The idea is to mark pages mapped to GPU as invalid, and to modify the page fault handler so that it will interact with our runtime and automatically call the proper function whenever a page fault is detected.

handling will be performed within the runtime if the page fault involves a page mapped to GPU, whereas the page fault handler will resume its normal operation otherwise.


Can such agents reason on their beliefs and make deductions?

does an agent's memory merely consist of a set of assertions or of its deductive closure?


However, upon reestablishing a broken connection, users typically expect the task to resume.

they expect the task to be performed in the presence of a volatile connection.


As discussed above, these are either (1) objects read or written, (2) static variables read or written, or (3) input parameters or return values, depending on the program point.

dIDUCE associates with each program point a set of expressions, each of which is a function of the object or variable being accessed.


In this paper, we focus on a sub-problem of product derivation: instead of deriving a complete software product, we aim to derive the use cases of a software product, which are a kind of software asset at the requirement stage and play an important role in negotiating application requirements with customers and generating test cases for testing applications [2][11][14].

we focus on automated use case derivation, i.e.


INTRODUCTION Given a stochastic process X(t) with X(0)=0, the first passage time (FPT) T to the point x=a>0 is specified with T = inf{t : X (t) = a}.

(1) FPT is the time when the stochastic process first crosses a threshold a.


We classify the relationship between an entity E and the AOI of another entity E' into the following two types.

enclosing: AOI(E') encloses entity E. AOI(E') covers the minimum distinguishable unit in which entity E is located (i.e., entity E s level-K residing cell).


Furthermore, we want to apply this approach to controlstate ASMs derived from machine-programs and programs in higher-order programming languages, respectively, induced by the language semantics.

this becomes interesting for machine languages, because their control-state ASMs are likely to be irreducible due to jump instructions.


In our case, the .x is carried out by the fixTail() method, which is aware of the existence of the slow path.

it checks whether the 47 void help if needed() { 48 HelpRecord rec = helpRecords[TID]; 49 if (rec.nextCheck-- == 0) { 50 OpDesc desc = state.get(rec.curTid); 51 if (desc.pending && desc.phase == rec.lastPhase) { 52 if (desc.enqueue) help enq(rec.curTid, rec.lastPhase); 53 else help deq(rec.curTid, rec.lastPhase); 54 } 55 rec.reset(); 56 } 57 } Figure5.


We assume that, the front-end stages in the pipeline, up to the rename stage, delivers eight instructions/microoperations per cycle at a sustained rate.

our simulations ignore all the arte- facts associated with irregular instruction fetch bandwidth.


These models are useful for API compliance.

we can verify correct API usage with respect to threads (Section 2) and .nd API usage bugs (Section 4).


While P-state transitions on current processors are faster than a few years ago, they are still slow compared to the length of processor cycles.

the processor may stop completely for a short period of time decreasing performance while wasting energy.


The batchactive model requires rethinking metrics and algorithms.

when the system is aware of speculative tasks, the traditional response time metric should be re.ned.


We note here that the above Exact BVC algorithm remains correct if the non-faulty processes identically choose any point in G(S) as the decision vector.

as seen in the proof of Lemma 1, all the Tverberg points are contained in G(S), therefore, one of the Tverberg points for multiset S may be chosen as the decision vector.


The scheduler is leveraged to distribute transactions across the cluster in such a way that con.ict waits and aborts are optimized.

the scheduler-based approach is useful for applications where several threads are expected to run at each node.


If class C extends D1 and D2 and the unspecialized method m is de.ned or inherited by both D1 and D2 then C must also de.ne the unspecialized method m. Also, if method m with specializer B is de.ned or inherited by both D1 and D2, then C must also de.ne either (1) m with specializer B., where B is a subclass of B., or (2) an unspecialized method m. Additionally, the calculus assumes an elaboration phase that translates method names to quali.ed names, using the name of the class where the method was .rst de.ned; consequently, methods have a unique point of introduction.

in the calculus, two classes only share a method name if it exists in a common superclass or common required class.


(f )= .0 10 1-fmin (4) where the exponent d (> 0) is a constant, indicating the sensitivity of fault rates to voltage scaling, while .0 is the average fault rate corresponding to the maximum frequency fmax = 1 (and supply voltage Vmax).

reducing the supply voltage and frequency for energy savings results in exponentially increased fault rates.


Roles from multiple patterns can crosscut each other with respect to classes and/or methods.

2 classes that pattern A sees as part of 1 role, pattern B may see as in more than 1 role, and vice versa.


INTEROP arises when PD and CD do not directly align, that is to say: the way consumers characterize needed data (according to CD) does not directly correspond to the way producers characterize the counterpart available data (according to PD.)

valuable data needed by consumers is available from the producers but it is not evident how to use them.


Zyzzyva s protocol, however, remains relatively e.cient in such scenarios.

zyzzyva s cryptographic overhead increases from2+ 3fb +1 to3+ 5fb +1 operationsper batch.


A term is .-linear if for each of its subterms of the form t.s, where t and s may be standard or non-standard terms, it is true that t or s is ground.

if a term t contains a subterm of the form t1 .


Xen uses a split driver model for both network and disk I/O.

for each device, a guest VM has a virtual device driver called frontend, and the dom0 has a corresponding virtual device driver called backend; these two communicate by memory copy.


Other systems: Partial execution is also used at web servers to improve overload behavior [1].

web server returns full contents at regular load and returns degraded-quality contents during overloading.


The third case study is motivated by a programming framework for sensor networks [18] that offers so-called tell actions,where a node may tell one or more other nodes to execute a (potentially synchronous) command and the tell action itself waits until all nodes have .nished executing the command.

a tell action basically is a synchronous one-to-many remote procedure call (RPC).


Being a model of the software process available, the GQM plan is defined as usual, but with reference to the process model, as described in Figure 2.

the process model can be used: In the Prestudy and Identification of GQM goals the process model is useful to characterize the context and to establish the goals and evaluate their importance.


CONCLUSIONS This paper presents a framework for efficient compilation of applications written in a high-level language to a reconfigurable computing architecture.

the compiler aims at extracting the data parallelism at coarse- and fine-grained levels in a given application, and then produces an execution schedule that explicitly reflects a SIMD execution model.