In fact, the need to link specific intentional elements types to specific elements of the ADD metamodel led to the exclusion of the enumerator type and the inclusion of metaclasses to represent the intentional elements.

as can be seen in Figure 1 (see red elements) the intentional element types are represented by the Goal, Softgoal, Task and Resource metaclasses.


Of course, since naming, interface, and conversation based approaches always produce all 8 as candidates, these competing approaches had an average candidate set size of 8.

in this case study, OMSD improved precision by reducing candidate set size 73% on average.


Although at some instant, the RI for each tree deviates from the ideal curve,  GrandChallenge Slashdot Rally SIGCOMM2002 SOSP2003 the resources each tree have remain close to perfect balancing for the most of the duration.

we conclude that our heuristics maintain trees in reasonable balance in resourcescarce environments.


However, dramatically increased .le system access, data storage and transfer requirements at the fringes of an analysis tree [9] would quickly eclipse these bene.ts for large scale runs that use up to hundreds of thousands of MPI tasks.

we designed an adaptive pre.x tree re.nement method that addresses these scalability challenges.


However, the Forest compiler generates load and manifest functions for each named type in a description.

updates may be made at any granularity for which there is a named type, which is typically at the level of individual .les.


SYCMC is built on top of an extended version of NUSMV[14] that integrates the MathSAT[32] SMT solver and provides advanced algorithms for performing predicate abstraction by combining BDDs and SMT formulas [15], [16].

the new ESST model-checking algorithmis implemented withinSYCMC.InSYCMCas well as in ESST each time we expand an ART (ARF) node we perform the check to verify whether the newly generated node iscoveredbyanotherART(ARF) node.itis fundamental to perform this check as ef.ciently as possible.


When a concurrent workload runs on a VM, we observe that: (1) the number of spinlocks in a .xed time interval decreases along with the VCPU online rate; (2) the majority of spinlocks have waiting time less than 215 CPU cycles; (3) the percentage of waits taking more than 225 CPU cycles increases quickly as the VCPU online rate decreases; (4) the long waits usually occur in some neighboring spinlocks.

virtualization has a severe performance impact on concurrent applications in the virtualized system.


4 Performance The goal of this work is not to develop a high-performance implementation, but rather a design that facilitates high-performance, multiprotocol communication.

these tests serve primarily to validate the design, rather than being ends in themselves.


4.2 Seamless Switching of Responsible Nodes for Subscription In the metho d where the global game state is maintained separately in sub spaces, each player cannot receive events  Figure 3: Sub Spaces and Player s View occurred in unsubscrib ed sub spaces.

if each player subscrib es to a resp onsible node after a new sub space comes into his/her view, the player may miss receiving events which occurred in the new sub space just before the space comes into his/her view.


Algorithm: RSB(T) = {T}; for each optimization O applied to T for each source fragment S referenced in applying O to T RSB(T) = RSB(T) U {O}; end end For the translated code block T, if every element in RSB (T) is unchanged, reusing T would be 100% correct, even if there are changes in other parts of the source binaries in the same module.

since RSB (T) is the minimum set of source binaries that determine the semantics of T, comparing any real subset of the Referred Source Binaries cannot ensure the 100% correctness of reusing T. for each translated code block, saving and comparing its RSB is the most efficient way to verify its reusability.


The integration concept provoked the idea that the integration can be performed in more than one way.

we set three subsequent research questions (RQ1, RQ2 and RQ3), and developed three integration approaches that address these research questions.


Here we list some of the .elds in which Ada is used to a signi.cant degree[4]: 1) Air Tra.c Management System 2) Commercial Aviation 3) Railway Transportation 4) Commercial Rockets 5) Commercial Imaging Space Vehicles 6) Communication and Navigational Satellites and Receivers 7) Scienti.c Space Vehicles 8) Banking and Financial Systems 9) Information Systems 10) Military Applications In all these .elds, the software systems are safety-critical and running online for long term, a tiny error may cause great losses.

we need more ways to increase the reliability of these systems.


Computer is based on mathematics, corresponding program should be converted into binary logical relationship to control computer to perform a specific task.

programming work can not be well finished without rich mathematics knowledge.


Interestingly, domain experts say that assessment is indeed usually performed sequentially by a doctor and a nurse.

the greater detail in the definition shown in Figure 2 seems to support the possibility of scheduling that could reduce waiting time in a real-world ED.


It may be quite appropriate for a superclass to make a particular method re-implementable and overridable, and to allow one of its subclasses to override it while another re-implements it.

we see that for each method there are three independent access rights: o, r and c, and so there are potentially 23 = 8 di.erent sets of rights.


We considered making this an error as in Vault [11], but found that exception handlers and shared unique pointers (described below) generated too many false alarms.

we settle for a warning and rely upon the GC as a safety net.


Thus, consider the case where r = c. By Lemma 5, all processes that set v in round r = c set v to the same value, say v ' .Process p delivers v = m ' ;thus, v ' = m ' .

any process that sets v in round r sets v = m ' .


We want these new names to be fresh, i.e., nowhere else used and private to 'A.

a and 'A are isomorphic but distinct objects.


Several other research projects also explored the distributed object notion, notably Argus at MIT[71] and Clouds at GeorgiaTech[2].Argus, asa languagedesign,was essen tially complete before the Emerald project started.

argus was contemporary with Eden rather than with Emerald, and indeed shared with Eden the idea that there were two kinds of objects large objects that were remotely accessible (and, in the case of Argus, transactional), and small local objects (essentially, CLU objects).


Filters must implement the interface RegionSummaryFilter, whose only method veri.es whether a region summary is accepted or rejected by the .lter.

for example, a .lter that accepts only region summaries with non-zero message passing time can be encoded as follows: class MyFilter implements RegionSummaryFilter { public boolean accept(RegionSummary rs) { return rs.getCommunicationTime() != 0; } } in order to implement an iterator object that iterates over all region summaries with non-zero message passing time, we can use the following code: iterator = experiment.regionSummaryIterator(new MyFilter());  Figure 4.


Note that for the UDP implementation the set of parameters (interval, readPort and writePort) are different.

each implementation of the aspect is independent.


the node set C belongs to a strongly connected component.


Figure 4: Interposition of JDOSecure between an Application and a JDO Implementation As pictured in Figure 4, JDOSecure is intended to be interposed between an application and a JDO implementation.

the architecture of the application domain could consist of user-interface, application, JDOSecure, JDO implementation and a JDO resource to store the persistent objects of the application domain.


Greater the distance of valid scope of data item from the user s current position lower is the chance that client will  enter in the valid scope area of that data item in near future.

it is better to eject the farthest data item value when replacement takes place.


In this paper 23 benchmarks and 58 sample workloads were used and we evaluated thread numbers between 1 and 8.

a total of 23 × 58 × 8 = 10672 experimentswere required tocollectthetrainingdata.


On allocation, the resultant pointer always points to a base address.


The metamodel provides the fundamental concepts for: a) the definition of the planned modular architecture, including common module and rule types; b) extensive semantic support of these types; c) module mapping; and d) conformance checking.

the metamodel may be helpful to enhance existing tools or to develop new approaches.


Despite extra work involved in testing, each component was always delivered on time, and, with a single exception, to speci.cation.

we will repeat development practices described here in future projects.


Modifying a list means to add or to remove items of the list.

we provide the keywords adds and removes to add and remove a list of enumeration items.


Parentheses and semicolons in method calls can be omitted in Groovy.

for a method m that takes a closure as its sole argument, the call can be written as m { ... }, where the ellipsis represents the actual code of the closure.


Native JNI functions have a speci.c name and signature which is implied by the JNI standard.

it is only possible to call native JNI functions from Java.


The actors within one group use the same proxy and tend to have similar interests, resulting in a higher level of intra-group communication than inter-group communication.

the population of actors in a scenario with fewer groups is overall more homogeneous in its web-access behavior.


When a snapshot is created, the values of these selected .elds are preserved.

not every state can be re-established, but states that are part of global snapshots.


Speci.cally, discrete GPUs typically communicate incoherently with the CPU across a limited interconnect, and should be treated like distributed-memory machines.

carefully choosing when to move data between CPU and GPU is important to achieving good performance.


Hence, implementations of our concept need to pay attention to performance issues and may consider partial tracing approaches [32][23][20].

reproducible results rely on deterministic tests.


This kind of attraction factor decides the freedom of the growth of roads.

the shapes of roads are decided by two aspects: elevation and freedom.


t[p] = tm[p]+1 { t[p] := t[p] + 1; } l[py] := 42; l[px] := 24; var lx: lin in lx := l@{px}; var lxm:tot in lxm := map(lx); call incr(px,lxm,lx); l := lx@{px}; Figure 3.

ghost variables the triple {px != py} C {l[py] = 42} can be easily veri.ed using the conventional frame rule.


From our partition of the heap to areas (see 3 below) we know that each word in the bitmap can be written by one thread only.

writing the bitmap does not require synchronization either.


It can only deals with link crashes due to its adaptation ability.

the only property supported is Integrity.


result Formula: (True U (~ PM / (False R ~ MU))) / (False R (~ PM / (True U MU))) Figure 3: Maude screen shot This formula characterises all the paths in which ¬ MarkasUnread occurs at least once: this is guaranteed by the .rst part of the formula, in which it is required that Placedin-Mailboxes must be false at some point in the future, followed by globally ¬MarkasUnread.

this formula rules out the possibility that MarkedasUnread is always true: indeed, in this case it would be impossible to .ip the value of the original formula because of MarkasUnread.


Since the source code of Inspector is not available for us, it is not possible to directlyintegrateourproposedideatoInspector.

