Whenever di.erent parts of the data domain cannot be treated uniformly, proofs branch into case distinctions.

branching points in the control .ow (e.g., if, while, exception handlers) lead to branches in the proof.


Because the URL was edited by the remote P2PA to be 127.0.0.1:25766, the SOAP message is intercepted by our EA.

the client-side EA intercepts the SOAP call and passes it to the client-side P2PA.


The key idea is to determine if there were already speci.c queries looking for that overlap.

we scan the query log, and for each pair of tables we .nd to be joined on their primary keys, we check this pair against the discovered pairs of sibling relations.


In order to effectively analyze such differences we adopted the terminology from Software Product Line Engineering [3].

the term variation point refers to a given type of variability among NLP whereas the term variant refers to an available option to realize a given variation point.


To help meet this need, Scott and Scherer in 2001 and Scott in 2002 proposed some local-spin abortable mutual exclusion algorithms, but these algorithms have Shortcom- ings.

the algorithm by Scott and Scherer allows an aborting process to be blocked by other processes, which is unacceptable.


ap)}  Figure 6: Rule for aspect application (revised version) There is one .nal complication the combination of the two problems identi.ed above.

the items of advice applicable to methods called within the body of C.m() may also have dynamic pointcuts associated with them!


No memory operations (vector or scalar) appear in the loop body.

all vgather and load operations appear before the loop, and all vscatter and store operations appear after the loop.


The notion of AAIF is essential for reasoning implicit connections.

aAIF assists our approach; support tool displays implicit connections and assists reasoning.


Furthermore, information retrieved from static and dynamic analysis can be combined to overcome each others' deficits: E.g., for state machine extraction, code coverage is guaranteed via static analysis while the precise dynamic information can be used to search for potentially invalid transitions.

information can be exchanged between static and dynamic views.


Here we show that even with improvements to the justi.cation process to permit these optimizations, other very basic problems exist.

the oftenmentioned out-of-thin-air guarantee, as well as the necessity of preserving sequential consistency for race-free programs result in signi.cant constraints on optimization, limiting important existing techniques and imposing additional analysis costs.


All of the execution states in one group are merged.

for example, aas ({[{a},l],[{a},m],[{b},n],[{b},o],})= {[{a},l. m],[{b},n. o]}.aas is designed to maintain the correlation between a given property state and the execution states under which the property FSM is driven into that state at a given program point.


The results of a basic, uniqueidentifierbased comparison can be expressed in the same notation.


The results also show that using the sum of the criteria to rank papers was better than using a simple 5-point scale assessment.

the overall assessment was unable to distinguish between papers B and D, whereas the sum of the individual criteria made it clear that paper B outscored paper D. The main limitation of the study is the number of targets.


By the type isomorphisms of Section 2.3, dependent and binary sums and products commute with universal quanti.cation over clocks.

the functors F of Examples 1 and 2 commute with ...


yes-instances have a valid proof that is accepted by all nodes, no-instances do not have valid proofs, and at least one node detects an invalid proof.


(6), we .nd that the cost on a link up to time interval t equals the sum of the cost on that link up to time interval t - 1, and the additional cost incurred by the possible over.ow in the time interval t. This implies that, if the traf.c volume on a link during one time interval is less than the charging volume on that link up to the previous time interval, which is the maximum aggregate .ow rate on that link over t - 1 time intervals times the duration of one time interval, no additional costs will be incurred.

the traf.c volume in interval t is carried on the link for free.


It satisfies the features discussed in section 2.

a model in CAMLE consists of three views: a caste model, a collaboration model and a behaviour model.


The .nal result then corresponds to the application of the function to the object.

pfold h (buildp g c)= let (f , z)= g .h c in fz Of course, this law can be generalized in the sense of extended shortcut fusion.


Figure 3a shows that with transient-core nodes instead of transient nodes, the overhead for disk-intensive jobs relative to the job execution on only core nodes is much smaller.

sort shows a signi.cant improvement, decreasing the overhead from 40% with transient nodes to 23% with transient-core nodes, as do KMeans and ActiveHashes.


and their refinements are defined in a type-specific language.

the definition and refinements of .jak files are expressed in the Jak(arta) language, a superset of Java.


The logical operations in Figure 5 are considered to be set operations.

imme- diately after the points-to analysis, each shared-access set includes only one check routine.s = sizeof (X) ,C = O where X is the domain type of ff.


Though the final specification has not yet been completed, consensus has been reached on various issues.

the safety-critical profile will not support execution of traditional java.lang.Thread, nor of javax.realtime.RealtimeThread.


Thiemann [22] adds the notion of a CGI Session for maintaining state, and provides more sophisticated form-handling methods.

callbacks may be associated with submit buttons, with nameless representations for form inputs.


The result of combining MBT and PBT is a new testing approach in which testers get the bene.ts of using properties to generate test cases, and those of specifying the test requirements using a model of the SUT.

we have used UML models complemented with OCL constraints as starting point, so that testers do not have to deal either with the implementation details of the SUT, nor the peculiarities of a new formalism to specify the tests.


However, s2 ' is only known up to =.p -.


We made several simplifying assumptions that need to be removed in order to generalize our approach.

we have implemented the agents against our very light-weight agent platform that simpli.ed testing.


Parallel bindings Parallel arrays and tuples provide a fork-join patternofcomputation,butin some caseswewant more scheduling .exibility.

we may choose to execute some computations speculatively.


We can now state the conservativity theorem which says that if the stricti.cation of a lazy computation EL reduces (in a purged context) into a value V1, then the lazy computation reduces (in the unpurged context) to a value V2, whose stricti.cation is equivalent to V1.


LeSelect architecture extension addresses scientific resources exchange difficulties.

the idea is to provide more semantic information about basic scientific resources, i.e., programs and data.


We conclude that a delimited continuation, like an ordinary function, should be able to access and supplement its callers dynamic bindings at each call.

capturing a delimited continuation should close over the dynamic bindings within the delimiter but discard those beyond the delimiter.


We now show that it is also bene.cial for them to cooperate with their neighbors, by maintaining a non-negative balance.

each node sets its H parameter to be equal to or larger than 0.


Two sets of attributes have a completematchif one-way matches succeed in both directions.

attribute sets A and B match if the one-way match algo- rithm succeeds from both A to B and B to A.


The balls are randomly extracted with replacement.

every time we pick up a ball, we re-insert it in the urn.


In a dynamic scenario, the model can be extended by assuming (1) departure rates that depend on performance, (2) arrival rates a.ected by p, and (3) dynamics that a.ect the distribution by postulating type-dependent departures and  arrivals.

one could imagine that p would a.ect the arrival rate in di.erent directions.


Second, the partial evaluator must preserve the typing of the original program.

when presented with a correctly annotated and well-typed program, the residual program is also guaranteed to be well-typed.


We introduced glue code that invokes platform-dependent system calls to interface with the platform-independent code on our target platform.

the glue code provides a clock source implementation that provides the timing semantics of timed automata.


VeriCon simpli.es the veri.cation task by assuming that both switch and controller events are executed atomically.

when the controller executes a sequence of commands the invariant is checked before and after the whole sequence and not after individual commands.


Ld1 which obtains its value from St1, now gets it value from a store that was executed during the processing of a fault inducing request (request 1).

the value to be loaded is corrupt and the condition (step ii) evaluates to true.


An Intra-Task DVFS Technique based on Statistical Analysis of Hardware Events Hiroshi Sasaki, Yoshimichi Ikeda, Masaaki Kondo, and Hiroshi Nakamura Research Center for Advanced Science and Technology, The University of Tokyo {sasaki, ikeda, kondo, nakamura}@hal.rcast.u-tokyo.ac.jp ABSTRACT The importance and demand for various types of optimization techniques for program execution is growing rapidly.

dynamic optimization techniques are regarded as important.


Despite these bene.ts, the current version of Mercury needs a few extensions and additional evaluations.

we are currently extending our models to consider clock throttling and variable-speed fans.


In fact, out of 51 lines, 12 statements calculate tile indexes and 11 tile sizes.

45% of the lines are needed for the bookkeeping of tiles due to the lack of tile support.


For example, the difference of two types contains all the values that are contained in the .rst type but not in the second, the union of two types is formed by all the values of each type, and the intersection of, say, an arrow and a record is equivalent to (in the sense that it has the same interpretation as) the empty type.

subtyping is just set inclusion: a type is a subtype of another if the latter contains all the values that are in the former (for more details see [8]).


Speci.cally, the set of tasks that run in each logical execution slot is chosen from the intersection of all resource speci.cations of the components and the platform constraints speci.cation (as described above).

improving the speed of the machine allows better performance (because less constraints means more applicable schedules and possibly existence of a better one).


As for Lucene and Ant, we obtain their bugs and test suites from their bug tracking and version control systems following the procedure described by Dallmeier and Zimmermann [8].

we consider Lucene bugs that were reported for versions 2.0 to 3.1, and Ant bugs that were reported for versions 1.5.1 to 1.9.2.


Aspect programming addresses some of the concerns we listed in the Introduction.

aspect weaving allows to change the meaning of methods.


An adversary in the real world is likely to have information about which scenarios are more realistic than others.

users communication patterns are not totally random.


newtype fm*a = FreeT {unFreeT :: m (Free f a (fm*a)) } data Free f a x = ReturnF a | OpF (f x) instance Functor f .

functor (Free f a) where fmap (ReturnF a) = ReturnF a fmap f (OpF x) = OpF (fmap f x) When the monad is Id there is no additional structure so: f* a = f* Id a f* a is the .xpoint of Free f a.


Therefore, we discuss the mapping between CBFM and Core Components.

the mapping is discussed based on the Core Component example illustrated in Figure 6.