we .rst runInspector alone togetdata race reports, then separately run AT-Detector withthedata race candidates asitsinputs.


While identifying such patterns recursively can allow us to improve the I/O savings even further, this can signi.cantlyincrease the amount of computation required as well.

in our approach, we only consider the .rst level of periodicity.


In terms of the example discussed above, by carefully moving classes from their original modules into other modules, it is possible to reduce the coupling between modules.

move refactoring applied to a software dependency network translates into relabeling the network nodes (e.g JAVA classes) according to module membership (e.g.


If they want to create new metrics, they have to implement these by themselves, if the software is available in source code or o.ers an appropriate interface, or they have to rely on theCRMvendor.

developing and experimentingwith new metrics is di.cult.


If an object is moved, only its handle needs to be updated, which is trivial and can be done atomically.

the old location of a moved object can be re-used immediately, without need for the copy reserve required by direct pointer implementations.


However, since this problem is undecidable in general, predicates from the underlying programming language were considered as black boxes.

the implication relationship was only determined for syntactically identical terms.


The monitors we add to Xinu contain an associated semaphore, a thread ownership ID, and a count tracking the number of locks performed without corresponding unlocks.

a monitor count begins at zero, every successful lock action increases the count by one, and every unlock action decreases the count by one.


By contrast, the speci.cations for client code are relatively simpler, and the speci.cations required to show the absence of unexpected exceptions in client code are even simpler.

there is ample opportunity to reduce the cost of partial formal veri.cation by focusing on client code.


Intuitively, if a task is executing code with a given control .ow variable state that another task could have already executed with the same state then that .rst task is earlier in its execution than the second.

it has made less progress in the logical execution space.


For example, although a table is a block-level element that can span many lines of Wikitext, its individual syntactic atoms are only recognized at the beginning of a line.

many processing steps start by breaking up the source by lines.


{2,...,d}, there must be an m such that S[0,m], threadE (bi)) = bi.

the condition on line 13 must be satis.ed at least once for each i .


However, GC poses additional writes that hinder the I/O performance, while SSD blocks can only endure a .nite number of erasures.

there is a performance-durability tradeoff on the design space of GC.


This is especially true for pro.ling heavyweight typestates, e.g., pointer typestate.

2ndStrike analyzer runs in a separate process which connects to the programbeing tested via socket, so that it can consume the generated logswithout saving them to disk.


And, for those ones that are external characteristics the evaluation team should define the quality attributes for compose and complement the quality characteristic (if was not performed yet).

the evaluation team assures the complete definitions of the quality characteristics necessary to evaluate the components.


This is all that needs to be done for read-only transactions.

the TCM sets the Commit .ag in the transaction header.


We strongly believe that the design and development of domain-specific languages should not be different so much from the design and implementation of general-purpose languages.

for efficient and rapid development of domain-specific language any tool can be used that generates a compiler or an interpreter from formal language specifications.


ti.T Pi The memory space requirement makes the optimal speed assignment for all task instances impractical for the on-line usage.

we propose to set the execution speed of the j-th task instance of task ti as the maximum execution speed among all of its task instances with the same value k = j (modNi)in a hyper-period (referred to as the (k +1)-th task frame Fi,k+1 of task ti).


However, after the .rst join, the intermediate join result of R S is pre-grouped on attribute a, b and c (e.g., the symbol a1 is not distinct on the attribute a in the join result).

if this intermediate result further joins with the symbolic relation T on attribute a and e, then the distribution cannot be freely speci.ed by a user, because if the .rst tuple t11 of T joins with the .rst tuple t7 of the intermediate results, this implies that e1= a1 and thus t11 must join with t8 and t9 as well.


Neglecting the memory required to generate random numbers, .tness values of two sampled individuals, etc., the two largest memory requirements for cGA are: (1) Probability vector: 4 *f bytes, and (2) sampling two individuals: 2 *f/8= f/4 bytes.

the total memory required to store the probability vector and to sample two candidate solutions is given by 17 µcGA =4 *f + f/4= ·f.


In FICKLE, any subclass (direct or indirect) of a root class must be a state class, whereas with shakeins, regular classes, that can have regular subclasses, are used as roots.

shakeins can be used to create a state group from existing classes within a pre-de.ned hierarchy, such as the standard library.


If the guard condition is satisfied, the test generator proceeds with the rest of the path, otherwise, it backtracks to a suitable node and explores another path for test generation.

specification of guard conditions along state transitions is a powerful mechanism for the test generator to select test scenarios that are coherent and c) in the extended UML Statechart model, test statements may be specified along state transitions or state nodes.


For shower simulations, the double source of randomness leads to the combination of gaussian distributions due to internal randomisation and non-necessarily gaussian distributions coming from the above-mentioned physical e.ects.

taux d acceptation 0.6 0.4 0.2 the outlier detection test itself has to be designed from data mining of existing (and hopefully correct) shower results.


The schema mapping M ' is a maximum recovery of M if (1) M ' is a recovery for M, and (2) for every recovery M '' of M, wehavethat M.M ' .M.M '' .

a maximum recovery is a recovery that is optimal among all recoveries in the sense that the composition of M with M ' is the smallest among the compositions of M with every other recovery.


Once such information stops, prediction uncertainty grows.

to the degree that PocketParker queries follow a pattern of arrivals and departures, it will do well.


The crucial point of the integration of graph transformation techniques into MOFLON is, that MOF 2.0 acts as graph schema language rather than old versions of UML or proprietary approaches, which is a considerable novelty in the community of graph transformation tools.

the promising features of MOF 2.0 like association subsetting and rede.nition can be applied in the context of graph transformations.


At time t = 1 an event E1 occurs, which satis.es all the constraints to enter 4 Notice that an automaton in its initial state cannot be deleted, as transitions exiting the initial state do not include timing constraints.

state E. Aut duplicates itself, creating Aut1, which uses event E1 to move to state E. We record this fact by labeling the .red transition with the triggering event E1 and the time of occurrence, i.e., E1@1.


The extractive and reactive models are not isolated pieces but are integral components for .exible SPL development.

the issues discussed in Section 3 can help tackle the problems we face in reactive requirements analysis.


Although it s quite simple, it does depend on nesting (an object literal in a method in an object literal), and that can be hard for novice students to understand at .rst.

for instructors who want to delay a discussion of nesting, or who just prefer a more concise or more familiar syntax, the following class declaration accomplishes the same thing: class anAddressCard.for (nm) address (adr) { def name = nm def address = adr method email { EmailApp.openComposerWindowTo(name) } } a Grace class is really just a factory object.


In MR-MPS, each expected result that implements a certain process culminates with the generation ofone or more work products, which can provide concrete evidence of the process satisfaction.

in agilemethods, when the practices are implemented, it is possible to generate a work product as output.an important issue to consider is whether the work products arising from the use of the targetagile method correspond to the work products required by the MR-MPS processes.


An experiment focused on assessing the quality of a code written in some particular language can be strongly in.uenced by the experience of the developer.

experience may be a blocking variable [6].


In the processor, Intel Hyper-Threading Technology (HTT) that delivers two processing threads per physical core is adopted.

the hardware experimental platform can be viewed as a multi-core computer with 16 cores.


Second, distributed systems require a large amount of policy to be attached to storage: .les and directories must have owners, access control lists, and other data structures that would be impractical to attach to every block.

a block interface is not the appropriate low-level interface for tactical storage.


Hence, NSGA overall signi.cantly outperforms FPLS, and the same .nding apply for the Random approach.

we reject the null hypothesis H0 and accept H1.


Influenced by these factors, mobile environments and apps are in many ways fundamentally different from the conventional desktop paradigm and applications.

the current mobile paradigm means several new challenges for the responsible parties (e.g., the interaction design team, the development team, the architects, etc.)


Its effectiveness is directly related to the author's ability to adapt to these simple and regular inference structures, writing questions and answers that properly function within these constraints.

knowledge is entered via text editing, without the use of probabilities or weights, making knowledge entry easy.


Fortunately, such asynchronous hardware events are observed and handled on the instruction boundary in common processor architectures.

a replayer can reproduce the correct order of hardware events and related software behavior by capturing and replaying hardware events at instruction level accuracy.


Because the baseline bandwidth demand of OMNet++ is slightly less than 25% of the saturation bandwidth, which is less than the system peak bandwidth, we would not expect four instances to saturate the bandwidth.

without any additional information, our best (although naive) prediction would be that the throughput scales linearly.


It is beneficial to use as much slack as possible.


It makes use of web services to expose processing operations, but the task of data transport is delegated to a subsystem.

the data transfer is performed outside of the web service scope.


In our case, metadata applies to the collection as a whole.

when a replica receives protocol metadata during synchronization, we call it as a sync operation.


Emulation of the real Internet made a testbed increase realism, however, it was di.cult to construct an experimental network which had same size, same facilities, and / or same characteristics of the real Internet.

some emulation techniques should be taken to solve trade-o.s among the scale of a testbed.


Furthermore, the cost of the operations made during the solve phase is not very high.

we must be able to prefetch factor blocks as fast as possible and to do sequential read to ensure a good speed of I/O operations.


while still fulfilling the main purpose of the system.

identifying and analyzing alternative ways of how the main objectives of the system can be achieved and designing a system that supports all of these alternative behaviours is a promising way to develop autonomic systems.


µEi s Ei are the only additions to states in host language partition of the LR DFA MC H for the composed language.

in those states, any new actions introduced by adding an extension are only added in the µEi columns of the parse table.


Variations can be composed to produce the actual behavior of the agent.

variation activation and the other context-related operations are performed by sending ad-hoc messagestotheagent.in CONTEXTERLANG,asynchronous activation, as required by real-world adaptive systems, is the norm.


Path-based schemes [7] tend to model the timing information accurately but have an exponential complexity which does not scale very well.

most recent works are net-based [8][9] where timing analysis is performed to identify the critical paths and weight the critical nets, while the core placement engine works on weighted net length minimization.


In an evaluation of our JAVALANCHE framework on seven industrial-size programs, we found that mutations that violate invariants are signi.cantly more likely to be detectable by a test suite.

mutations with impact on invariants should be focused upon when improving test suites.


Considering that the organization has several applications that have been built independently, with different languages and platforms, files are a universal storage mechanism, which can be available and serve as a way to integrate applications.

one application can produce files to be consumed by other applications.


In Situation 3, in the worst case, we need to perform l reducedorder merge operations before erasing a log block, where l is the maximum associativity of a log block allowed in LMT.

the worst-case system response time in Situation 3 is: l × {(Trd + Twr ) × Npage + Terase } + Terase .


These exceptions only aim to avoid type errors that occur when merging existing types and their extensions, and thus they are conservative.

we discuss the type system only from the viewpoint of merging types.


each node should be clear, coherent, ordered and most of all, simple.


Extracted access patterns can be used for prefetching [12].

we exclusive access control is also required between the .


Applying both serializations causes a cycle between Def(F) and Def(G), which makes scheduling impossible.


However, for this, the data has to be available locally for the scientists to visualize.

if the application was executed and pro.led at a remote location, the pro.le data has to be transferred (oftentimes over adistributedenvironment) tobeprocessed and viewed.


Once a string literal is instantiated, it continues to exist as a live object unless the class is unloaded.

the instantiation of unused literals may consume much of the Java heap.


(sk+1,tk+1) is permitted (in fact, checking that a word is accepted by a timed automaton is linear, see [3]).

as mentioned above, the maximum diameter of a witness for a violation is equal to the number of states of an automaton, which is bounded by n. the veri.cation that (sk,tk) .


Ad hoc tracing has several disadvantages: e.g., experts who have a strong mental model may not need to keep explicit traces; however, later in development the memory of traces may not be sufficient and much more costly and timeconsuming to obtain.

recent software engineering standards (like CMMI) demand basic systematic tracing between requirements and artifacts such as design, pieces of code, and system test cases.


In a similar way, we can decompose the tile horizontally if we wanted to view it as a revision of the derived update /u* towardsupdate v. Figure 4.

examples of 2-arrows Ifupdatesareunderstoodoperationallyaseditsequences, then u and v may be two different sequences with the same all components of the tile are essential and neither result.


This would at least in most cases be too circumstantial and only feasible when all applications can cope with the resulting non-availability of the .lesystem for temporary data.

we propose a more convenient approach relying on the tmpfs storage facility [9] (called simply tmpfs in the following), which is basically a dynamic RAM disk based on the virtual memory subsystem.


Note that a peer generates at least one MVR (with starting position being zero) and possibly a number of MVRs due to viewing jumps.

the average number of jumps for a given movie is approximately equal to the total number of MVRs divided by the total number of MVRs with starting position being zero.


Most of the Parks PDA content consisted of one full-screen image per card.

in response to a button press the system typically had to fetch and display a fullscreen image.


If the same program also executes the function foo in Figure 1, which accesses f1 and f2 together, then placing f1 and f2 in separate cache lines hurts foo since spatial locality is lost.

the challenge is to simultaneously optimize for both spatial locality and false sharing.


In a loss-prone energy sharing network, the less energy transferred in the network, the less energy loss would be incurred during the energy transfer process.

depending on the current energy harvesting and consumption rate, device i .rst calculates the minimum amount of energy that has to be accumulated from other devices.


Pluto generates code only for .xed (not parameterized) tile sizes.

pluto had to be repeatedly used to generate code for each tile size.


Open standardsbased middleware supports computation and communication software portability, which means that middleware written for one vendor s hardware should run on another vendor s platform.

middleware code that constitutes the inner-loop software implementation can be used for different vendors platforms for design analysis using performance modeling.


Goalbased methods such as KAOS and Secure Tropos have not achieved as widespread use across industry as use cases.


Therefore, the evaluated architecture was not detailed enough to provide a sound basis for implementation.

as a last step of the architecture development activity, the architecture was refined as soon as domain models were available as the result of a domain analysis performed for a sub-domain.


For example, project planners use traceability to perform impact analysis, while designers use it to understand dependencies between requirement and design [22].

we believe that without enabling traceability as a basis of the metamodel, the realizations of the requirements previously described are not feasible, becoming the SPL development a complete disorder.


Nevertheless, asynchronous events (e.g., interrupts) make the execution on real CPUs non-deterministic.

we have to setup a proper execution environment that guarantees deterministic execution in all possible CPU modes.


Experimental results seem to indicate that the cost of solving most problems is low order polynomial, often sub-cubic, in the size of the system.

fLAVERS has the potential to scale to handle realistic software systems.


Note that even people with the same medical diagnosis can have a wide range of motor capabilities [17, 22].

traditional, manual UI design and engineering will not scale to such a broad range of potential users.


To avoid repetitively and needlessly iterating over many dead robots in scan(), the programmer might maintain a cache a list of just the alive robots as follows: class Battle { private List robots; // master list of all robots private List aliveRobots; // cached list of alive robots ... public List getRobots() { return robots; } public List getAliveRobots() { return aliveRobots; }} Then, each robot can scan the list of alive robots, without needing to check whether each is alive or dead: class Robot { ... private void scan() { for(Robot r : battle.getAliveRobots()) { if(r!=null && r!=this && r.intersects(...)) { ... } }}}  Here, aliveRobots is a sub-collection of robots containing only those where !isDead() holds.

the for-loop in scan() no longer needlessly iterates over dead robots.


We found that supporting place names is important to promote the development of more location-based applications by the user community.

we re-engineered part of the architecture to make place a first-class citizen in the toolkit, giving developers the appropriate abstractions.


To do so it relies on primitive pointcut designators that select from certain join point types, as defined by that designator, those whose metadata description matches the designator s argument.

this argument is usually a signature or type pattern, depending on the designator.


We suspect some kind of hardware issue with the acoustic channels on that particular node.

about half of the shots were detected by three or fewer sensors.


In simulations, the amount of credits is set to be equivalent, in terms of CP U.hour, to 10% of total BoT workload.

depending on the BoT category considered, the number of provisioned credits varies.


Among others, the de.nition of user-centricity in TAS3 also addresses the user s ability : 1) to express privacy preferences, 2) to manage his own partial identities, 3) to con.gure trust preferences and provide feedbacks.

the user s ability to express trust preferences in TAS3 is accommodated by allowing the user to specify the trust rating or trust score that is required for entities in order for them to be involved in processing operations that for example can involve his/her personal data.


4.1 Concepts for service-oriented design The first three milestones from section 3.3 cover both business process design and application service design.

our concepts, shown in Figure 4, are generalizations of concepts from these domains.


Higher values of k implied that pages moved more quickly toward eviction.

k dictates the target allocation, as the two values are inversely related.


These problems are ex-acerbated when dealing with FPGAs (Field-Programmable Gate Arrays), a popular technology which combines the performance of custom hardware with the flexibility of software [2][3].

developers must explore code and mapping transformations specific to each archi-tecture so that the resulting solutions meet the overall re-quirements.


In case N(J)=Span(J)=max(AIt)+l, the maximum iteration dif- ference between any two nodes in J is strictly less than the number of loop bodies.

for each duplicate J~ of J, any two nodes that belong to different iterations of J will be located in different loop bodies in G =, thus not interfering.


Tracingtimeimprovesparticularlyonbenchmarkswhere crossmetadata references account for a large proportion of the total numberof referencestracedby COMP,e.g.avrora, fop,luindex, lusearch,sun.ow,tomcat andxalan.Forthesebenchmarkstracing timeisreducedby afactor of .veor more.

thesmallestgainsare obtainedforh2(15% only).Itstotal numberofliveobjectsintheapplicationheap aremorethan65 times aslarge, andthe numberof references emanatingfromthe application heap are more than 50 times as large than from the permanentgeneration.h2isthe onlybenchmark to bene.t more from the elimination of compaction than the reduction in tracingtime.


Transition, alias handover, can become very expensive and protracted if the organizations are not well prepared for performing it.

thorough preparations and good planning are necessary for alleviating many transition problems [3].


InFigure11,if the next eventbreaks out along/near the solid thickgrayline, whichperpendicularly bisectsthe soliddarklinebetweenanchorC and thecenterof gravity of node9 s area(thegray area), the wave would reach anchorC and thecenter ofgravity of node9 sareaat roughly thesametime, which would relatively equallydividenode9 s area.

node9prefersto voteforthepositions around the thickgrayline.


We believe that pruning of erroneous transitions should be done before learning.

we include a .ltering process before the learning process in SMArTIC, as we shall describe in Section 3.1.


Moreover, one pattern usually affects several other principles.

the paper continues with a focused explanation of the patterns grouped into the three categories form, modi.cation, and support.


As the name implies, Yaccscript is the fusion of a compilercompiler2 and a scripting engine.

it supports multiple languages by compiling compilers for those languages dynamically.


For example, a select operation on a collection represented by a comprehension of the form (1) is translated by conjoining the body of the select construct with the predicate p(x).A collect operation can be translated by substituting E(x) by the body of the collect construct.

every OCL type includes an unde.ned value.3 we add to every translation of an OCL expression e a formula de that evaluates to true iff the expression does not evaluate to the unde.ned value.


Additionally, RedHerring s decoy environments are constructed to look identical to real distributed web servers from inside the container; for example, many real web servers use LXC containers that look like the decoy LXC containers.