In doing so, we apply results of cognitive science and educational psychology in general and cognitive load theory in particular to ensure an instructional design that balances the cognitive load in order to optimize learning.

we focus on programming patterns .the concrete representations of schemas in program and algorithm design.


A value is a tree of the special form .k n. {||} , of ten written just k. For instance, the phone number .. .¯ pc; dotted arrows represent splitting or concatenating trees.

the result of applying l1/ to c|pc (the tree formed by dropping the immediate children of c whose names are not in pc) must be a tree whose top-level labels are in the set pa; similarly, the result of applying l2 / to cpc must be in pa. the lenses l1 and l2 are allowed to change the sets of names in the trees they are given, but each must map from its own part of pc to its own part of pa. Conversely, in the putback direction, l1 must map from pa to pc and l2 from pa to pc.


However, we believe that our approach breaks new ground by the integration of MAC into use case, class, and sequence diagrams, and by providing design-time.

security assurance in this paper, we report on our research on the incorporation of MAC into UML use case, class, and sequence diagrams, for the definition of clearances and classifications for relevant UML elements, which augments our efforts on including role-based access control into UML [9].


FASTTRACK uses an adaptive representation for tracking the read history of each variable that is tuned to optimize the common case of totally-ordered reads, while still retaining the full precision of vector clocks when necessary.

if the last read to a variable happens after all preceding reads, then FASTTRACK records only the epoch of this last read, which is suf.cient to precisely detect whether a subsequent access to that variable con.icts with any preceding read in the entire program history.


pathS no longer satis.able, then Achilles can drop path Ci from the current state, but also all path predicates path Cj such that di.erentFrom [j][i][a] = FALSE .

if pathCi no longer holds, due to the additional checks on .eld a, then all path predicates pathCj can be dropped, because they cannot have any additional values for .eld a.


It speci.es for each functional unit the sequence of instructions that are currently under execution in that unit but not yet completed.

the time-pro.le gives just that most recent part of a partial schedule that may still in.uence the issue time slot of the next instruction to be scheduled.


Unlike reliability testing, claims obtained by our method are quanti.cations for a series of reliability queries (a set of curves) which are likely to be more conservative but are yielded with absolute con.dence.

in reliability testing, reliability claims are accompanied by a con.dence level based on an appropriate statistical analysis.


In contrast to previous work [12] that focuses on synthesizing algorithms such as sorting or bit-manipulation routines, this paper focuses on synthesizing object-oriented programs that involve method sequences.

we accept a user-speci.ed intent in the form of a desired object state and automatically synthesize a method sequence that produces the desired object state.


Namely, when two or more people decompose the same legacy application using the same set of features, the resulting feature modules are always different.

the module for feature F in one decomposition can be quite different from the module for F in another decomposition.


Modern hardware design and veri.cation languages also provide events as object attributes.

e shares many features with our proposal.


Otherwise, we distinguish two cases : (a) IfS C is .nite, then for all constructors c in this set we consider the context Qc Q ' c = EX(c( ,..., ),ctx) Then, trap handlers (P1,e1); ...;(Pt,et) are scanned left-to-right, stopping at the smallest i, such that the intersection Q ' c nPi is not empty.

we .nd the trap handler where to jump to when the head constructor of x1 is c, in order to extend the case list as follows : L= L case c: (exit ei) It is possible that ei does not exist (when Q ' c is empty).


CONCLUSIONS assumes that improved throughput can be obtained by having This paper has described the design of reusable component concurrent access to the data, for example, if the data is stored on interconnection patterns in client/server systems.


In practice, to detect a fixed point (or equilibrium), we need to use some acceptance criteria and at the end of each trial evaluate an individual element or a selected subset or the whole object space to decide whether to repeat the trial or to halt.

the evaluation of the object space can take place at different levels of granularity depending upon the problem domain.


Second, the model may not accept sequences of events that are possible in the application because the history does not contain the particular sequence of events.

the model may partly underapproximate the application s behavior.


The distributions of the node averages are shown in the .gure.

each point in the .gure is the average of the node averages while error bars indicate the 90% range of the node averages with the lower bars corresponding to the 5th percentile of node averages, and the upper bars to the 95th percentile.


However, the SCD branch has an empty body.

the fact that match does not get updated induces the strict dependence between match and the predicate at L: from match = 2, we can infer args[0][pos]= b .


We .nd that although the oblivious method allows base code designers to ignore aspect design, it leaves important abstractions implicit in program details and does not decouple design decisions in the other direction.

the freedom afforded to base code designers comes at considerable cost to aspect designers, who are thwarted by a lack of constraints on the code they need to advise.


Another issue here arises with increments once a safe design has been reached.

as additional increments are carried out, what size should these increments be, and how can it be guaranteed that these increments do not jeopardise the safety of the overall system.


We then analyzed the distribution of the mutants for each set.

for the traditional mutation operators, we examine whether mutation testing of BCEL generates numbers of mutants that are similar to those generated for procedural programs.


Here, li is the running time of phase i and A ij is the estimated run time of qj when it runs in the query mix of phase i.

a ij is the estimated time for a query instance of type Qj to execute, from start to .nish, if it executessolelyinthismix .Sincephase i runs onlyfor time li, qj will complete only afraction li ofits workin thisphase.


Doing so, we document explicitly the relevant information that motivates the composition rules and extension points used.

figure 2a, Figure 2b, and Figure 2c contain such documentation.


Introduction The continuous advances in adaptive middleware architectures have been changing the way distributed systems are being developed.

several approaches have been proposed for building software that can dynamically adapt to its environment.


A user can customize parsing by leveraging SDF s support for grammar composition.

it is possible to provide additional productions for a nonterminal of the base language.


The next step after addressing these issues is design of methodology for improving TDD by leveraging traceability information.

we need to study: -in-process guides that identify requirements remaining to be implemented, -in-process identification of inconsistencies between requirements and unit tests, -traceability-aided automated test generation, and -generation of change-impact information when refactoring (tools such as Chianti [17] might prove helpful here).


Present the statistics of the features for requirements analysis.

the votes on the features help Internetware application providers identify the common features and the special ones, as a basis for feature prioritization.


Typing The primary goal of the TALFT type system is to ensure that welltyped programs exhibit fail-safe behavior in the presence of transient faults.

well-typed programs must guarantee that a memory-mapped output device can never read a corrupt value and make it visible to a user.


We now use Lemma A.1 and the rules of Work-Stealing Algorithm to prove that lemma is preserved.

we will show either k' = 0 or the property holds.


PROBLEMS IN LogLCP In this section we give examples of graph properties and graph problems that admit locally checkable proofs of size O(log n) but for which there is no locally checkable proof of size o(log n).

these problems are in LogLCP but not in any lower level of the LCP hierarchy.


For all experiments, each node is initialized with a link tuple for each of its neighbors.

nodes have a priori knowledge of their local links and use MINCOST and PATHVECTOR to discover longer network paths.


This is so because there is still a clear delimitation between the matching and handler code, both in terms of the programming language used and the lifecycle of the entities involved.

the action handles is still a separate code, implemented using a different language.


The second characteristic of a monolithic browser is that, from the web page s perspective, all of the browser components are either black box or grey box.

the HTML/CSS parser, layout engine, and renderer are all black boxes the application has no way to monitor or directly in.uence the operation of these components.


The semantic security condition will require that at all times, the attacker s knowledge includes all possible input strategies for high-security places.

all possible input strategies for high-security places are consistent with the attacker s observations.


Each EMi and SFi is converted from text (such as very high ) to a numerical value by looking up the cost driver elements of An and M in tables provided as part of the definition of COCOMO6.

5 seven possible ratings exist ( extra low, very low, low, nominal, high, very high, and extra high ); however, technically, extra low and extra high are excluded options for some attributes, meaning that an alternative such as very low or very high must be used instead.


This score can be expressed as a fraction of the PDG: |N | S = 1 - |PDG| 7.4 Improved Strategies A cause transition at a blamed location b can impact the failure only in two ways: If the state at b is infected, it is caused by the defect.

the defect d is in the backward slice of b or b .


An important set of runtime tactics are those to improve the fault tolerance of the system.

the system takes certain actions to detect faults and errors in the running system, prevent faults from impacting the integrity of the system, and recovering gracefully from faults if they do occur.


This hierarchy can serve as a class repository by generating a parser that converts source code to instances of the mirrored classes.

visitors written for the INTERPRETER pattern are no different than other clients--they can be retargeted to use reflection as well.


Recent results on the SSA form open promising directions for the design of new register allocation heuristics for embedded systems and especially for embedded compilation.

heuristics based on tree scan with two separated phases one for spilling, then one for coloring/coalescing  seem good candidates for designing memory-friendly,fast, and competitive register allocators.


In this paper, we make the following contributions:  We .rst propose to use Neville s algorithm [8] to predict the storage cache space required by competing applications such that everyapplication s SLO is satis.ed and the overall I/O latency is minimized.

this .rst partitioning considers all the storage server caches as one big monolithic cache space and allocates it across applications.


It can be seen that our approach cuts dynamic instructionsand packing/unpacking operationsofSLPonaverage by 14.5% and 43.5%, respectively.

we observe that Global achieves signi.cant packing/unpacking instruction reductions for most benchmarks tested, which shows the advantage of our global strategy of extracting superword reuses.


While sorting randomly ordered data is a well-studied problem which has produced a plethora of useful results over the last five decades such as Quicksort, Merge Sort, and Heap Sort (see [9] for a summary), the importance of sorting almost sorted data quickly has just emerged over the last decade.

the vast quantities of almost sorted log-based data appearing in data centers has generated this interest.


Jobs are not required to follow the same processing route.

different jobs may consist of different tasks.


Prashant R. Chandra Intel Corporation prashant.chandra@intel.com With the hardware support described above, every memory access instruction in IXP is non-blocking and is associated with an event signal.

when a memory access instruction is issued, later instructions can continue to run while the memory access is in flight, until a wait instruction (for the associated signal) blocks the execution of the thread.


The knowledge of common work processes that allows architects to find relevant diagrams also helps them recontextualize those slides with respect to the project.

the architects can use steps in the process and the resulting documentation to deduce what state the project is in.


Thus a front-end adaption was necessary.

daikon analysis starts instrumenting the source code of the application in order to monitor values of variables during execution; while, the input of this phase is the simulation result in form of execution traces.


#4: End-with-backward-branch considers an instruction sequence as a repeating cyclic execution path if the sequence goes back to the head at a backward branch.

this checks repeating cyclic execution path only at backward branches.


In [19], the authors introduce synthesis methods to add di.erent levels of fault-tolerance to centralized and distributed models.

they show that in the context of distributed modcovery, where each phase ensures satisfaction of a certain predicate during recovery, to real-time models is investigated in [9,11].


The computational cost of maintaining sketches and providing recommendations is also compatible with current commercial devices.

adding a new contact to the contact list of a node A requires updating sk(A) (algorithm UPDATE(··· ) in Figure 2) and has cost (O(m)).


(Any gaps in this would also be weaknesses encountered during debugging, hence worth .xing within DWARF).

python s main distinction is not its machine model but its language semantics, and this can be isolated within our Python interpreter, where it is invisible to other code in the process Python becomes an implementation detail that can be hidden inside a function s implementation.


Rn if and only if W is balanced2,and I W - n 1 11T I< 1where thenorm is maximum singular value norm [12].

convergence is satis.ed if 1 is an eigenvalue of W and it is also the eigenvalue with greatest magnitude [11].


Kernels of each application are chained together according to the computation logic, they may have dependencies since data .ows from one kernel to another.

ti is modeled as a kernel graph that contains zi connected kernels {ti 1, t i 2 ,..., t i zi }.


d)ifitis both(d, d1,f,f1)-speculatively stabilizing and (d, d2,f, f2)-speculatively stabilizing.