distinguishing decoys from real web servers on the basis of environmental details (e.g., through init process control groups) is di.cult for attackers.


That is not to say that they can not be so represented, it is just that they usually are not ad it is often difficult to do so.

for most computer science problems we have a somewhat greater challenge.


Tuning parameters for each application manually might achieve better performance for that application but is not general.

we empirically evaluated a wide range of parameters for each strategy and, for brevity, report results using best-performing parameter values (on average) across the benchmarks studied.


Thiskeepstheinternal stateof theunitinternally consistent on all explored paths: for each explored path, there exists some concrete execution of the system that would lead to exactly the same internalstateoftheunit alongthatpath exceptthe enginedoes not need to incur the cost of actually .nding that path.

any sound analysis that takesinto account only theinternal state of the unit produces no false positives under the LC model.


Thus, a macro step consists of all the actions that are executed between two consecutive pause statements.

all parallel threads run in lock-step, which leads to a deterministic (!)


Concretely, we must prove that: runAT aenv o(f #i ) .. orunAT aenv 0 o(f #i ) We observe that the problem of reasoning about aspect interference for an isolated function woven by aspects is directly analogous to the work of MRI in the model of mixins.

we can bene.t from the established results of MRI in at least two ways: The type Open s represents an open component of type s. new is a .xpoint combinator that closes, or instantiates, an open component that is potentially extended.


O(q).v < v}| automata, an upwards closed set is completely determined by a single natural number, which is the lower bound on the set.

we introduce an integer variable k.nal and create a constraint that Our decision procedure will take four additional parameters as the value of the counter after reading t is greater than or equal to input Q, N , K , M .


We attempt to improve on this situation by increasing parallelism.

we spawn a second-level parallelism over the outer loop of the sub-image in Figure 14.


It is even quite likely that the strategy of recycling gaps in the layout introduces differences.

it may be interesting to make a trade-off between image size and the number of modi.ed erase blocks.


Our main aim is to keep the time variables of concrete model during the abstraction interpretation proceeding as safe as possible.

the second question of interest can be dressed: Is it possible to apply PMC (Nbac) algorithm into Nbac (PMC) without losing clock variables?


As before, the results are best understood as differences in response times.

we compare the lazy policy response times against those of the other three single-core policies.


If this checking is successful, the bytecode for that class is generated; otherwise, an error message is generated.

in Java, compiling one .le causes a recursive compilation of every uncompiled source .le upon which it depends [4].


Our second observation is that a subscription does not match the event as long as any of its predicates cannot be satis.ed.

whenever we .nd one unsatis.ed predicate, we can immediately discard all associated subscriptions, and their remaining predicates do not need to be evaluated.


Each individual trace must have code to .rst save the interpreter state and restore the interpreter prior to leaving the trace.

trace A saves state, executes, and restores state back to the interpreter.


To make the algorithm incremental, we design it in such a way that it does not execute one code fragment on all generated inputs; instead, it tries to execute all code fragment (Line 7) on one input .rst and partition them into smaller sets (also called code clusters).

the whole set can be gradually partitioned into functionally equivalent clusters with more and more inputs (Line 6).


However, EigenTrust utilizes normalized global trust values so that the difference between an attacker s trust values with more or fewer transactions is relatively small [13].

nT rans increases in almost direct proportion to the G under EigenTrust as shown in Fig.


Recall that an aasumption that is not invali- dated by any regular property or desired result in a superim- position (or in a roletype) is considered an implicit regular property of the same (if not declared as "basic").

in row six of Table 3 (in contrast to the same row in Table 2) there is a contradiction between a result of B (--p) and an assumption of A (p) that is not invalidated by any result or property of A.


As seen from the graph, the total number of DOM element locators increase linearly with each DOM state, while the total number of minimized DOM element locators saturates with the growing number of DOM states.

we achieve convergence within a relatively small number of DOM states.


The fuel to this fire has primarily been the fact that software fault localization (hereafter referred to simply as fault localization ) is one of the most expensive activities in program debugging [10].

any *This work is partially supported by USA National Science Foundation (NSF) grant DUE-1023071.


No data restructuring or code restructuring techniques, as described in Section 3.6, have been applied.

this speedup cannot be caused by a reduction in required memory bandwidth.


The more complex the module is, the more likely it will contain faults.

it is natural to use software complexity metrics to predict the fault proneness of software modules.


Since FIT is an optimizing instrumentor, for comparison purposes, the Base version of the benchmarks are generated through a dummy instrumentor (No instrumentation code is added, but it bene.ts from all the optimizations available from FIT.

they are actually faster than native runs, which are not shown here.).


Importantly, the boolean value on the top of the boolean stack after evaluation of the expression determines whether the conditional evaluates to true or false.

the contents of the expression (in addition to the predicate) control which production rules apply.


Field types are restricted to poly or pos.

a .eld f that is typed pos, is guaranteed to be pos in all x.f, while a .eld that is poly is interpreted depending on the type of x.


However, even in the early stages of fieldwork, the ethnographer searches out experiences and events as they come to his/her attention.

the participant observation technique becomes more refined, as the researcher understands more about the culture.


As mentioned previously, Data Dependencies is a performance indicator of the number of cycles the core has to wait for memory dependencies to resolve.

based on the discussion above and with the idea of re-using performance events covered by CPU power estimation, we parameterized memory power consumption using two performance events: Instruction fetch miss and data dependencies.


Note that, with this heuristic, diverge branch-CFM point pairs that are identi.ed as short hammocks are always predicated, unlike regular hammocks.

any other CFM point candidates found for the same diverge branch that do not qualify as short hammocks are not selected as CFM points.


In contrast, IA-32 maintains instruction cache consistency in hardware, making every write to memory a potential code modi.cation.

we must monitor all memory writes to detect those that affect code, either by sandboxing each write with inserted instrumentation (Section 3.3) or by using hardware page protection.


4.3 Concurrent context manipulation Context switches take place dynamically, as changes are detected in the surrounding environment.

context switches occur concurrently, at the same time applications run on the device.


p1(let z =(1, 2) in (1, 2)) Further, we must be able to instantiate under nested bindings between the binding in question and its use.

(inst-2) must allow additional bindings E2 and E2 ' between R and the let and 1 It is the conventional wisdom of distributed programming that in any cases of this sort early binding is extremely wicked, and every opportunity must be taken to allow for variability.


If so, then either the variable value changes will be used to create a cause-effect chain or an attempt will be made to narrow those values further.)

potentially relevant variable value changes (to a program state in ep ) constitute a compound treatment in HOW C O M E s experiments.


As in SSBA, the essence of this impossibility lies in the requirement that if a Byzantine node changes its input value, the output value of the repetitive consensus does not change.

in CC, even if all non-faulty nodes have all the input values of all nodes, they cannot di.erentiate between a nonfaulty node that has changed its value, and a Byzantine node mimicking a new input value.


Furthermore, from the macroscopical perspective of their superior organization, all simple roles, sub-RN and their relations form an upper-layer network.

a hierarchical network structure is formed as figure 2.


The location estimator solves the equations with the Gauss-Newton algorithm.

an estimate of the recording location, m, is determined.


Consider every predicate expression as being mapped to a set of locations.

assume a set of location sets, {L1 = {.11 ,.12 , ....1m1 }, L2 = {.21 ,.22 , ....2m2 }, ... Lk = {.k1 ,.k2 , ....1mk }}, where Li corresponds to locations associated with predicates that reach call-site i of procedure P .


During this period the legacy system must be maintained to meet the ever changing business requirements, which implies parallel costs for both the new system and the legacy system.

smooth transition paths and integration of legacy systems are not just nice properties of software development projects, but essential for most real-world projects in the domain of information system integration [9, 20].


Free superblocks are linked together in a free -list, but they cannot be coalesced.

the size of an allocated block cannot be larger than the size of a superblock.


It is safe for us to treat the code provided or generated by the frameworks as unchanged libraries, and omit them in our analysis.

the CFG of each operation in each service will be generated from only those methods (functions) which are actually implementing the operation.


For example, in continuos sensing it has been shown the relevance of modifying classi.cation parameters at runtime; (iii) classi.cation accuracy is inversely proportional to the number of treated classes [11] [5].

modern architectures stemming from these requirements should exhibit a certain degree dynamism and .exibility and make applications able to autonomously WORKSHOP: MCW interoperate and recon.gure.


Further, we often time operations that complete very quickly; thus, timer resolution is an issue.

we provide a fast timer that is specific to the current platform (e.g., on Intel machines, we use the rdtsc instruction).


This also implies that ENS sensor, processor, and other components may also be employed on-demand and only infrequently used.

a new ENS platform intended to support the complete set of environmental monitoring applications must differ from previous ENS systems by introducing proper scheduling of sensing, computing, and communication tasks.


In contrast, there are only a couple of allocation sites that allocate many objects of a certain class [26].

an overflow in ID numbers rarely occurs even with few bits.


Unfortunately, computation of such formulae is complex thus preventing their usage in common practice [4].

generally attribute values are valid for a speci.c context and they cannot be reused in a di.erent context without precise information about it.


As is the trend now, we expect that static analysis will be used where possible, and runtime analysis will be used to complete the analysis 1.

we are proceeding with the development of both static and runtime veri.cation tools, and have found that static and runtime analysis have complementary features.


The advantage of the algorithm in [13] is that the processes do not have to start at level N (the total number of processes in the system) but can start at any level, according to a pa- rameter (start_level).

the step complexity of the algorithm depends on the start_level parameter passed in each call.


However, the problem of grid scheduling is still more complex than the proposed solutions.

large number of researchers [1, 9, 11, 13, 14] is showing interest in it.