still for the sake of simplicity, we say in the following that a distributed protocol p is d-speculatively stabilizing for speci.cation spec if there exists a daemon d .ud such = that p is (ud,d,f, f )-speculatively stabilizing for speci.cation spec.a d-speculatively stabilizing distributed protocol is self-stabilizing under the unfair distributed daemon (and hence always guarantees convergence) but is optimized for a given subclass of executions described by d.  Examples.


The high-level loop in the BMT Test function tests the database with a series of commands.

the inner loop of BMT Test calls the Lookup, Delete, and Create functions in that order.


To date, most allocators use a heuristic to solve the problem.

vertices are removed one-by-one from the interference graph and after each vertex is removed, the interference graph is tested for k-colorability using a heuristic.


The changes are transformed to model operations, which are transferred to the composite model and executed.

only the Set, Add and Remove operations can lead to changes of the models.


Additionally, the noninterference theory for FJifP needs to be strengthened to provide guarantees about data safety in the presence of noninterference [20].

if we only declassify data to Alice security level, then an observer below Alice should not be able to interfere.


However, they leave it to the system administrator to determine a deployment architecture and con.guration settings that are best suited for local needs.

most private cloud management frameworks implement a control plane for managing various cloud services such as monitoring, messaging, allocation of compute and storage resources and VM image management (see Fig.


µ(an :&: Sig) inlineAnnotated = [propAnn (.M trans inline)]Ø M We close this section with a small example that shows how to generically annotate a tree with unique labels so as to track changes made by subsequent transformations.

we shall annotate each node with a list of type [Int ] that describes its access path, i.e.


Then, the job of the type system is to guarantee that our operational semantics respects our interpretation of types.

for a function, we verify that, whenever the function body starts with a marked value inhabitingin the input type and performs operations as speci.ed by the body expression, it results in a marked value that conforms to the declared result type (if it terminates).


CHEAT CONTROLLED PROTOCOL 4.1 Time Cheating In the example in Figure 1, if P2 was a malicious player, he could intentionally alter the value of d1 21, of CM1 21, or tag CM1 21 referring to the previous update message such that CM1 21 would be delivered for processing before the command message CM1 11 from P1, from which he benefits unfair situation.

through time cheating a player can obtain more time to react to a game world event than an honest player.


The biggest change was in the Interpreter class, which we instrumented to intercept all relevant events.

we instrumented all opcodes where object properties are accessed (read, store and delete), or objects are created.


First, the variability present within the Core Components approach which is currently only speci.ed in a textual speci.cation, has been formalized utilizing the notion of CBFM.

all potential change operations that may be applied to the Core Component model have been incorporated into the Change Variability Model.


The model captures many of the essential features of peerassisted VoD.

it shows that when a service provider is operating in the surplus mode, it can increase the quality of the videos without incurring signi.cant additional server bandwidth costs (using peerassisted distribution).


Left-shrinking guarantees that the new translation schema for the do-notation will agree with the already existing translation, in case there are no recursive bindings.

considering the basic translation schema given above, the leftshrinking law guarantees that the following two expressions will be equivalent:  mdo x .


As variable names can be easily modi.ed for malicious code theft, these lines are all eliminated in the abstracted code.

text/token-based methods can be disturbed by the ordering of variables and the names of variables, eliminating these declarations helps produce more accurate similarity estimation.


In order to solve this interoperability problem, our proposal is to base the service de.nition in open standards.

theOpenVirtualizationFormat(OVF)[17] isa standard recentlypublishedbythe DistributedManagement Task Force(DMTF)1 that describes a speci.cation on how to package and distribute software to be run in virtual machines.


3.2 Spaces Spaces can have two or more dimensions and serve as a runtime environment for spatial constructs.

spaces are responsible for maintaining and diffusing data generated by spatial constructs.


This required integration of pieces of software developed at different points in time, and in different parts of the organization.

we needed a compositional approach, allowing to 'arbitrarily' combine existing software assets.


Synchronization methods can be used to synchronize concurrent calls.

the execution of a synchronization method suspends the calling thread prior to executing the method until all concurrent methods that are issued by the calling thread are retired.


After specifying the propagation templates for various operations on structure types, the structure and propagation templates are driven as input to a CASE tool that generates the appropriate code (currently classes in C++) that implements the run-time core of structure servers.

the CASE tool parses the structure template and generates a class for each structure type.


2006), where structural recursions such as folds and catamorphisms are used to structure programs and systematically manipulate programs.