2.4 Impact Analysis Although test suite reduction has a number of advantages, it is not always appropriate (e.g., even though reduction approaches can maintain 100% requirement coverage, they may have di.erent fault detection behavior from the original test suite [23]).

developers often prefer impact analysis-based approaches [13, 17, 18, 20] that use static and dynamic analyses to determine which tests could possibly be a.ected by a source code change.


by construction, managed runtimes provide a small instrumentation surface for adding functionality to record/replay non-deterministic environmental interactions, including .le system, console, and network I/O.


Parallelizing Eduction The semantics of NVIL is a good basis for executing NVIL programs but does not take advantage of distribution in the case of parallel architectures and does not memoize computed values to avoid recomputation.

we have designed a parallel Eduction Virtual Machine (EVM) to execute intensional NVIL programs.


Interestingly in our test runs, on average, only about 25% input sources and 3% shared objects affect other shared accesses through conditionalbranches.

itisimportanttoidentify such relevantinput sources and shared objectsfor testing anddebugging.


This means that the paths can grow inde.nitely without a.ecting the interference metric.

we de.ne the average path interference of a graph as the sum of interference for all interference-optimal paths between node pairs, divided by the number of all node pairs in the graph.


Using those semantics, it is not possible to determine that a given memory operation was delayed by examining only the source state and the transition associated with the operation.

we instrument the concrete semantics with additional information about the instruction that stored each value.


However, for truly pervasive and context aware applications based on IMS, the intrinsic IMS contextual information is not enough.

general context can be retrieved from external context management systems and linked into the IMS similar to what we propose in this paper.


Since S only has arcs to nodes corresponding to Ts s instructions de.ning r, this is clearly a cut in Gf .

by the construction of Gf , for a given cut C in Gf , the number of dynamic communications of r that will be executed corresponds to the cost of the arcs in C. the problem of .nding theminimum number of dynamic communications reduces to .nding a minimum cut in Gf .


6.4 Runtime ef.ciency Although the aim of Evalorizer is to advise web developers in the replacement of eval, it is arguable that, to be useful, the runtime overhead of our tool needs to be low.

we measured the speed of pages while using our tool.


Figure 9 con tains an illustrative implementation of this simple abstract interpreter.

our systematic pre-generation of optimized derivatives needs to account for selective generation of reference count operation optimized derivatives, e.g., for binary operations the following four optimized derivatives are possible: both reference count operations can be removed,  the top-of-stack operand s reference count operations can be removed,  the reference count operations of the second element on the operand stack can be removed,  no reference count operations can be removed (this corresponds to the standard implementation).


We note that the language of these properties are timed-pre.x-closed, timed-su.x-closed sets of interval-timed traces, and hence the properties are passively testable.

as described in Section 2, passive testing corresponds to checking of membership of the observed interval-timed traces of the HBM in the language of these properties.


Using Type a does notwork becauseit would notbe possibletode.neatypeequality mechanismoverit.Thedrawback ofthe use of Var isthatHaskelltypeinferencemechanismfails to unify Var withany type, likeit woulddowithanormalHaskell type variable.

we cannot solely rely on the Haskell typesystem and thus have to create our own uni.cation mechanism (Section5.4).


A statistical test was performed, Wilcoxon-Mann-Whitney rank sum [8], and we could reject the hypothesis that FRAN is not favorable to FRIAR in more than 50% of comparisons in the top-10 and top-15 cases (p-vals of 0.0034 and 0.00034 respectively), but not in the top-5 case (p-val of 0.83).

statistically, FRAN more often than not does better than FRIAR.


if ( join attribute value t.v is already inserted in   LHist(BTi)) then increment the frequency relative to t.v in LHist(BTi); .

else add the couple (t.v, 1) to LHist(BTi); Endif }} the associated records of local histograms on all mappers are sent to the same reducer.


However, to limit the number of samples to a manageable size, n must be made large for a large m. Unfortunately, a large n may result in a precision loss because it creates large gaps between some samples.

in this work, we vary the values of m and n in different parts of the memory trace.


Unfortunately, this approach is not systematic: as our measurements indicate, during normal user interaction, coverage tends to be low, as users explore just a small set among the features and functionality offered by the app.

relying on users might have limited utility.


RELATED WORK AND DISCUSSION Previous work has studied transactional memory consistency by: investigating the semantics of different programming languages with atomic blocks and the feasibility of their ef.cient implementation [1, 11, 19]; or  de.ning consistency conditions for TM [3,5,8,9,18] and proving  that particular TM implementations validate them [4, 9].

previous work has tended to address the issue from the perspective of either programming languages or TM implementations and has not tried to relate these two levels in a formal manner.


4.3 Limitations Our current implementation lacks access to type information and support for type manipulations.

for example, field reordering is done by manual source code modification.


For example, it is possible to express policies that disallow system calls for opening .les in the host computer, or to block access to network services after reading data, but it is hard to encode the dynamic behavior of a high-level policy, which takes an authorization decision based on the current conditions in its running environment.

the model of the policy environment becomes a crucial element for enforcing dynamic policies.


depth-.rst search order and assign levels in a descending order.


In the case where P sends a message to this processor, it becomes a late message.

unlike system-level checkpointing protocols, application-level checkpointing protocols must handle both late and early messages.


To make program behavior deterministic, we stipulate that these actions are executed in the order of their textual occurrence in the program.

when Ambiguous Example 1 receives an A event, it executes first the action x=1 and then the action x=2, leaving x holding the value 2 when the action !>B(x); is executed.


Clearly, #l(z) _> t + 1, and f(y) = 0 for every y with #l(y) = #l(x) --1.

since t = 1, #l(x) > 2, and it is possible to switch two of the rs in x to 0, getting two input vectors yl,y2 with #l(yz) = ~l(y2) = #l(x) -1, and hence with /(yz) =/(y2) = 0, and both yz and y2 differ in exactly one bit from x.


The second approach, operator-based co-evolution, allows users to evolve their metamodel using pre-de.ned operators (small transformations applied to the metamodel), each of which has an associated model migration action.

the migration strategy is created automatically whilst evolving the metamodel.


Let T1hop denote the average delay of each packet transmitted in one hop.

a time of iT1hop (i=0) after a packet is sent out from the root node, the nodes whose depth are less than or equal to i will receive it if no packets is lost.


We expect that the frequently accessed scalar local variables will be assigned to the registers during the register allocation step.

they are not considered for allocation onto the SPM.


Besides, scheduling decisions can also take advantage of register spilling.


are the "potential query terms" that can be used to retrieve additional requirements for the complete search.

thcse terms comprise a conceptual space that can charectcrize requirements space R. It is a highly labor-intensive task for uscrs to gcncrato such a long list of elsboretive (similar/alternative) queries with an expectation of not missing any important requirements terms.


Programs can be run by multi-processors machines without any change.

multi-threaded systems immediately take bene.t from SMP architectures, which become now widely available.


The Precision Time Protocol (PTP) [7] can synchronize clocks in a network to a very high degree of accuracy, typically on the order of microseconds.

accurate time appears to be an accessible and useful tool for coordinating con.guration changes.


Overall, females had significantly more pauses than males, with a mean of 220 versus 190 occurrences (ANOVA, p<0.05, F[1,74]=4.22, R2=0.05).

males did not take the time that might have been used to reflect upon the feedback from their actions as often as the females did.


Our observations further imply that there is a latency caused by defect introduction on the main line and defect detection on branches during stabilization (bug-fix time [2]).

when analyzing releases on the main line, the time frame has to be selected large enough to encompass all defects on branches which have an impact on the analyzed releases.


When the SODA scheduler makes RF queries and encounters a point where increasing the MIPS decreases the output rate, the scheduler naturally assumes that further increasing the MIPS will not produce a higher output.

the source PEs (and correspondingly, the downstream PEs) end up getting too few MIPS.


By inspecting the dags associated with Fibonacci computation, we see that T(n) -=3F(n) -2.


These tools process the abstract syntax of MontiArc models.

they may be reused in extensions of MontiArc as well.


However, from at least the 100 th test case on, test cases are nearly uniformly distributed within the input domain.

the in.uence of the early test cases vanishes for lower failure rate.


We assume uniform compute resources: each resource has a compute speed and the execution time of a task on a resource is proportional to its speed.

a resource is not intrinsically better for some tasks than for some others.


While testing can be useful in practice for .nding vulnerabilities, it cannot be used to make security guarantees.

several techniques based on static analysis or runtime checking have been proposed, most of which are based on the notion of taintedness, similar to Perl s tainted mode [40].


Furthermore, most UIs have been developed only for a 2D environment in mind: their 3D integration is not seamless and not straightforward.

there are many reasons to de-fine and test a method for systematically producing a 3D UI simi-larly to methods existing for 2D UIs, while taking into account specific characteristics of the 3D world and what is needed to en-sure a smooth transition between 2D and 3D.


Then, the OCL constraints have to be the reason for the contradiction.

a method for OCL debugging is executed in the second step.


In the current version of the code generators, each actor is translated separately and is connected with FIFO bu.ers.

no cross-actor optimizations are employed at the current level of development of the tool.


Note that our slicing algorithm is based on backwards traversal of the program trace, whereas the actual stack is constructed via forward program execution.

during slicing we reverse the roles of pushing and popping the stack.


(2) If k = 0, then we know that OPT is S0,0 and from the algorithm we know that f) = s0,0 .


practical problem appears in terms of memory requirements since each of the K -1 permutation pattern needs to be stored.

we wish to generate multiple interleavers from a simple equation or by simple operations on a common mother interleaver.


Co-iteration consists of associating to each stream a transition function from old state to a pair of a value and a new state, and an initial state.

in Haskell we can model co-iterative streams as follows: d a t a S t r e a m a w h e r e S t r e a m : : ( s t a t e .


Though the above mechanism may compromise the atomicity of a weak-lock protected code region, we always preserve the invariant that only one thread holds a given weak-lock at any given time.

recording and replaying the exact order of forced weaklock release and reacquire operations with respect to instrumented weak-lock operations is suf.cient to guarantee deterministic replay.


In the meantime, however, the deletion of o7 has been undone, eliminating the delete-reference con.ict.

the link can now be inserted automatically.


During our validation, we identi.ed that the test subjects do not adopt LMZL, allowing the execution of local script code.

this insecure component usage can lead to serious vulnerabilities.


Semantically these operations can be thought of as accesses to .elds that are internal to the virtual machine, e.g., an object s lock and waitset.

like the access metric, the wait metric de.nes the ordering of operations.


While Schema has the virtue of being platform-independent, ecologylab.xml is oriented toward meeting the needs of software developers engaged in building practical systems for document engineering.

schema-equivalent specifications are defined through annotated program object declarations.


[7] explain the challenges of formalising such an ecosystem, players need to realise their role, and manufacturers need to face risks such as opening their product interfaces, knowledge bases and source code to other parties.

the formalisation of business rules that enforce the required openness to support open innovation while preserving the intricate properties specific to ES, such as real-time constraints and safety, is required.


However, the performance of the cleaner greatly affects the system performance.

many researches [2,6,8,11-13] aim at improving cleaning performance.


The proposed system will transform web pages to their corresponding mobile pages directly without going through any intermediate language like XML.

it is quite adequate for the web sites to be updated frequently.


(In fact, a bug .x must not be semantics-preserving.)

our approach is much simpler in that it identi.es added and deleted dependences only.


For HC most of the points are local optima.

hC spends most of its time in doing restarts even in the case of good quality solutions.


The events with priorities below 0 are regarded as no contribution to understanding the following event.

all priorities value less than 0, are scaled as the lowest one.


First, the derivation by restriction and its associated variability is purely based on a textual speci.cation [26].

supporting the process of Core Component customization relies on domain-speci.c implementations.


In page mapping FTL, the map translates a sector number to a combination of page number and block number where the sector data exists.

each modified sector can be written to any available page of any redundant block.


For the COTS vendors, this contract serves as the basis for future upgrading and evolving the system.

any new version of the same COTS component should conform to all properties specified in the previous version to avoid the danger of mismatch when old version of a component is upgraded by a new version.


The jGRASP integrated Java debugger is used to collect the runtime information necessary to render the visualizations.

a program must run in the debugger or from the jGRASP workbench for its data structures to be visualized.


In the presented traits example, the resend semantics of CELL are used to realize super-sends.

if a traitmethod does a super-send, the lookup visitor .rst visits all super-traits of the current class, and then the super-classes.


The Triple Spaces (TS) paradigm basically consists on writing and reading triples grouped in graphs in di.erent spaces.

the resources in TS are RDF graphs identi.ed by an URI.


Reactive rule insertion allows such rules to be installed selectively and hence may reduce the TCAM size requirement.

it is important to design the controller for predictable performance irrespective of the traf.c dynamics.


For example, each of the feature references may lead to a type error, if the target of the reference is not present in a product.

to measure the potential for a type error, we can count the number of references to optional features.


Yet these approaches are special-purpose and attempt to solve only this particular instance of the problem.

special-purpose tools such as D and Doorastha are rarely used in practice: programmers avoid introducing extra dependencies just to address a single optimization task.


In [36], several ways are proposed to determine input-output relationships in tested software.

a tester can analyze system specifications, perform structural analysis of the system s source code, and observe the results of system execution.


OrderedCollections and SortedCollections store their elements in an array that is referenced by one of the instance variables of the collection.

the internal array can be replaced with a larger one if the collection grows beyond its storage capacity.


Consequently, method calls must be issued for the test cluster objects.

a test case for an object-oriented software unit consists of the de.nition of testing prerequisites, a test program incorporating both test data (as parameter values) and method calls3, as well as the test oracle.


As explained above, we did not implement direct global allocation for this benchmark.

we report measurements with thread-local heaps and in the next section infer how direct global allocation would a.ect this case.


In our implementations, we found an overlapping set of required functionality across the gray-box ICLs.

we have begun to formalize a "gray toolbox": a common repos- itory of useful routines to ease construction across different operating systems.


3.2 Application of the Model The interpretation and analysis of the amount of time for the communication tasks at arvato services healthcare based on the VSM leads to the following assessment of the IC structure: the site manager spent lots of time for daily visits at the warehouse or operational issues (System 3*) and meetings with staff (System 3).

there was no time for System 4 and System 5 functions which nobody else carried out.


Therefore, the hot paths in the pro.ling runs may not be frequently taken in the real runs.

picking one hot path at compile time may cause manymisspeculations at runtime.


For a structural feature r, let tc(r) be an instant test case of r generated by the on-demand test generator.

for each test case ti, we can de.ne a set of faulty features F F S (ti), where each structural feature r .


Daily use also helped realize that the ability to put back windows into a normal state after some transformation was very important.

the default Metisse con.guration allows users to cancel the transformations applied to a window by rightclicking on its title bar, a simple animation being used to ease the transition.


For example, in their analysis of the Apache server OSS development community, Mockus and colleagues found that of 3,060 individuals who submitted a total of 3,975 CRs, a subset of 458 individuals submitted the 591 CRs that were addressed in subsequent code releases [15].

increased noise is a downside of the openness of OSS development.


it cannot determine which array element is written at (*)), and in general it is unfeasible in the generic setting of the bytecode analysis, where high-level syntactic structures are compiled away.

at the early stages of this work, we tried to implement the second pre-analysis approach in Clousot [14].


If the tax rate is low (<< 1), then task A can preempt task B much of the time because it is charged less than B for using the CPU.

taxation implements a cross-CPU priority mechanism.


Note that none of the existing techniques provide maybe NPR information.

we did not compare our maybe-NPR analysis with others.


If a method s hash is the same as before, then the method did not change between versions, and for those methods VMV(N ) boils down to just checking that the extracted necessary conditions are also suf.cient (i.e., col.5).

we focus on those methods whose semantic hash changed; these are the cases where the semantic assumptions carried over from previous versions should enable the proof of the modi.ed code.


Error outputs should be never matched since they represent the end of an interaction.

if the StrawBerry s user has this information this heuristic can be enabled to prune the set of dependencies.


Unstable interfaces force usersfor further compilation of code.

unstable interfaces impactcode reuse, which tends to ossify the code.


These devices do usually not o.er any low power states and constantly communicate even if systems are idle.

switching them o. further reduces energy consumption [2].


The general 3D motions of human and animals are usually of complex geometry and topology.

to reduce the parametrization distortion, a polycube is an ideal parametric domain as we demonstrated in the horse gallop model.


In our machine model, memory resident data is non-trusted but register and secure storage resident data is trusted.

to reduce security overhead, the main goal is to utilize registers and the secure storage efficiently.


In contrast, users of SmartSynth can give commands containing events, conditions, and actions without any restrictions.

smartSynth provides users with greater .exibility and control over their smartphones.


Figure 1 shows a class diagram with some extensions concerning events and their coordination.


In Atlantis, abstractions like HTML tags and XMLHttpRequest objects are implemented entirely outside the kernel.

when the Atlantis kernel services an openConnection() request, it cannot determine whether the fetch was initiated by an HTML parser upon encountering a  tag, or by an XMLHttpRequest fetch.


This implies that the E-agreement condition is not satis.ed.


If a correct algorithm were to exist for tolerating f faults among (d+1)f processes, then we can obtain a correct algorithm to tolerate a single failure among d + 1 processes, contradicting our result above.


The AIS Information Model, and especially the AMF related part, has a hierarchical structure, which needs to be re.ected in the application models too.

every relation which expresses ownership or containment between elements are modeled as packaging.


;the type-checker rejects an instantiation of a in which the bound may not hold.

if pkg has type struct IntFn, then we can call f so long as .


The tables corresponding to the entities of the E-R model described above and their primary keys (PK) are shown in Figure 12.

the field mill_type (mill type) of the tables box and roll should be a foreign key of the identically named field in the For the case study, the query numbered 12 has been chosen.


Implementations of other rewriting engines and rewriting language have been used to provide prototyping [10, 7, 20], but again, to our knowledge, they do not interact with a client written in a modern programming language.

these systems do not provide the software engineering bene.ts that our approach offers.


For example, in the statement a=b+c, a is a dependent attribute that directly uses attributes b and c. We observed that omnipresent attributes mostly tend to be independent.

we discard independent attributes in (k, w)-CC.


As suggested by the motivating example, the application may fall into failure due to its inaccurate understanding to the environment caused by uncertainty.

we should consider uncertainty in verifying selfadaptive applications.


We abstract the interface which depends on the Map-Reduce framework.

our tool has very good portability, it could adapt to most of Map-Reduce framework implementation.


This may be explained in part by the custom in computer science of learning to write programs before reading any.

literature containing programs worth reading is rather scarce.


In terms of A-FSMs and state matrices, if an A-FSM is deterministic, it is possible to search for Adaptation Cycles and Adaptation Races by looking for paths of transitions among multiple states whose active rules contain predicates that are satis.able on the same bit string.

in order to detect these faults, it is necessary to consider all propositional context variables, not just the subset relevant to the active rules of a speci.c state.


Nonetheless, large windows are better in terms of adapting to resource .uctuations1 , due to their greater smoothing e.ect.