our approach is in.uenced by the many attempts at de.ning structural recursions for speci.c graphs, such as graphs represented by trees with speci.c pointers (Hamana 2009; Dal Zilio et al.


Agents have the opportunity to unilaterally decommit contracts.

they can forego a previous contract for another (superior) o.er.


From the analysis of the data we can draw the following conclusions: From the correlation tests we can conclude that there is a strong linear dependency between the precision and the general understandability of the diagrams on the one hand and the architectural understandability on the other hand.

we can conclude that any measures that increase the general understandability and precision of architectural models directly help to improve the architectural understandability.


Harbulot and Gurd implemented just the first type of Loops sometimes contain operations that can be executed in a loop (one-exit-node, one-successor-node), because it has the most parallel manner via a multitasking environment or multiprocessing potential for aspectization functionality.

it can handle before, after, and around advice, and it can provide context exposure.


In this view, we intend to exploit paradigms and models of the state of art games and upgrade them in order to make them suited to deliver educational value.

our idea is to enhance existing game concepts rather than designing educational exercises with a game aspect (e.g.


RT and NHRT Testing There are several challenges when reusing existing class libraries with an RTSJ implementation.

with respect to validation of our NHRT Safe List, RTSJ introduces new memory areas and new types of threads.


In terms of whether the number of versions of each system analyzed was a determining factor, HSQLDB had the fewest number of versions analyzed and Tyrant the same number of versions as Velocity.

the number of versions is not a particularly strong reflection of the number of refactorings either.


When an ultra-widely distributed .le data transfer technology, a .le fragmentation technology and an encryption technology are used, then quite di.erent characteristics from a point of cipher strength arise.

the combination of the following technologies such as the spatial random scrambling of all data .le, the random fragmentation of the data .le, the corresponding encryption and duplication for each fragmented .le by using stream cipher, and in addition, the corresponding noti.cation of the history data composed of the encryption key code sequence which we call metadata in addition can e.ectively realize the prompt data backup system economically only when they are combined at the same time [3, 4, 1].


It is never necessary to roll back to the check- pointed state.

exceptions raised by reversible instruc- tions are precise.


Change packages do provide a form of project consistency, but do not have the expressive power of our consistency model.

clearCase has no notion of a consistent subproject, which prevents or re- stricts the use of the flexible coordination mechanisms similar to those provided by Coven.


Variability in the tree navigation technique.

the client should be able to select node access orders other than left-to-right, depth-first, total traversals.


ing that MOPS uses signi.cant hand-coded optimizations external to the core push-down model checker.

for improved performance MOPS .rst slices the program to extract the securityrelevant portion in a pre-pass, resulting in a much smaller program to be checked by the push-down implementation, whereas our implementation simply generates and solves constraints for the entire program.


Currently, we assume that such recon.gurations are applicationdriven.

application end-points provide format handlers either directly or in response to a request for such handlers from an application component that does not recognize the new format and perhaps, requires data to be translated to an older version.


5.2 Utility Function Whenever a con.ict is detected, either inside a pro.le (intrapro.le con.ict) or among various pro.les (inter-pro.le con.ict), user s goals, such as maximisation of the quality of the display for an image processing application, or directionality of data synchronisation for a calendaring application, must be taken into account.

users should be allowed to in.uence the con.ict resolution process operated by the middleware as they are the only ones who know what their goals are at the moment and how different outcomes are valued.


However, our Algorithms 1 and 2 cannot handle this scenario.

when StatAnalyzer(B9, null) is invoked, StatAnalyzer identi.es the pre-target as Push.After DynAnalyzer successfully covers this pre-target (Line 4 of Algorithm 2), Stat Analyzer invokes DynAnalyzer(B9, IntStack.Push).However, DynAnalyzer still cannot cover B9, since Push is invoked only once in the suggested sequence.


However, the PDL joinpoint model, unlike AspectJ s, is static.

joinpoints in PDL are static program entities such as classes, .elds, methods, and instructions in the byte-code.


Instead, we constructed state space schemas that precisely captured the modular decomposition of the corresponding implementation.

principal speci.cation constructs had names identical to the implementation construct that they described, thus facilitating a manual correspondence mapping.


3.2.1 PnPAP definition and analysis PnPAP is an API on top of a device's operating system, through which applications can access many kinds of networks over various protocols with basically only one method call.

pnPAP provides an abstraction layer for networked applications, hiding the complexity of various underlying P2P protocols including for example JXTA, SIP and Jabber.


But we could also have the type Iterable&List, in which case the left is a supertype of the right and therefore redundant.


Autonomic Pervasive Applications Driven by Abstract Specifications Ozan GünalpLevent Gürgen CEA-LETI CEA-LETI Minatec CampusMinatec Campus Grenoble France Grenoble France ozan.gunalp@cea.fr levent.gurgen@cea.fr  ABSTRACT Pervasive application architectures present stringent requirements that make their development especially hard.

they need to be flexible in order to cope with dynamism in different forms (e.g.


For simplicity, only intraprocedural execution is considered.

we assume the entire run is the execution of one function.


We opt for simplicity and build the global explorer on a small set of common data structures and APIs.

we model the basic concurrency unit of a system as a thread.


What this means is that this regret bound is very likely to dwarf the number of bugs that can be found in real-world software after a very small number of epochs.

even though we have the right kind of guarantee from EXP3.S.1, the guarantee quickly becomes meaningless in practical terms.


the problem is not determining such a constant (e.g., as in [33,8]), but its very existence.


Overview This section describes the operation of Poli-C in the context of a simple example.

we have added a statement called require to C. The require statement is parameterized by a list of resource kinds and policies, which we describe below.


Pipeline Pattern The Pipeline pattern schedules the tasks according to a pipelining strategy.

the tasks are executed in a .xed order, i.e.


Our main contributions are as follows: We .nd that commonly used anti-disassembly methods are not effective, even against a weak adversary, and require signi.cant overhead.

two instruction sequences usually resynchronize after a few instructions because of the Kruskal Count [32].


The ability to establish interpretation and reason on higher-level and global-level situations is mandatory, whilst fuzzy system models and granular component data are prerequisite to specify the probability, abstraction and situation.

multi-level information retrieval forms the input of the reasoning; the pattern of fuzzy future situation, meta-model granularity information and relevant coordination rules and protocols are the keys to formulize the sustainable action [14].


Speci.cally, it is satis.ed by every schema mapping M=(S,T, S) such that (a) S is a set of s-t tgds, or (b) S is an SO tgd, or (c) S is the union of a set of s-t tgds with a set of target tgds and egds, and has terminating chase.

this hypothesis is satis.ed by every schema mapping speci.ed by Sst .St, where Sst is a set of s-t tgds and St is the union of a weakly acyclic set of target tgds with a set of target egds [9].


6.3 Verifying Purity With our extensions, Joe-E makes it easy to reason about purity.

in a Joe-E program, if all of the parameters to a method (including the implicit this parameter) are immutable, then the method is pure.


The aim of this paper is to present the methodological challenges of applying ethnography to a case study aimed at characterizing an agile project team's belief system and its origins, sources, and impacts on the team's software development practices [15].

we focus on the social interactions, communications, and relationships that arise as an intrinsic part of adopting agile software development practices.


Figure 4 improves our understanding of the variation in job sizes.

figure 4 shows results using two di.erent delay-tolerant workloads: both with the same average job size, but di.erent variation.


3.2.2 Mappings As EvoFM is more abstract than the FM it does not contain all feature model elements.

evoFM does not specify the properties of a feature (mandatory/optional) or additional feature model elements like cross-tree constraints.


The already fairly good locality of new objects, most of which are of proli.c types, delivered by the memory allocator used with the copying GC (which places all new small objects contiguously in memory), is perhaps the reason for such a behavior.

since we co-allocate objects many of which probably would have been close to each other anyway.


For example, there is a known7 atomicity violation in the version of Java s ConcurrentLinkedQueue we tested (JDK 6, update 20), involving concurrent calls to poll() and remove(o).

it is 6 The error in the phyl source is that each worker thread s call to globalResults.addAll(results) is not atomic.


In earlier work [14] we have shown that independent parallel sections can be tuned separately, which cuts the initial search space into smaller pieces.

a parameterized pattern offers context for each of its tuning parameters.


The programs are clustered on each of the metrics individually.

one clustering is produced for lines per method, one for methods per class, etc.


Pickling works surprisingly well in practice.

pickles are usually pretty compact (in the order of few to few ten kilobytes), even when they contain computed components with signi.cant amounts of code in their closure.


Note that we assume annotations to be closed.

fl :: Ct x .t is interpreted as fl :: .a¯.Ct x .t where a¯= fv(Ct x,t).


In the research presented here, we take the approach of using cheaper but less accurate methods to extract semantic information.

we are investigating how well information retrieval methods can be used to extract relevant semantic information from software.


(P3, T3.1) At the end of each experiment, we asked the participants if they could understand listeners by looking at the class diagram.

we asked one developer if the class diagram helped him understand that a Drawing has a list of DrawingChangeListeners,he said: Not directly.


In such an unfortunate case, we will resort to multi-level tracing which instruments a subset of the functions but yet permit the trace to be replayed.

we will utilize multi-level approach to recompile and re-run the program.


All but the baseline are not on the convex hull.


The users may also get information about nearby museums compatible with the user s preferences or hobbies.

the users may get special last-minute offers, based on the fact that they can be very close to the museum.


To avoid overestimating the contribution of missed prefetching requests, we should consider both the prefetching miss rate and the total cache miss rate.

we prefer a binding type that generates a high prefetching miss rate and relative low total cache miss rate.


Checkpoints and Continuations Instead of Nested Transactions Eric Koskinen Department of Computer Science Brown University Providence, RI 02912 ejk@cs.brown.edu ABSTRACT We present a mechanism for partially aborting transactions through the use of data structure checkpoints and control.ow continuations.

we show that boosted transactions[9] already havebuilt-in restorationpoints and a.ord a simple, e.cient implementation.


Intuitively, a higher ICPI indicates a smaller change propagation influence.

a higher ICPI indicates that a smaller number of components will be modified in each commit (which directly links to ANMCC).


In our eCITY+ tool, we adapted their secondary model to highlight the evolution of components via animation.

we only follow their approach to calculate the representation of the software structure at the initial point in time.


However, the technique is much more general than this, and can help whenever one wishes to transfer VM state across a bottleneck network.

vM synthesis can signi.cantly speed up the upload and launch of a custom VM on commercial cloud services across a WAN.


PLEX had a number of language features that corrected shortcomings in the earlier AKE exchange.

some of the properties of the AXE/PLEX system were viewed as mandatory.


Although middleware has been used successfully in DRE systems [5, 30, 31], key challenges must be overcome before it can be applied broadly to support the QoS needs of PLA-based DRE systems.

r&D is needed to help resolve the tension between (1) the generality of standards-based middleware platforms, which bene.t from reusable architectures designed to satisfy a broad range of application requirements, and (2) applicationspeci.c product variants, which bene.t from highly-optimized, custom middleware implementations.


We are currently working to further extend and re.ne the different framework services to better support more complex coupling and runtime scenarios.

support for concurrent execution of multiple (possible parallel) components on high end capability-class computers.


BACKGROUND AND RELATED WORK My research area is software engineering for service-oriented systems.

my focus is on techniques for specifying and analyzing dynamic service compositions.


Our PGA library is extended to adapt to supercomputers of hybrid architecture (e.g., Stampede cluster with mixed CPU, Intel Many Integrated Core (MIC), and GPU architecture).

the asynchronous migration strategy is enhanced and a runtime PGA parameter tuning function is developed for the library to be adaptive to dramatically increased heterogeneity among PGA processes on such supercomputers in order to achieve desirable scalability and reliability.


Note that bid prices based on $/hpm reflect service quality as well as load.

the center may increase its profit by improving service quality to deliver better throughput at a given load level.


The basic idea is that the checkpoint is rather a process history containing all successful operations, and at restart, CPES work.ows start from the very beginning but skip all operations that succeeded earlier.

instead of reading the checkpoint data at the beginning of the restart, rebuilding the state of the work.ow and then continuing from that point, the actors in the CPES work.ows continuously check their actual task against the checkpoint and skip the task if it is found to be already done.


Therefore, faults that do not appear in the cvs logs cannot be considered.

the set of FP modules used in this study is not complete.


It is important to note that these sensor elements share the common characteristics of not requiring substantial energy to support their operation.

this energy dissipation is less than that of the node platform itself.


For any pair of executions E and E ' of this code pair from initial state s0 to .nal states s and s ', it must be the case that min cost in s equals min cost in s '.

letting Fdet denote bridge predicate min cost == min cost, it asserts: E!


We have measured this parameter while increasing the size of the simulation model (as said up to 1024 simulation objects) and while adopting two di.erent deploy strategies of the simulation objects across the cluster.

in one strategy we hosted the simulation ob jects on di.erent simulation kernels that are deployed as much as possible on the same machine.


First observations indicate that in particular for small systems with few computational resources a significant amount of research will be necessary to elaborate efficiently working solutions.

this includes the three interrelated areas: 1. determination and exchange of (discrete or other) configuration space models at runtime,  2. efficient computation of space intersections in order to determine matchings, and  3. the construction support for utility functions at development time.


The size of the applications was used, together with other parameters characterizing the product and the process, as an input for the estimation tool.

the SEER/SEM [26] tool was used to estimate both the expected size in LOCs and the expected development effort for each application.


We can observe that the revenue for both groups of ISPs follows .B : .C = |CS| : |BS|.

both types of ISPs evenly share revenue when |BS | = |CS |.


However, programming phase facilitation is mainly focused on generating a code skeleton using a target programming language, which is very often object-oriented.

while the design phase happens in the component world, the programming phase occurs in the object-oriented world.


A conflict closure is a transitive closure of facts with respect to mutual exclusion.

it is a minimal collection of facts such that each fact conflicts with at least one other fact in the closure but none outside of it.


The shift widths of both references are the same (2), but the global ranges of the loop nests are di.erent.

the ranges for the non-distributed dimension are di.erent.


Also, they do not just keep the minimum but also the maximum coordinates of IDs inserted to this node and also the minimum and the maximum timestamp.

this describes the coverage area that each node overlaps and also the time range during which this area is covered.


Incorporating our approach in the runtime (i) reduces the overheads, (ii) simplifies the implementation, and (iii) removes bytecode editing from the critical fetch class file-load-execute path.

the experience gained with this first prototype was very valuable during the design and implementation of the KVM-based prototype, where the isolation model is implemented entirely in the runtime.


This engendered a surprising (to me) modification to the language.

we had defined a region to be a list of index ranges enclosed in brackets, as in the declaration region R = [1..n, 1..n]; and required that to control the execution of a statement the name appear in brackets at the start of the line, as in [R] A := ... ; It seemed obvious to us as computer scientists that when a region was specified literally on a statement that it should have double brackets, as in [[1..n, 1..n]] A := ... ; Users were mystified why this should be and were not persuaded by the explanation.


In Oemga, there seems no strict separation between programs and proofs.

proofs need to be constructed at run-time, and thus the serious problem with proof construction at run-time as is mentioned in Section 1 does occur in Oemga.


The join point visibility feature maps join point computations to actual join point instances.

each potential join point in the granularity is classi.ed as either visible or invisible.


CONCLUSION For the .rst time, our work examines a broad set of quantum computing benchmarks and motivates static and dynamic compilation problems.

we .nd that generating code for arbitrary rotations presents signi.cant challenges.


Condition 2: As forbidden pair of edges cannot be realized simultaneously, we need to make sure that the paths do not use them.

for every pair of forbidden pair of edges e1 and e2, if one of the paths uses e1, the other path should not use e2.


n.8 Attaining .n in (31) for some .xed n requires, in general, knowledge of the network topology matrix F. For n = 1, the minimization in (31) yields h N i=1 .1 = - hN µi , (32) 2 µ i=1 i which can be computed via macroscopic network information.

due to the structure of F, NN NNN 11 111 22 µi = fii,µi = fii- fii , NN NNN i=1 i=1 i=1 i=1 i=1 i.e., the numerator and the denominator of (32) can be obtained via the average and squared-average number of connections in the network.


It is the same as wrsRec except that it allocates cycles based on each task s statistical demand and sets CPU speed correspondingly.

the parameter Ciact is set to the statistical demand (as opposed to the worst-case demand in wrsRec) when the ith task releases a job.


This means that the algorithm in [11] is optimal for all three variations.


A general-purpose operating system prefetching policyshoulddeliverhigh average-caseperformancefor common application workloads.

many applications only exhibit fairly short sequential access streams or evencompletely randomaccesspatterns.


In contrast to this negative result, and as the main result of this paper, we show that for asymmetric congestion games with linear and polynomial delay functions, the convergence time of a-Nash dynamics to an approximate optimal solution is polynomial in the number of players, with approximation ratio that is arbitrarily close to the price of anarchy of the game.

we show this polynomial convergence under the minimal liveness assumption that each player gets at least one chance to move in every T steps.


To evaluate the performance of these operations, we conducted microbenchmarks on a desktop computer with Intel dual core 3GHz running Linux 3.2.24, as well as on a smartphone with a 1GHz CPU running Android 2.3.

we measure the number of query buckets that the three systems can process per second.


We have identi.ed di.erent spectral methods to perform subscription clustering and adapted them to work in distributed settings.

we have developed mechanisms to perform linear and non-linear dimensionality reduction as well as k-means clustering using the hierarchical overlay organization.


Technically, the BPC framework allows the programmer to provide a callback object to manage event selection.

modifying the selection strategy does not entail recompiling the framework.


The requirements and challenges for smartphone-based in-street detection techniques differ signi.cantly across scenarios.

in-street detection can assume different meanings depending on the environment.


Brainy extends those prior works by 1) using machine learning to automatically construct more accurate models, instead of relying on hand-construction, and 2) incorporating hardware performance counters into the analysis, thus providing greater accuracy.

unlike Chameleon, Brainy is not restricted to languages that have managed runtime features such as garbage collection.


The cost for a subst call should also be put against the number of times a cyclic data structure is expected to be garbage-collected.

each time a cyclic structure survives a garbage collection (of the whole heap), the relative cost of one additional scan of that structure (i.e., the cost of an initial subst call) will drop towards zero.


Recall that, the SLOs are indicative of the maximum degradation tolerable in average I/O latencies, with respect to their I/O latencies in fair share of cache space in I/O servers at the .rst level and storage servers at the second level.

if IO Latfair is the I/O latency of an application Appi when allocated a fair share of cache in both levels of storage caches, then the assured I/O latency (even in the presence of other applications), IO Latassured for that application would be IO Latassured = SLOAppi × IO Latfair .


Though the call graph is incomplete in our dynamic encoding approach, the maxID is always the maximum possible encoding value at runtime.

the possible encoding value at runtime is within the range [0, maxID].


Q.8 t(G, L, Q, A) We then de.ne capacity CBB as follows.

capacity CBB of Byzantine Broadcast in network G is de.ned as the supremum over the throughput of all algorithms A that solve the BB problem and all values of L.CBB(G) = sup T(G, L, A).


The reference implementation is expressed at a slightly higher level of abstraction than the optimized implementation.

the reference implementation expresses homomorphism computations as native operations in the CertiCrypt language, whereas these are expanded aslowerleveloperations over the underlying algebraicgroupsin the optimizedprotocolimplementation.


Conversely, the statements that are executed by a high per- centage of the passed test cases are more likely to be correct than those that are executed by a small percentage of passed test cases, and thus are presented more brightly to express the level of confidence in their correctness.

the brightness of a statement, s, is computed by the following equation: 5In color space models, a pigment with zero brightness ap-pears as black.


So, the constrained payoffs on other strategy pro.les are not both better than the ones on (s1,i* ,s2,j* ) for both players.

(s1,i* ,s2,j* ) is the Pareto optimal solution for our fuzzily constrained game.


The next reuse vector (NRV)ofa data block is the difference between the next use of the block (speci.ed in terms of a block iteration vector) and It.

if the data block in question is next used by iteration II, then the corresponding NRV INote that IAs an example, can be calculated as In= I- It.


In particular, for chain constraints,it is also possible to specify unwanted chains.

it is possible to specify that the messages in the chain are exchanged following any ordering di.erent from the one represented by the chain itself.


Because these aspects crosscut the dominant problem decomposition, they are usually dif.cult to express cleanly using standard languages and structuring techniques.

functional (core concern) and non-functional (crosscutting concerns) codes are mixed which makes maintenance, evolution and adaptation dif.cult.


The linear-algebraic fact needed in the proof of the following lemma is stated and proved as a separate technical lemma in Appendix A. Lemma 5.

for all large enough integers m, s with 2 < s<m +1, and for all su.ciently large f, there exists a linear MDS code C over GF(2f ) of blocklength N = ms +1 , s(s-1) relative distance d =1- , and dimension (1-d)N +1, m(m+1) with the property that there exists a Hamming ball of radius tN, where t =1 - s/(m + 1), containing at least (m + 1) codewords of C. C is not (tN, m)-list decodable.


The registerClass method, described earlier, is responsible for updating the external method registry to re.ect the loading of a new class.

any mappings from the new class s name in the registry are removed, and the mapped-to external method descriptors have their counts decremented.


(iii) The shortest path from a node of GA to a node of G ' B has length at least 3r - 1.

for su.ciently large r, the local neighbourhood of any node is a subset of W .


It is known that 802.11b modems can operate at four different data rates, namely 1, 2, 5.5 and 11 Mbps, by changing both modulation format and channel encoding schemes.

1Mbps is achieved by employing DBPSK modulation, 2Mbps is achieved using DQPSK, while the other higher bit rates are achieved by using Complementary Code Keying (CCK) modulation which is a form of bi-orthogonal signaling.


The tool that imposes constraints on data and variables should be tailored to the data it annotates.

different program components may require different type systems.


we want to be able to de.ne control structures and not just individual control signals like in SCADE.

unlike SCADE, we want our component model to be truly both control-driven and data-driven.


Proof: Consider anytriple t = (s, w, n).

choose the parameter ct for the triple t to be equal to the product of the parameters cp of all paths p in G that start at s, end at n and go through w. ct = cp (13) p such that t is a subsequence of p. To show that Path re.nes Triple with respect to the post expectation PostE stated in the theorem, we need to show that WP(Triple, PostE ) = WP(Path, PostE ).


The list decoding radius for list size growing polynomially in the blocklength approaches the Johnson radius.

for every d, there exist linear codes of relative distance d that have a super-polynomial number of codewords in some Hamming ball of relative radius close to J(d).


To address this issue, we investigated the use of a Genetic Algorithm (GA) to search for a suitable configuration of SVMs to be used for inter-release fault prediction.

we report on an assessment of the method on five software systems.


5.1 Growing a T -tree Given a test suite T and a FSM M, we .rst construct a hierarchical structure, called a T -tree for M. In a T -tree, each node represents a FSM that is being constructed.

a node contains a table describing the transition and output functions of the FSM represented at that node.


Software engineering is also interested by defining precisely the different steps of an appropriate software development life cycle.

a model-based approach is assumed to be a development method that is explicitly based on models.


The system relies on a predicate language (presented in Section 4) speci.cally designed for studying schema and query com patibility issues when schemas evolve.

predicates allow characterizing in a precise manner nodes subject to evolution.


Cyclone: A memory-safe dialect of C In this section, we provide a high-level overview of memory management in Cyclone.

we discuss how traditional regions are used in Cyclone and identify some shortcomings that are alleviated in our language.


.,such that a ' also involves components {Bi}i.I .

a new recovery interaction can only in volve components that interact in the original model.


Information about this section is sent to the kernel via a set of system calls so that the kernel can maintain a global view of the DTs it hosts.

the kernel uses a system-wide ID, which we refer to as the gtid, to identify the DT for scheduling purposes.


CONCLUSIONS AND FUTURE WORK This paper addresses the problem of design space explo- ration of system architectures where both performance and power consumption are relevant issues.

a methodology to reduce simulation time dramatically while preserving acceptable design accuracy has been proposed and experimentally assessed by considering the design of the memory subsystem of a real-world processor.


Sutherland modeled inferencesby considering the set of all possible worlds W;i.e., con.gurations of the system, and introduced the notion of an information function that represents a certain view of the system.

all the information about a given world w .W is provided as the outputs of information functions that operate on w. Sutherland describes information .ows from function v1 : W. X to v2 : W. Y in a world w .W as follows.


The debugger shouldwork with everything and be always available, even if this meanssacri.cing functionality.

this implies that any solution that requires recompiling the entire program and libraries isruled out.


Architectural decisions made early in the design process are critical to successful development of a distributed system.

selecting an appropriate architectural style has a significant impact on system quality attributes (e.g., latency, scalability, reliability, etc.).


We propose a method that can quickly optimize the trade-off between speedup and various overheads, with consideration of uncertain execution scales.

the new solution can optimize the checkpoint intervals for different levels and optimize the number of cores simultaneously.


We can clearly observe that more the number of actions per workflow, the less the overall per action overhead.

the overhead required to prepare and launch the first action is greater than the overhead required to transition between actions.


Note that retries do not attempt to provide transactional semantics.

a retry will re-execute the portion of the try block that had already run before the exception was thrown, which may lead to undesirable side-effects, as discussed in Section 5.


Hence the name of x-collectors we gave to the (·)x transformations.

the second component of the translation of .abstractions can be simply seen as the collector for the bound variable hidden in the .-term by .-expansion.


For the purpose of this paper, we consider a twophase self-healing process whereby a failure is .rst detected and then dealt with by means of an appropriate corrective action.

we focus on the second phase, and assume the availability of a failure-detection mechanism that, in addition to signaling a failure, provides some contextual information regarding the failure.


As an integral part of the future Cisco s test scheduling system for validating video conferencing products, we introduce a search-based multi-objective test prioritization technique, considering multiple cost and effectiveness measures.

our multi-objective optimization setup includes the minimization of execution cost (e.g., time), and the maximization of number of prioritized test cases, feature pairwise coverage and fault detection capability.


The contrastive corpora is a set of documents containing domain-generic terminology.

we have considered the Penn Treebank corpus, which collects articles from the Wall Street Journal.


Also in Section 2 we detailed how our approach can be instantiated in the Axis2 framework.

we can obtain the information for the service id and the interface id straight from the framework.


Thus, similarly to a virtual method, a virtual class may be overridden in a subclass of its enclosing class.

trait ECore { [open] trait Expr[t] case class Num(n :Int) extends Expr[Int] } trait EEval requires (ECore with EEval) { trait Expr[t] { def eval :t } case class Num(n :Int) extends Expr[Int] def eval = n } } [close] class Deployment extends ECore with EEval Figure 7: Pseudo-code pretending Scala supports virtual classes a virtual class VC is a virtual member of another class M (i.e., VC is nested in M), so that VC may be overridden in a subclass M of M. This rede.nes the meaning of VC in every member of M (including the members inherited from M).