we say that larger windows bene.t quality and robustness of streaming.


When using suspend/resume, on the other hand, we observe that the trend is for the wait times to not vary with the requested duration and for the slowdowns to exhibit a slight decreasing trend.

all requests are treated more fairly, although the overall average does increase (the shorter requests, which make up the majority, have longer wait times because they no longer skip the queue, thanks to back.lling).


let rec run () = match try Some (Queue.take queue) with Queue.Empty -> None with None -> () | Some t -> Lwt.wakeup t (); run () Thefunction yield creates a suspended thread, adds the thread to the end of the queue and returns it.

a thread waiting for an expression yield () to terminateisstopped untilresumedbythe scheduler.


Moreover, while the SystemC speci.cation allows many schedulings for a given test case, the OSCI simulator exhibits always the same scheduling.

even if an execution leads to the expected result, another execution with a different scheduling may be erroneous.


However, the collector is executed even if some of the parallel jobs have failed, which is not always desirable.

in some work.ows additional synchronization mechanisms have been implemented to guarantee that all, or a minimum percentage of tasks are completed before merging.


The constraints are extracted from (a) the system architecture and requirements (e.g, a cruising speed must be between 10 and 150 kmph); (b) user requirements for a particular scenario, and (c) soft constraints that represent testing knowledge, i.e., the veri.cation expertise which biases test generation towards interesting areas [7].

a generation of a test can be seen as a solution of a series of CSPs [9].


Note that there may be many branches, including calls and returns, along the way.)

when the trace is generated the loop will be obvious because the trace will end with a virtual branch back to its beginning.


with function symbols D d exported by other D-module, simply by renaming suitably the functions of M to .t (a part of) the exported signature of N .

we obtain an instantiation operation that we denote M[N ,.]


In contrast, the categories with less studies are security, MLT, RSVM, and testing.

it is argued that optimization, GC, and ES are evidence clusters (i.e., where there may be scope for more complete literature reviews to be undertaken), whereas security, MLT, RSVM, and testing can be regarded as gaps (i.e., where new or better primary studies are required).


Then nc = rankc(j1) - rankc(i1 -1) represents the number of suf.xes pre.xed by p and preceded by c whichisactuallythe number of su.xes pre.xed by cp.

we deduce that j2 = i2 + nc - 1=(C[c]+ rankc(i1 - 1) + 1) + (rankc(j1) - rankc(i1 - 1)) - 1= rankc(j1)+ C[c].


This was the case because on every memory operation, the tree needed to be iterated to determine if the address modi.ed affected memory graph nodes.

dDT tells us that a data structure with more ef.cient lookup is appropriate for implementing this particular set.


The .ow-insensitive algorithm used is set-constraint-based, like the Andersen-styled pointer analysis [1].

there are two stages: constraint generation and constraint resolution.


INDIGO S ARCHITECTURE Adaptability is a major concern for semantic matching systems dealing with heterogeneous data sources.

indigo was developped around three important functionalities taking into account the domain, the properties and the various ways (one-to-one, many-to-many, etc.)


Result: The system reliability is dominated by sensing reliability.

a wired system would have had similar system reliability as our wireless system.


Finally, we concluded that these properties are all satis.ed.

we believe the models have been constructed correctly.


In addition, flash memory has asymmetric read and write operation characteristics in terms of performance and energy consumption.

it is necessary to revisit various operating system policies and mechanisms, and to optimize them for flash memory-based secondary storage.


Each single individual only can de.ne what is the best for itself without taking into account interests of other individuals or the goal of the collective.

there have to be rules de.ning what the system aims at and how this can be reached by letting all individuals work together.


Had we taken steps of 500 users increase, then with 6 steps and 3 tests in the shrinking process we would end up with 2750.

a linear strategy for load testing seems to make sense.


Precise exception semantics (as in Java) requires that all code transformations preserve the program state at an exception point, and also the order in which exceptions occur.

the application of traditional optimizations must be restricted to prevent side-effect-causing instructions from moving across any exception points.


2 to be unreached by the current set of test cases as an example.

the mutant de.ned at address 0x48 cannot be killed as it does not impact the output.


MinCaml adopts the caller-save convention, so every function call is assumed to destroy the values of all registers.

we need to save the values of all registers that are live at that point, as implemented in an auxiliary function RegAlloc.g call.


Locks are volatile by nature because they only have meaning during run-time.

to operate correctly, all locks must be released aftera systemfailure.


Non-static inner classes may access the type parameters from the enclosing class and may declare their own parameters.

the complete type for such a class is Outer(l1..n).Inner(m1..k ).


During this stage, resources flow between the knowledge source and the recipient.

the first step should be the development of supportive antecedents in accordance with items in the impediment backlog and the strategic plans.


If a developer s reputation can be shown to have a positive impact on the outcome of code review, then we have evidence of the value of developer s reputation on the project outcome as a whole.

the objective of this study is to identify how an OSS developer s reputation affects the outcome of his/her code review requests.


(B:2)}..D, for example, will show that this record was produced because the A component of (A:1, B:2, C :7) at index [r1] in the input was less than or equal to the B component.

we can replay after any change that preserves this ordering information.


The reason for this line shape is that a beginner tends to drive relatively slowly and, hence, cannot make use of a fast system response time.

higher delay values up to 200 ms seem to be acceptable for unpracticed drivers.


The mixed-precision method changes only the iterative phase.

this paper evaluates the performance improvement of the iterative phase compared to a conventional double-precision implementation.


This is rational to the fact that the machine consists of many but very small clusters of cores.

we have not included any performance measurements for the hierarchical algorithms on the Magny Cours machine.


The majority of the respondents(56%) originatedfrom twoIT companies and one company in consumer electronics in the Netherlands the rest (44%) originatedfrom various companiesin theNetherlands and other countries.

it is not surprising that 80% of the respondents originated from Holland, followed by the United States (5%), India (4%), and the United Kingdom (1%).


For example, jQuery [22] exports two global symbols jQuery and $ by default and many other JavaScript libraries also often export $ as a global symbol.

if one uses another JavaScript library alongside jQuery, the jQuery.noConflict() method relinquishes the control of $ so that the other JavaScript library uses $.


(e) For each t-con.g occurring in each branch of M , Fold it against those in ..

if that fails, de.ne it as a new t-con.g and add the new de.nition in .. M will once again become a piece of automata code.


My preliminary experiments have shown that this assumption is often incorrect the faulty statements are often executed by some passed test cases.

an effective approach requires some tolerance for cases in which the faulty statement is excuted by a passed test case.


We have I(E3E2E3E1, 2) = {E2E3} because tc(E2E3) and tc(E3E2), respectively, generate instant test cases in form of [N] - [N] + [N] and [N] + [N] - [N], where right associativity only affects the calculation result of the former one.

we have our .nest-grained faults: F(E3E2E3E1) = {E2E3}  4.3 Algorithm In this section, we present a detailed pseudo code for an automatic fault localization.


Web content developers may address this checkpoint.

from the results obtained, the number of guideline failures at each priority can be established, and this data used to aid creation of a set of prioritised recommendations.


However, the relation types neither take into account Object s behaviors for equality comparison, nor support typecompatible and hybrid equality (the generated implementation uses getClass() only).

it would help solve only a subset of equals() implementation issues.


Furthermore, the mutual recursion theorem means that the code needed for a termination proof of mutually recursive methods is available.

if the code of a new subclass follows the rules, then a standard proof of its correctness would be valid.


However, only a partial swap of COI processes is possible: MPSS uses buffers on the Xeon Phi to hold data that has been transferred from the host, and these buffers cannot be swapped as they are pinned.

a COI process can run out of coprocessor memory and crash, which is especially an issue on coprocessors since their physical memory (8-16GB) is much lesser than the typical physical memory of host processors.


As in the robustness optimization mentioned above, it can be verified already during the preprocessing stage that audio watermarking does not lead to annoying artifacts.

the quality loss can be calculated for every watermarked frame and stored into the container file as metadata.


INDICATOR considers a constraint candidate as real, if a) all the violating test cases fail and at least one of the satisfying test cases passes; or b) all the test cases fail, and the error messages of the violating test cases look alike to the description of the constraint can didate.

iNDICATOR first invalidates a candidate, if some of its violating test cases pass.


and Cheek Raise are related to the risorius and the zygomaticus mainor-major respectively.

we captured a subject in facial expressions loosely based on Lip Corner Puller and Cheek Raise in Facial Action Coding System (FACS) using a high de.nition Sony HDR-SR12 video camera with 29.97 fps.


Unlike card marking, the object, boundary, and zone barriers are all conditional.

their performance depends heavily on the rate at which their slow path is taken.


Now, let v beavariablevertexin V whose outgoing arcs reach context vertices {c1 ··· cn}.

obviously, v can be diagnosed through any of the context vertices, say ci,where 1 = i = n. in our mapping, we represent each context vertex c with a binary integer variable xc; i.e., the value of xc is 1 if and only if v can be diagnosed through c. Otherwise, xc is equal to 0.


An increase of instruction-level parallelism results in an increase of register count as well as FU port count for concurrent access [9].

according to this disadvantage of VLIW architectures, the Transport Triggered Architecture (TTA) [10] processors have been developed to reduce the demand of general-purpose registers and to improve the utilization of FUs.


The example in Figure 9 shows that Object[] has two elements that heavily miss (hot), so it is included in the sequence starting from Entry.

the two hot sequences String-Char[] accessed from the array indices 0 and 7 will be placed after the Object[].


The ruc primitive uses the stubborn single-hop unicast primitive to do retransmissions.

the ruc primitive does not have to manage the details of setting up timers and doing retransmissions, but can concentrate on dealing with acknowledgements.


3.3 Instantiation of the Criteria The formalized criteria are merely templates to be used for veri.cation of any system.

when using them, a user has to instantiate them to .t each target system.


For example, while some of them might be in active use, others will not be accessed until some time in the future.

it might be possible to keep the latter type of data blocks in a compressed form to increase the available space for new data blocks.


Its main property is that, if vectors are drawn from a multidimensional Gaussian, the subvector x ' k of the k .rst components of x ' is as close as possible to x ' .

the PCA is often used to reduce the dimensionality from Rd to Rk .


The semantics of CoJava interprets a program as an optimal nondeterministic execution path, namely, a path that (1) satis.es the range conditions in the choice statements, (2) satis.es the assert-constraint statements, and (3) produces the optimal value in a designated program variable, among all execution paths that satisfy (1) and (2).

to run a CoJava program amounts to .rst .nding an optimal execution path, and then procedurally executing it.


2.1 Layout policies We anticipated somewhat early in the development of Ganeti that the actual policies for the layout of virtual machines across (pairs of) physical machines might differ based on site policies and thus decided that the actual policy should be left to external scripts, while Ganeti itself should just implement the mechanism.

we have a documented API (called the IAllocator API) for things like given cluster state X, on what pair of machines should new virtual machine with speci.cations Y be placed?.


To make the comparison consistent, wegenerate the submission schedule withasubmissionduration of554 seconds, record itintoa .leand useitthroughouttheexperiments.Thesizedistribution of eachGrepjobfor this experimentis showninTable5 andisbased onthe experimentsperformedbyZaharia et al.[24].

our scheduleis representative ofa typical workload of aproductionMapReduce cluster with a mix of many smalljobs with a single map taskperjob, and afewlargejobs with morethan100 map tasksperjob.


(iii) Removes the points that represent users that have not participated with a new location for a recent time period.

we update the new distances and derive the corresponding  Algorithm 1 Clustering ClusterData(., MinP ts) Initialize ordered list L for (.p .


At this point, the reader might be wondering why the problem could not have been solved as follows, using the original form of try: try case Expressions of Pattern 1 -> Body 1; ... Pattern n -> Body n end catch Exception 1 -> Handler 1; ...

exception m -> Handler m end The di.erence is that in this case, all the success actions Body i, as well as the pattern matching, are now within the protected part of the code.the catch...end section will handle all exceptions that may occur not only those within Expressions.


Because no complete methodologies address the concern location and comprehension problem, more development time is spent reading, locating, and comprehending source code than actually writing code [25].

a software development organization could Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


SCM systems are among the most ubiqui- tous tools used by software developers, and are the primary mecha- nism that programming teams use for storing programs and sharing work.

for most developers, integrating VSC into an SCM system provides the most natural interface to this functionality.


The recursive process of embedding Treemaps within a Treemap ends at the leaf nodes of the underlying model (see Figure 3).

for a class node, only its advise (i. e. its advised by) relations can be shown as sub-elements.


Process Pmr is not one of Pmo,.--,Pmr-~, since it enters Filters[r], and therefore succeeds in Filters[Of .... , Filters[r -1].

there are processes Pmo,---,pm._~,pm~ that enter and fail in Filters[Of,..., Filters[r -1], Filters[r], respectively.


However, people with knowledge of humancomputer interaction, group interaction, organizational issues, and possibly knowledge-based user interfaces are required as well.

the first part of the duality is the need for a diverse software development team to tackle the new breed of complex software.


In addition to the qualitative evaluation, we automatically evaluate our approach without using the feedback of potential users to give more quantitative evaluation to answer RQ1.

we compare the proposed operations with some expected ones defined manually by the different groups for several code fragments extracted from the five systems where most of them represent code smells detected using previous work [6].


When exceptions are masked, the w rules are not applicable.

masking offers a safety escape from resource limits: when a thread is masked, we always ful.ll its allocation requests, even when the current resource container has exceeded its limit.


Generally, aspect interactions can be categorized as intrinsic (those that inherently exist among concerns) or technical (those that are dependent on technology and may change over time).

these types of interactions should be encapsulated properly.


This conclusion also complements the results provided by the study reported in [13]: not only the visual difference should be well established between the representations to be sketched, but also they should minimize the amount of constraints required to sketch the object.

it is not only a matter of visual difference, but also a matter of sketching simplicity.


Radio coverage is small compared to the area covered by all nodes, so that most nodes cannot contact each other directly.

communication may be performed using several intermediate hops as in mobile ad hoc networks (MANET, [10]).


Therefore, WireCAP can be used to support middlebox-type applications.

at a high level, WireCAP provides a new packet I/O framework for commodity NICs in high-speed networks.


*) fun destroy gconsumer = fn xs => let fun next [] = NONE | next (x::xs) = SOME(x,xs) in gconsumer (next, xs) end Again,thekeyoptimisationisthat(ignoringeffects) List consumerList "' "' (destroy gconsumer) (unfoldr (next,s)) = gconsumer (next,s) . '

"' " generator consumer generator wecanagaineliminatetheintermediatelistpassedfromunfoldr todestroy,andinsteadpassthe(next,s) generatordirectlytotheconsumer,whereitcanlikelythenbeinlinedintoaloop.


For instance, Law 13 is responsible for merging advices that execute the same action at di.erent join points.

it enables us to have an advice capturing several join points.


Since the subclass is not public, the text cannot be attached to the subclass, which is not mentioned in the API documentation.

in the doc comment of CtClass, two documentation concerns are tangling: one is the behavior of defrost in general and the other is the implementation of defrost in the subclass CtClassType.


For example, the hardware may implement rollback of memory state, but rely on the programmer or compiler to retry transactions that abort, sometimes using backoff protocols to ensure that a given transaction eventually commits.

it is helpful to distinguish the memory model for TM, as the essential memory semantics that the hardware implements, from the program model, as the semantics that the programmer sees.


Broadly speaking, we have chosen to link all the mistakes (form or substance) of the learner to items of knowledge (basic), knowing that these links can be propagated (as in the exercises) bybottom transitivity to all nodes of the tree representing the ontology.

at a given item may reflect several errors, each of which provides an indication of its non control by the learner.


Moreover some of the most widely used implementations of parametric types in other programming languages, such as C++, do not apply any control to intercept this problem.

the compilation of some programs may fail to terminate, typically leading to the issuing of an out of memory error20 .


Moreover, they do expose different optimization .ags, and they likely use different optimization passes in their internals.

one of Pathscale or Intel compiler may very well work better than PGI with the technique described in the present paper, as well asin the possible future ones.Forexample they may exhibit quite different sets of con.icting .ags.


Proactive page allocation enables the kernel to allocate pages from a particular physical memory device.

at allocation time the kernel can select which memory device will be used to satisfy a request.


The bene.ts of the SMDS concept still have to be validated in practice.

alongside the development of the SMDS concept, we have been implementing a prototype of such a self-con.guration and -management system, called COMPASS (Con.guration, Organization and Management Prototype for Autonomous Systems of Systems).


This happens since the benchmarks exhibit different power characteristics for this machine due to its bigger memory size.

lSR is able to .t the training data better compared to the training data for the 8GB machine.


The data reuse theory [44] says that the array V has temporal reuse.

using the condition ~vlq3 = /:v2qa = 00, we obtain ~a = (1,0,0) T. a suitable Q is (001) 0 I 0 , 1 0 0 which, in turn, leads to a displacement vector (1,0, 0) for array U, meaning that its layout should be column-major.


The fully synchronous implementation based on time-triggered architecture [13] must be conservative, forcing the global clock to run as slow as the slowest computation and communication process.

sM is not suitable for video codec applications, which have large variations in computation and communication.


Namely, if the participants do not spend enough time on studying the given component, the percentage of the correct answers will probably decrease for that component so there is a dependency relation between these two variables.

the percentage of the correct answers can assist in estimating the time required to fully study the given component (i.e., to achieve 100 % of the correct answers), which can be used as an indicator of the e.ort required to fully understand a component 1 .


So, DMSA handles instance sharing for these specific implementations.

the deployment plans generated also contain instructions targeting shared instances.


The primary differences include: Primitive Assignments -Dalvik primitive constant assignments specify only the width of the constant (32 or 64 bits).

no distinction is made between int and .oat or between long and double.


If one message is lost, a newer one will replace it soon (and using an absolute position information, errors are avoided).

these messages must not be sent reliably and result in low overhead for sender and receivers.


According to another interviewee, the company has tried to include the innovative features in the normal feature decision making and release planning flow but this resulted in an inability to meet the tight deadlines dictated release planning as well as by the market and competitors.

only mature features are currently considered.


LGP algorithmsdi.erfromTGP algorithmsin many important characteristics, such as linear versus tree structure of the learnt program and separable blocks of code versus complete trees.

it is unlikely a crossover operator developed speci.cally forTGP willperformwell whenusing LGP.Henceitis Copyright2010ACM978-1-4503-0072-8/10/07 ...$10.00.


If a task is monitored, the truth values of its precondition and e.ect are known.

the task s satisfaction or denial is inferred through the task denial axiom (axiom (1)).


The issue is that while the Infusion Manager will stop infusion if a critical alarm occurs, the Alarms subsystem will raise an alarm for empty reservoir only if the system is infusing.

the system must start infusion before the alarm will occur and cause infusion to stop.


These policies ignore references to some of the more recently used pages.

implementations of these policies don t require VM system intervention for references to those pages.


SECURITY-SPECIFIC SECTIONS We observed that 18 of 38 publications use sections that differ from the GoF and POSA templates (see Section 2.1).

we assumed that one or more of these new sections can be security speci.c for describing software-security patterns.