Note that even with languages that do not support composition abstraction, the whole body of the document denotes a composition.

the concept of composition still prevails, although not allowing composition nesting.


A further goal is to require very little in the way of mathematical background, and to strive for concise and comprehensible descriptions of programming languages, following Plotkin [39].

we should avoid (explicit) use of category theory, as that might make our language descriptions signi.cantly less accessible to many potential users.


Reentrant interrupts are those that directly or indirectly preempt themselves.

a reentrant interrupt may have multiple invocations on the stack at the same time.


Where relative ordering of accesses to different loca- tions is important, loads, stores, and atomic update instructions may specify additional ordering restrictions.

the IA-64 sup- ports acquire/release ordering semantics [5] with optional acquire se- mantics on loads, release semantics on stores, and acquire or release on atomic updates; it also offers a memory fence instruction.


For an edge e(v1,v2), the effective tie break function (ETBF) caused by selecting e in the path cover, ETBF(e), is the sum of MWP({IE(v1)-e}) and MWP({IE(v2)-e}.


We propose a quality-aware model to explicitly describe the complex feature dependencies by specifying dependencies among architectural components.

we are adding another layer of description specifying the impact of feature dependencies on the architectural level.


ProcessM () monitorProcess a b ma establishes unidirectional process monitoring.

process a will be noti.ed if process b terminates.


Simplifying annotations In many cases the dynamic and static speci.cations turn out to bevery similar.Fortunately, thereisa relatively simple processto derive the static speci.cation from the dynamic, and vice versa.

deriving static from dynamic We give a syntactic opening function, [P ]C , which opens all the abstract predicate families in P on the object this at type C. def [a(this,x)]C = aC (this,x) def [a(y, x)]C = a(y, x) where y = this def = [aD(x)]C aD(x) def [pr(x)]C = pr(x) def [false]C = false def [P opQ]C = [P ]C op [Q]C where op ::= * |.| -* def [.x.


CASE STUDY To establish the workability of the approach, and investigate issues that may arise in its application, we refactored a number of APIs and their implementations that form part of the Concern Manipulation Environment(CME) [8].

we have applied our approach to two APIs called CIT and CAT the Concern Information Tool and Concern Assembly Tool.


Two thresholds on active connections, named underloaded (UT) and overloaded (OT) respectively, are defined to determine when nodes are in low, normal or high load.

a node is considered overloaded when N > OT and LI - LO > 0 .


Second, the order in which partial traversals are performed can be changed during execution.

as points traverse the tree, we can use their traversal history as a predictor of their remaining traversal patterns, and group similar points together.


The paper concludes with a discussion of related work, and possible directions for future investigation.

we indicate how the results of this paper could be used in a refactoring tool, which gives automatic assistance in factor- ing out aspects in legacy code.


We show that composition of several such weavings is however not compositional as it does not preserve semantics.

weavings must consider that other weavings have already been applied.


It does not enable the detection of new kernels, but it provides useful information for the parallelization of the loop nest.

it indicates that the values of the array entries ic(ii), which are determined by the induction variable len, must be post-processed after the parallel execution of doii in order to preserve the sequential semantics.


CONCLUSION We believe that FSV techniques, such as model checking, have considerable potential for .nding bugs in, or verifying correctness properties of, parallel programs.

we are concerned with programs that carry out large scale computations using MPI.


To validate our .ndings we will use the source code of the Android api since it is open source and a data set of Java stack traces from Android application crashes.

we would like to check whether the possibly thrown unchecked exceptions that we will .nd from the api methods there also exist in the stack traces from the application crashes.


Our results allow us to hope that the considerable gaps between the abstract model and real life can be bridged by algorithmic solutions.

we believe that the following problems are important to solve.


The y-axis denotes the percentage change between consecutive values of the metric.

if a metric changes from y1 to y2 between metric computation points t and t +1,we plot the value (y2-y1) × 100 at t +1.


The linker identi.es such computations and addresses by using the relocation information generated by the compiler.

the relocation information identi.es all computed and stored addresses.


A single set statement can contain multiple declarations, which are evaluated sequentially.

set idl : Ti =el, id2 : T2 = e2 ..... idn : Tn = e, in S is equivalent to set idl : T1 = el in set id2 : T2 = e2 in set.., in setidn : Tn = en in S Likewise, use idl : Ti, id2 : T2 ..... idm : TrainS is equivalent to use idl : T1 in use id2 : T2 in use ...in use idm : Tm in S 3.


Af.nepredictor: Thispredictorpredicts the new value as an af.nefunction of aquantity(e.g.,time)thatis sharedbyboth the mobile node and the PRISM server, with the previous valuebeing the constant termin the af.nefunction.

newV alue = a* time+previousValue, assuming that time is the domain of the function.


For the other .ve vulnerabilities, no solution could be found after 500 iterations.

for con.rmNew-User1, con.rmNewUser2 and my headlines, the search was not able to go beyond a particularly hard branch.


First, as mentioned in the introduction, the set of arrow and arrow loop laws is not strong enough to capture stream computations.

the commutativity law shown in Figure 4 establishes a non-interference property for concurrent computations  effects are still allowed, but this law guarantees that concurrent effects cannot interfere with each other.


Dijkstra stressed that the coordinate system was to be set up automatically by the programming language, not the concrete program (and hence not the programmer).

program organization should be promoted by the programming language, and not left to the wisdom of the programmer.


The restricted CFG is .nally used to drive the hybrid analysis step.

concolic based analysis [20] is used to completely explore the portion of the program that is represented in the restricted CFG, thus avoiding waste of time and resources with the exploration of unnecessary paths.


Roughly, for each quanti.er occurring in te we need to generate one fresh type name.

instead of transforming e itself, we simply wrap it with some expression that introduces the necessary names at the boundary, by induction on the type te.


Therefore, on Intel architectures with RTM [17], the most likely reason for a constant failure of this transaction is a capacity over.ow of the hardware reads bu.er.

the transaction metadata cannot .t in the L1 cache of the processor.


Statistical tests Pairs under comparison Rank Sum (a) Rank Sum (b) p-level 2*1 sided exact p Italy MUTS-MUTS(a)Spain(b) 349,50 1480,50 0,3638 0,3830 Italy MUTS MUTEGS (a)-Spain (b) 148,50 1645,50 0,01413 0,0152 Italy MUTEGS MUTEGS (a)-Spain (b) 126,00 1585,00 0,0105 0,0115 Questionnaire QA (a) Questionnaire QB (b) 598,00 677,00 0,2068 - The second and the third row confirm the findings of the experiment run in Italy: the background of pair s components affects the knowledge built.

the closer the curriculum of both the designers is to scientific profile (like MUTS and Spanish students) the greater knowledge the designers build.


Distributed Grouped Aggregation We studied the distributed grouped aggregation in the DryadLINQ CTP using PageRank with real data.

we investigated the programming interface and performance of the three distributed grouped aggregation approaches in the DryadLINQ, which included the Hash Partition, Hierarchical Aggregation and Aggregation Tree.


Therefore, we attempt to decrease the number of task levels by reducing those of services.

only some levels are considered in a service, while the others are ignored.


Our current implementation differentiates pointer accesses from non-pointer accesses based on the read/write values.

we ignore memory accesses when the involved values are clearly out of the range of stack, heap, global data region, or 0.


An important observation is that all links that are statical ly embedded in a web page can be considered safe with respect to XSS attacks.

the attacker cannot directly use static links to encode sensitive user data.


Poisson arrivals [30, 36]: The number of edge bu.ers, which has been denoted as J in this paper, is su.ciently large to ensure that the superposition of their output processes is reasonably modeled as a Poisson process.

it is assumed that headers arrive at the scheduler bu.er according to a Poisson process with rate J .


When the labeled set gets su.ciently large for the regularization to be e.ective, both TV and Manifold can approach the accuracy of Combine as the size of the unlabeled set gets larger (e.g., > 80%).

these regularization methods do have an excellent prediction accuracy close to being perfect.


Unlike related work, the servers in our system do not need to communicate with each single client individually.

we can control request rates of clients even before a connection to a server is established, leading to a signi.cant reduction in the required server-side resources.


Firstly, we note that several design-oriented notations for dynamically reconfigurable systems adopt a separation of concerns perspective, where the modeling of the aspects related to the reconfiguration is kept separate from the modeling of the normal system operation.

this is achieved by defining one or more entities (separate from the entities that model the normal operation) that model both the occurrence of events that trigger the reconfiguration and the corresponding reconfiguration activities.


The creation of Fast Fourier Transform (FFT) [6] made it possible for a variety of applications based on DFT computing because it significantly increased the speed of DFT computation.

the DFT is widely employed in signal processing and related fields to analyze the frequencies contained in a sampled signal.


The results show no statistically signi.cant difference.

the overhead incurred by tracking I/O requests is not noticeable.


Unparsed Patterns: Easy User-Extensibility of Program Manipulation Tools Nic Volanschi mygcc nic.volanschi@free.fr  Abstract Pattern matching in concrete syntax is very useful in program manipulation tools.

user-de.ned extensions to such tools are written much easier using concrete syntax patterns.


However, we have observed that our technique is robust to sampling in both our combinatorial analysis and empirical observations.

figure 7 shows that approximately 100 datapoints with 10 bits of metadata provides high reliability of recovery of a 32-bit provenance mark.


Based on this library, which possesses rich, well-structured and mathematicallybased semantics, we demonstrate how the concepts therein can enable a sophisticated concept-aware design for a broad range of scienti.c generic libraries.

we show that concepts can enable the description and application of property-based, libraryde.ned, optimizations.


To describe the proof returned by PEC we ll make use of a modi.ed step relation, .

t. , which essentially steps over any program points not in .. t the PEC simulation relation .. .. combines the sequence t of regular .


Similarly, 98% of the dead objects responsible for the seventeen major live-size reductions in jack are long-lived.


We rely on several relations between levels and types to ascertain various invariants.

a type t is higher than d, written d < t, if the outer level of the type is at least d.d is a lower bound of the outer level(s) of t. Figure 7 de.nes this relation.


Mutant interpretation and output comparison are delegated to the node processors, making each node processor responsible for a portion of the total number of mutants.

the host processor distributes mutants to each node processor and the node processors interpret mutants for each test case.


As APnM integrates the representation model and runtime model of workflows, the skeleton plus token dimensions are enough to identify the corresponding terms in Petri nets (viz., work items, tasks and activities).

work items and tasks can be mapped to the skeleton dimension approximately, and activities mapped to the token dimension.


Figure 6b contrasts this with the fraction of .elds that are per-class immutable.

figure 6b provides a static view, whereas the view of Figure 6a is dynamic.


Similarly, ucould be re i interpreted as if i shared and all other nodes knew that she did.


If the lock this is not held, the atomicity cmpd means that interleaved actions of concurrent threads may affect the behavior and correctness of addTwo, even though there are no race-conditions.

if a concurrent thread also adds entries to the list, then addTwo will not achieve its intended behavior of adding its arguments to the list consecutively.


In Figure 7 we analyze how additional tra.c .owing on the REDS overlay a.ects the performance of the four protocols we consider.


(Recall that V denotes scheduler bu.er size in this paper).

our approximation for Ps, as given by (6), deteriorates as V is increased because interarrival times can interact in the scheduler bu.er over a longer timescale than if V were small and increase the e.ect long term correlation has on bu.er dynamics.


We found that 2 of the 3 factors were indeed related to reusability.

the reusability of components could be predicted on the basis of component authors' prior work and the documentation provided about components.


Thus, e.ectively the shu.ing step is skipped altogether and monitoring is resumed.

when thread migrations are not expected to yield any bene.t, they will not be performed.


Our experimental results show that these techniques and optimizations are effective.

technique (1) is effective in reducing working memory at compilation time.


Regarding interoperability among ADLs, we are investigating on how to fully automatize it.

currently in DUALLY a set of semantic links must be established between each ADL and the A0 pivot metamodel.


2.2 Limited scope In AspectJ, the within/withincode pointcut enables to applyan extension into a limited scope.

a combination of call and withincode pointcuts enables to execute an adviceinthemiddleof amethodbody.Thispartialextensionof a method body is a unique feature of AOP.


This paper shows that code size expansion can be significantly reduced by incorporating a few code reduction heuristics in the modulo scheduler.

the following heuristics are very effective: Minimize the length of the lifetimes to reduce the amount of MVE.


Each component Pi has a failure detector with all the safety properties of Oki × S resticted to Pi.

all quorum outputs are contained within Pi.The sum of ki s is at most k. Moreover, at least one component Pj also satis.es all liveness properties of Okj × S. Next we further weaken .k by allowing dynamic splitting of components during the run.


Research Issues and Future Directions Currently, we have implemented an ANTLR-based parser for A2BL, and we have tested several reinforcement learning algorithms for use in A2BL agents.

we have tested Q-Learning and Sarsa algorithms for single-goal agents and are working to design a general arbitration algorithm, that is, to develop the theory of modular reinforcement learning.


In the case of concurrent programs, the two processes act symmetrically with respect to each other.

portions of each are interleaved with portions of the other.


states, the connector queues service requests on the request queue.

clients can send requests to the service regardless of its state, because the connector will queue service requests if necessary.


However, specifying non-trivial properties in LTL, as well as in other temporal logics, is often considered difficult even for experts and virtually impossible for novices [1].

the challenge increases when expressing non-trivial properties which are relevant only to a subset of the states of a system.


A test criterion is a rule or collection of rules that impose test requirements on a set of test cases.

the criterion describes the test requirements in a complete and unambiguous manner.


Fortunately, these costs can be amortized across batches of requests.

when load is high the BASE library on which we build bundles together requests and executes agreement once per bundle rather than once per request.


To the best of our knowledge, all existing algorithms use the degenerate case where k =1 and the mutator count is either 0 or 8, in which case the count is simply a .ag that indicates whether a pointer to the object has been stored behind the wavefront.

immediately after a pointer to an object is stored behind the wavefront, the mutator count is set to a value that cannot be decremented.


4.4 Weak intruders An aspect is a weak intruder (de.nition 6) if states of a con.guration with a current base program instruction (i.e., ib) are always reachable states.

a weak intruder aspect may produce unreachable states during advice execution but always returns to reachable states when it returns to the base program.


UPER according to the Size of Striping Group Unlike data partitions, however, our scheme does not stripe log blocks across different flash chips.

an updated page in a data partition is stored in the log partition of the same flash chip.


A CyberOrgs implementation of such a system could geographically organize weather forecasting computations and the resources available to them.

eCash may be made available to a hierarchy of geographic regions to acquire resources to carry out computations necessary for assessing weather related threats.


Teamwork software (such as BITE [6] or CogniTAO [1]) automates sharing of information and the use of social choice protocols.

it allows synchronous joint selection of controllers for execution.


But, initial requirements making use of these techniques are expressed in a global way which makes it difficult to adopt an architectural or design technique based on the separation of concerns (including coordination constraints).

in coordination environments, the adoption of a coordination language requires the separation of the specification of the coordination behavior from the functional one.


Suppose G only contains variables introduced by the TFix rule.


Limitation While (Y) is very convenient and captures a large class of search heuristics, not all heuristics can be expressed in this way.

consider the random reordering of branches, muddle :: (MonadRandom m, MonadProlog m) .


In the countdown example, this could correspond to one site i which has seen a large number of events being told to subtract di from its count while site j is asked to add di to its count.

the slack in this case is used to even out the counts.


MOTIVATIONS Component-based modeling is a modeling method that receives more and more attention.

timed systems are often modeled this way.


We then incorporate this new model into the merge by describing how it overlaps with each of the models in Figures 2(a) and 2(b).

we map Shooting in the helper model to Shooting in Figure 2(a), and similarly, map Flash Shooting and Normal Shooting to the corresponding states in Figure 2(b).


For macro remeval, the scope is defined as the file where the macro is selected plus all files that include it, until an #undef for this macro, if it exists.

subsequent definitions for the same macro after its #undef are not removed.


for a subset of mutants, we continually selected k test cases from the test pool until the test suite composed of all the selected test cases is able to kill all the mutants in the subset.


In fact, to compute v it is necessary to compute z ', which in turn depends on z .

even with the introduction of the circularity, the computation of the .nal value depends on the computation of the second value computed by the mbuildp g c. When the consumer is also an effectful function, it is possible to state two other laws, similar to Laws 4.6 and 4.7, respectively, but that deal with fusion of effectful functions.


it proves to be rather unfortunate that we .rst specialize the convolution step and only after completing this task turn towards the convergence check.


denote the recursive results at self-join iterations 1,2,3,...,n, respectively, which are combined to produce the final result.

s1 = {result of join S0.c2 = B.c1}, S2 = {result of join S1.c2 = B.c1}, and so on.


The differences are due to the slight differences in the stride profiles they collected.

the naïve-loop method will generate stride profiles for loads inside a loop whose loop nest is executed only once, while the edge-check method will not.


In this work, we propose an approach that exploits the properties of this class of codes in order to solve some of the problems related to crosstalk faults and to the synthesis of TSC functional units.

we provide a weight selection strategy to .nd a code that is capable to detect the most likely bidirectional errors and all the unidirectional ones, while presenting a limited degradation of the code ef.ciency with respect to the case of the mostly used error detecting codes for VLSI SC circuits.


The rules de.ning this evaluation relation are straightforward, with some notable subtleties on how labels are handled.

we adopt the invariant that the label on the resulting value v is at least as secret as the program counter (pc label(v)).


BPEL defines an interoperable integration model that facilitates the expansion of automated process integration in both intra- and inter-corporate environments.

the current version of BPEL claims that links will support data flow in the future version, in addition to expressing synchronization dependencies [8].


This demo targets designers and implementers of programming languages which are expressible as a dispatching problem.


We verified this by asking (different) participants from PUC-Rio to project concerns into Health Watcher artefacts this time.

individuals from PUC-Rio projected concerns into MobileMedia and achieved outstanding results (Section 4.3).


Thus, we have implemented a smoothing scheme which tracks immediate increases in Tisample , but only gradually responds to decreases.

we optimistically assume that reductions are transient and improvements persist.


3.3 Code maturity vs. branching Once the most reusable actions are identi.ed, the challenge is making sure that they are protected and promoted to a higher level in the hierarchy of modular overriding.

moving actions vertically from the project level to shared and ultimately to the framework level.


Finally, rules have been included to guarantee that no unnecessary partial or full communication is created.

these rules handle the opportunities for communication reuse and guarantee that the DP only returns mandatory changes to the scheduling state.


If ¬(w .v), ¬(v .w) and v .= w (recall constraint (15)), then the read and the write may happen in parallel.

v and w are not ordered, and thus v may execute before w in some execution but w may precede v in the other.


Nonetheless, recall that UnLoc embraces a conservative approach by using a low similarity threshold" while declaring a landmark.

the signature of the landmark should be very dissimilar with other signatures to qualify as a landmark.


Flapjax events may, however, represent arbitrary actions.

they can represent events much more complex than those exposed by the DOM.


But all this goes through very smoothly, given what we already know.

for Choice 1, i.e., for f :: [T1] .LT1 f (x :y ) =L (JUST (x,fy )) f [] =L NOTHING and thus t1 =[T1] and t2 = LT1, we clearly still want that p :: [T1] .MAYBE (T1, [T1]) and q :: LT1 .MAYBE (T1,LT1) are listpsi and unL, respectively.


The business process entails the interaction of the essential aspects listed above.

an activity is executed by actors by using some artefacts.


In reporting code size results we compare the total code size over all functions relative to the fully optimal result.

a result ratio of one is the best possible result and larger ratios represent a code size increase.


We present an extended semantics that models preemption.

our design models handling of interrupts with priorities in the Windows and Linux kernels ([15, 27, 25, 3, 24]) and borrows ideas for atomic handler execution from software transactions [10, 23, 5], a concurrency primitive for atomicity that disallows interleaved computation while ensuring fairness (we return to software transactions in the related works in Section 7).


We have extended our de.nition to signatures that include functors, but only for the positive tight subtyping relation on signatures.

for T n V to be de.ned, we require that the functor arguments be equivalent.


The scheduler schedules operations along the critical path first so that communication scheduling assigns communications betweenthose operations to routes early, providing them with preferential allocation of interconnect resources and, if necessary, functionalunits for performing copy operations.

operations are scheduled in operation order, rather than cycle order.


Troll added the set-like notation with curly braces, where Roll required building multisets by using the @ (union) operator.

this has made speci.cation of the empty collection easier, as you can write {} instead of, for example, 0#0.


Figure 5a shows that the average wait time has positive correlation with Twaitlmt and Tshort .

twaitlmt has more signi.cant in.uence and appears to be a straightforward tuning knob for desired responsiveness.


Finally, rule Sub-Range enables variant subtyping: the parameterized ¯ type c behaves covariantly with respect to changes to the type values U ¯ and contravariantly for changes to the type values S¯.

the type c is a supertype ¯ ¯ ¯¯ of c when the ranges S'-U' contain the respective ¯ ranges S¯ -U, as indicated by lower lower bounds ( S¯' <: S¯) and higher upper bounds ( ¯ U').


The programmer must guarantee that open nesting contexts are partially ordered.

if an open action on object o1 invokes an open action on object o2, then an open action on o2 should never invoke an open action on o1.


The only mutual exclusion region that is abortdeferred is the Atomic interface used by interrupt handlers.

protected object and monitor operations are not abort-deferred regions.


(0, 1) it is a sketch with stretch f(E) and E-slack.

instead of specifying E ahead of time (as in the slack constructions) we need a single sketch that works simultaneously for every E. It is easy to see that when f is O(log 1 ), gracefully degrading sketches provide the desired average and worst-case stretch bounds (this was implicit in Chan et al.


Views generalize RaceFree-Java by allowing developers to specify the locking policy for a set of related .elds and methods, not just for one .eld at a time as in the RaceFreeJava case.

views allow developers to explicitly express, in one place, the state and methods protected by each lock.


The technique we propose is based upon comparison checking [14, 15] which leverages the availability of two versions of the program, the sequential one and the parallelized one, to detect faults.

the two versions are executed on the same input and the dynamic data dependences exercised by the two versions are compared to identify differences that result from introduction of data dependence faults.


Our approach proposes to generate test inputs for a database program considering the full interaction between the tested database and the program.

it o.ers a conceptually clean modeling that generalizes the simpli.ed model of a program used in software testing, to account for the particularities of database programs: A database program computes the result of a mathematical function over the data it receives as input while it may perform at the same time frequent reads and writes into the independent database.


One design decision greatly simpli.ed the Nucleus: following a design used in recent micro-kernels [11, 14], no Nucleus function ever blocks.

every Nucleus function performs a .nite (and usually small) amount of work and then returns.


Because the code for all disjuncts in tracematches is generated in a strongly typed way, the generated code uses those primitive types directly.

it does not box the values into objects.


We also need to test the feasibility of bytecode evolution.

we need to see that evolution of unrestricted bytecode can be driven by the compatible crossover operator.


Related Works  Although our goal is to provide data integration solution in scientific workflows in (semi) automatic way, our approach attempts to solve a different problem than typical data-integration systems in scientific applications [1, 26, 20].

we want to construct data transformations that can take valid data under one schema, and convert it to valid data under another schema, while these approaches focuses on combining source data expressed in heterogeneous local schema into an integrated view under a global schema.


This result constitutes the basis for the formal veri.cation of the recent algorithms and implementations of the ProB system, because it allows to prove properties of the CSCFG and the algorithms designed to traverse it.

the MEB and CEB analyses have been implemented and integrated in ProB as a debugging and program specialization tool.


Performance measurement of SW latencies on local and distributed SW platforms hasn t yet been completely solved, which is the research problem of this paper.

gPS-based time synchronization and performance of the proof-of-concept has been concentrated on.


In such a case, the remaining .le coverage corresponds to 66% (i.e., 2/3*100).

losing B only the knowledge of File 2 is lost.


Given two formula domains DX and DY , then the pseudoproduct operator (*) forms a new domain DX*Y = DX * DY whose models can be uniquely decomposed into a model of DX and a model of DY .

dX*Y represents all the possible pairs of models.


In fact, they rely on the presence of at least one test case that is passed by the buggy program under analysis.

if the program fails on each generated test, these automated debugging techniques cannot be used.