Therefore, we are facing a challenge, in our industrial context, to minimize the test suite for testing a product, whereas at the same time achieving high fault detection capability and functionality coverage.

the current practice of reducing the number of test cases is manual and not systematic, which often decreases the functionality coverage and fault detection capability in addition to being time consuming as we observed in our previous work [4].


Many authors have proposed approaches to formally analyze and verify feature models [2, 15, 20, 21, 24, 26].

so far no approaches have been proposed to formally verify decision models.


Many researchers and practitioners have proposed models for managing the knowledge of organizations, and practical steps to be followed in the KM strategy implementation [Gourova 2010].

the first issue is to be aware of the knowledge status of the organization: What it knows and needs to know in order to implement its business goals?


Moreover, data races are not always problematic; programs often exhibit so-called benign races.

data race detection tools are easy to use, requiring no direct input from the programmer.


RELATED WORK There exists a large body of research on knowledge transfer, newcomer integration in organizations, and information needs in software engineering maintenance tasks.

to the best of our knowledge, there is no other study addressing the issue of software developers who are not new to an organization and who join an ongoing project.


Dealing with contradictions amongst dependencies Context-aware dependencies imply that multiple dependencies may coexist with each other.

the semantics of these dependencies may contradict each other and in such cases one adaptation dependency must be selected.


Hence, the user data will be fetched in two round trips of database.

the most efficient way would have been a single bulk load of all the attributes of the user from the database and then reuse of information in the rest of the modules.


It was also important that a variety of XS types (XML Schema types [10]) is used and that both typed and untyped XML data are exercised.

the most important aspect was to obtain XQueries that should be used as part of SQL queries targeting generated XML data.


This approach reduces the runtime overhead on pro.ling signi.cantly.

it is not suitable for analysis tasks that have state dependencies such as cache simulation and branch prediction simulation.


Code coverage is usually used as a quality metric of software development to measure how thoroughly test programs exercise with the system under test.

it is also useful to understand how many parameters an experimental system exposes in a speci.c network experiment since the number of lines, functions, and branches covered by test programs re.ect the number of di.erent inputs (i.e., parameters) injected into the system under test with the support of ns-3.


From Table 1 1, we can see that TAOIIOP protocol is about 250% faster than the Simple protocol and about 26% better than the distributed proxy components.

tAOIIOP is about 38% slower than the pure CORBA test using TAO.


Super-linear speedup is predicted and measured in both jacobi and life but only the former had actual super-linear speedup.

these benchmarks consist mainly of DOALL loops, allowing unrolling to linearly increase the amount ofILP.unstruct also bene.ts from unrolling and serial optimizations,but its loops areDOACROSS, limiting unrolling seffects and limiting scalability.For theremaining benchmarks, aes, fpppp, and sha, unrolling was ineffective as the parallelized regions were functions rather than loops.


The primary advantage of RELWS is that it can adapt to changes that may arise.

it does incur the most overhead of the three polices due to its use of the bounded buffer and the stealing overhead when the buffer is empty.


For example, the Locale application automatically adjusts mobile phone behavior based on location [18].

most current location-aware applications are restricted to Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


For 64-93% of bugs they could identify a cause in the metrics.

there was no single best predictor for any system nor any .le.


Moreover, the tool support is much more mature, simplifying the use of partial evaluation as a con.guration tool.

specialization modules do not o.er automatic generation of guards, and it is not possible to specify complex specialization contexts with aliasing such as the one required for the arithmetic interpreter.


Furthermore, eliminating change early in the process means being unresponsive to business conditions [11].

if the instability is not an issue, this assumption can still hold on.


Nearly 60% of inte- grations occur while the original instruction is still active.

fewer than 20% of integrated results are simulta- neously shared by more than three instructions.


The questionnaire included 33, mostly close-ended questions.

open-ended and weighted questions were also included in the questionnaire.


When the function is applied, the effect is exercised.

at that point, there is no contract in force that would restrict the effect.


"x"=a] does not terminate for a input (s, t )where a t = void and b = {}.

such a non-terminating Beanbag program often involves some counter-intuitive constraints (e.g., the example constraint is universally invalid) and is rarely encountered in practice.


Most of the functions are intended for use only by the kernel, not by applications.

applications may call AllocObject and AllocVector directly.


Of course, for a static data set and a constant query rate there is no great problem .guring out the number of clusters needed to satisfy a target latency, and from there to calculate the number of machines in each cluster needed to satisfy the overall throughput.

neither the data set nor the query rate remain constant for most real applications, and the total number of machines cannot normally be changed on short timescales.


We also found that certain optimizations may have secondary effects that are hard to predict at compile time.

the application of runtime optimization using ADORE was quite simple.


The most common GC technique that eliminates the risk of fragmentation is two-space copying collection on the whole heap.

this method can be costly, especially when used for modern applications with large memory requirements; this is because all the live objects need to be moved with each GC.


From the performance perspective, it is best to place each function into a separate region, so that it will not interfere with any other object, but that may increase the code space too much.

mapping all functions into one region uses the minimum amount of code space, but incurs too many instruction  Figure 2: Cost between functions depends on where other functions are mapped, and updating the costs as we map the functions can lead to a better mapping.


[12] and [20] list four ways in which the block offset and block index bits are generated.

what constitutes a good hash function depends on the application.


A selection of findings from the pilot are discussed below.

50% Use of Interface (% of total references to interface types) 40% 30% 20% 10% 0% the presence of an object with a neighborhood covering a substantial proportion of the rest of the program may be indicative of some problem such as too much centralized control or lack of semantic cohesion.


In this language, compile-time code is quasi-identical to run-time code.

the programmer needs to specify which program constructs should be used at compile-time, and which should be used at run-time.


Here also, we can statically verify that eachtransition associated with a given event leads to the correct state.


Nesting f within g does not imply that f only expresses intraprocedural control .ow within g and can share the same stack frame as g. Conti.cation is also super.cially similar to Appel s loop headers [3].


To this end, we hope to shed light on the applicability of AOP beyond traditional examples of logging, debugging, authorization control, and the like.

by pointing out some of AspectJ s weaknesses and by demonstrating how Caesar, which combines concepts from both AspectJ and FOAs, is more e.ective in this context, we also demonstrate the power of appropriate support for layer modules.


Comments gathered from participants during the study were generally positive  one even complained about not having had access to the environment when initially learning about 3 http://www.bluej.org/ conditionals and loops.

there were a number of critical comments regarding the Jeliot visualisation, including: -Too much happening at one time often participants had to play the animation several times before understanding it.


CPP operates on a stream of lexical tokens and is completely oblivious to the syntactic structure of the source code.

we require the de.nition of a parser for the base language and our transformations operate on abstract syntax trees of the base language.


This can be notably seen for MPI_Reduce on figure 6.

this is not a major drawback for a diagnostic tool compared to the valuable insight provided.


In Konoha, users can extend the class of tokens through the API for extending lexical analysis.

racket and Honu does not contain a mechanism for extending its lexical analysis of the raw input data.


Obviously it is not possible to show this for .b3 , which has switched the recursive calls, because it is possible, for example, to use tracing advice to notice that recursive calls are in a di.erent order.

straightforward equational reasoning shows that .b2 = .b4 : do m .


Our results show that OpenVZ is the virtualization tool that introduces less overhead over CPU, disk, and memory usage performing almost as well as native Linux.

openVZ requires the same operating system (OS) and degrades for networking, which is crucial for virtual routing.


For example, Algol was never used substantially in the real world, but its impact was huge.

impact on the real world was an important goal of the Haskell Committee, so it is worthwhile to consider how well we have achieved this goal.


So, observing the speci.cation at a high-level without going into its details (this will be done during subsequent phases), it appears that no redundant classes were added to the speci.cation.

if the sales system readily includes in its speci.cation the interface operations needed, the class ClsLocalSales would be redundant.


We are not aware of an automated way of performing such an interpretation in the current state of research.

recently described techniques to automatically identify sentiments from user generated content [16] could help to derive user preferences from user input data by selecting according candidates that have to be reviewed by engineers.


Other development steps that should also be covered by UPC tools in Eclipse include debugging, analyzing the performance of an application, and various other static and dynamic analyses.

it should be noted that in the case of debugging, there is currently no freely available, open-source debugger that fully supports UPC.


The author pointed out several cases where automatic completion of work.ows is desirable, such as creating an executable work.ow from a work.ow instance by assigning tasks to resources, completing under-speci.ed work.ow templates by mapping abstract tasks to speci.c components or adding data conversion steps.


Other approaches to providing parallel extensions to Java in- clude JavaParty [10], HPJava [2], Titanium [14] and SPAR Java [13].

these are designed principally for dis- tributed systems, and unlike our proposal, involve genuine language extensions.


Partial evaluation has been known for many years, and Futamura s paper [16] on interpreter specialisation is now 39 years old.

the technique is still not widely applied, because several problems arise when putting it into practice.We have found that these problems are either easily handled or simply do not arise when embeddingDSLsinIDRIS,largelyduetoitstype system.


This traditional algorithm is imperative.

a purely functional implementation of backpatching can be given by abstracting the generation of the program with absolute addresses from the environment as illustrated by the code in Fig.


Memory allocation is called from the VMKit garbage collection allocation function gcmalloc, which is overridden by JaBEE implementation taken from library.

current dynamic allocation with malloc is very experimental and was not well tested.


Other components, for history, analysis and execution control algorithms are also part of the automation cloud system but are out of scope of this paper.

to make the purpose of the runtime part more clear, it is important to note that control algorithms are intended to be deployed depending on their intended runtime characteristics.


Even after finding the right form, participants complained it did not have usual input field with labels 'From' and 'To' and instead uses drop-down menu and also there was no clear instruction about how to use it.

after completing the task on desktop browser, it helped them recognize the right form on mobile browser and didn't get confused with the quick journey planner.


The runtime models provide higher-level abstractions of both the running system and its environment and are also manipulated at runtime.

the focus has been mostly on effecting changes through modi.cations to runtime models that are causally connected to running systems.


Although this is the standard de.nition of multiset union, some applications might .nd summing the element multiplicities to be more useful.

this behavior would not be a valid least upper bound (because it is not idempotent).


In terms of the continuation e.ect, y+ precedes x- (i.e., the matching unlock operation).

if x and y are instantiated with the same lock handle a and z with b, the continuation e.ect of the .rst lock operation becomes [a+, a-, b+, b-, a-] and the future lockset is now correctly calculated as {a, b}: a+ and b+ precede the matching unlock operation, which is the last a-.


Ideally, the architecture supports the fault tolerance measures, and they are implemented within the architecture.

reality always intervenes: other functional and non-functional requirements also shape the architecture, resulting in an architecture that does not perfectly support fault tolerance.


For analyzing our Null hypothesis potentially we could use all kind of (machine) learners that can do binary classification.

the goal of this research is not to find the best algorithm for doing defect classification on a particular data set, but rather to determine which set of predictors offers more information regarding defect proneness of source files.


A fence or conditional branch is required after shared loads.

a fairly widespread processor erratum already appears to require this fence for C++.5 Thus the cost of enforcing this ordering for C++ may actually be similar to the x86 case.


For example, text books on object-oriented development recommend all manner of diagram types ranging from domain models and use case diagrams/descriptions through state diagrams and interaction diagrams to component diagrams and deployment diagrams.

none of these are mandatory, and their precise form and contents are left largely to the discretion of individual software engineers.


In our case, we have seen that there is an open implementation of WS-Security, namely WSS4J, which brought to us the code we required.

there is still no open implementation to handle most of the other norms.


This is why they were able to complete so much work.

the predicting user almost never selects such hosts because it predicts (accurately in most cases) that the bursty user will soon return.


ISSUES OF MODULE-BASED EVALUA-TIONS As we have described in the previous section, module-order models are a realistic approach to use defect prediction models in practice, since the budget for validation and veri.cation is typically limited.


We employ a similar technique in the .rst phases of our solution, and we draw from their experience.

like with Mandelin s work, their analysis is only concerned with the object types appearing in code sequences.


Our reported time and space results do not include calculating, storing and printing the maximum latency path from each green node.

the extra space and time requirement is trivial.


We believe it is possible to bridge this gap and create macro systems with the syntactic power of arbitrary contextfree grammars.

new parsing technology is needed to do so.


This main process is supported by the collection of environment state and, potentially, the adaptation of the environment itself.

the latter is out of the scope of Cloud2Bubble, which focuses on the user.


Many resources provide suggestions on how to develop relationships, behave in meetings, or make decisions in global work.

as we have seen, creative tasks require very different interactions.


Finally, the article proposes a research agenda for future works in the domain, such as issues related to software frameworks, quantitative evaluation, machine learning and adaptation.

the proposed research agenda is not set in stone.


Haskell s types for numerical values are currently not supported in Clean*.

haskell* can use Clean s numerical types by pre.xing such a value with .


Virtual primaries In our work, a class can share its dynamic type data only with a non-virtual primary base.

the common vendor ABI [3] allows a class to share its dynamic type data with one of its virtual bases, as long as the latter has no .elds.


Our comparative experiment shows that the choice of coverage type can greatly affect the effectiveness of faultlocalization: some faults are best localized by statements, others by branches, and still others by du-pairs.

in general, it is impossible to know which kinds of faults exist in a program before .nding these faults, and thus, which type of coverage is best (i.e., ideal) for fault localization.


However, in case of collective I/O, the .rst phase in which the bu.er sizes and o.sets are exchanged using an MPIAlltoAllv still occurs.

the overhead of this exchange is small at small core counts; it leads to a 100 % reduction in collective I/O performance in comparison to POSIX I/O as we scale to 32K cores.


This way, by writing di.erent process contexts CT IP P [ ], CIMC [ ], etc., one can perform functional and performance veri.cation on di.erent SPA processes using the state space generated by the mCRL2 tool-set.

this approach is also bound for failure since in many process algebras, such as PEPA and TIPP, C[(a, r).0 (a, r).0] has a totally di.erent state space from C[(a, r).0 {a} ((a, r).0+(a, r).0)], i.e., C can distinguish between two {a} strongly bisimilar processes.


what is still needed is a systematic approach general enough to be useful in several application domains, while considering the peculiarity of the system to be designed.


As all the above facts for 'y' do get generated (at 3, 2 and 6 respectively), a fow-insensitivesolutionwill include allthe above mentionedfactsfor 'z'.


This approach, however, proves to be inefficient on resource-constrained sensors [20, 21].

dandelion achieves transparency by limiting the senselet functions to data processing and by introducing an extra compilation phase to produce sensor native binaries during application installation.


We believe that such a system is a good choice for languages that seek to employ mandatory typechecking.

many considerations impact the design of a language s type system, and discussing them is well beyond the scope of this paper.


By default, GenProg selects between the three mutation types with equal random probability.

the operations do not appear equally often in successful runs on the larger benchmark suite.


Note that this approach allows for the possibility of a denial of service attack by a malicious AAP against the NSE continually rebooting.

this behavior can be detected and access from that AAP can be blocked.


Grossman, Morrisett and Zdancewic have proposed the use of abstraction brackets for syntactically tracing abstraction boundaries [10] during program execution.

this is a comparatively weak method that does not seem to help in proving parametricity or representation independence results.


These scenarios are related to storyboards which also include how the products interact with the external environment.

internal interfaces (that present communication among internal elements of the reference architecture) are not relevant for these Scenarios; thus, we considered these interfaces to be partially used in these scenarios.


If a precondition for a hot .eld cannot be guaranteed, object inlining is not possible and the .eld loads must remain.

it is still possible to colocate the objects during garbage collection to improve the cache behavior.


The save instruction in Set 1 is inserted into basic block D prior to the other instructions in the basic block.

the restore instruction shown after basic block E is inserted as the last instruction in basic block E. the restore instruction on the control .ow edge between basic block D and basic block F cannot be inserted into basic block D, because that would corrupt the value of the register in basic block E, and the restore instruction cannot be inserted into basic block F because there is an execution path that would reach that restore without any save instruction.


It allows manual addition of resources of any type but also monitors user activities and automatically adds resources to the current activity.

the system has been designed for personal information management only, not complete synchronous/asynchronous sharing and awareness.


This allows even deadline-sensitive applications such as LEAD to run on nondedicated machines.

it is important to understand the different parameters of the system and the tradeoffs with existing systems.


They assert, e.g., that they do not consider multidisciplinary work important in this situation (n = 16).

all respondents that have collaborated with professionals from other disciplines (n = 14) agree that they benefit from this collaboration and the quality of the systematic reviews improved due to multidisciplinary work.


This explicit representation makes it straightforward to track information .ows and to enforce the key correctness property of noninterference [Goguen and Meseguer 1982].

universal labeling incurs signi.cant overhead to allocate, track, and manipulate the labels attached to each value.


One of the important concepts of multi-agent systems is cooperativeness, or interactions.

existing languages for implementing interactions lack expressiveness.


Diminishing returns: In many applications, quality function exhibits diminishing returns: allocating more processing time to a request leads to a decreasing quality improvement.

the quality improvement is signi.cant when we start to process a request, while it gradually becomes diminishing during the processing, as can be explained by considering the example of VoD servers using scalable video coding (a popular video encoding technique used in H.264/MPEG-4 AVC standard): sending higher-rate bitstreams increases the video quality but the quality increment gradually diminishes [34].


This paper presented a GA-based approach to generate test data, intended as combinations of bindings and inputs, causing SLA violations.

the paper proposes a blackbox approach, where the .tness awards individuals violating constraints or close to constraint violations, and a white-box approach, combining the black-box .tness with the code coverage .tness proposed by Wegener et al.


Inspired by these facts, Conway de.nes the chip-chop matrix of a .xed regular language S. This matrix M(S)is indexed by the .nite set of chops of S, and the individual entries are given by M(S)X=XY xY One could think of M(S)as a systematic organisation of all the parts of S. In particular S itself occurs as at least one of the entries of M(S).

we are now ready to generalise from the original problem (which was to determine whether all program paths are in S) to a problem that is easier to solve compositionally, namely whether all program paths are in each part of S. for a set of program paths P,we de.ne a Boolean matching matrix B(P), indexed by the chops of S: B(P)xXY =P CM(S)XxY Since M(S)contains all the parts of S, this matrix answers the question whether P CS.for any part S.of S, in particular, for S itself.


An exclusive permission for an object x represents the unique ownership of x.

such a permission grants read-write access to the memory block at address x and guarantees that no-one else has access to this block.


SecComm is a much simpler composite protocol than CTP and the video player, and the event behavior in this particular SecComm con.guration turns out to be quite predictable.

there is one event chain on the sender and one chain on the receiver.


On a roll now, our user defines a function to do the regional sum for any argument which has the same length as the regionvariable: sumReg.

{+/¨(classify region)..} sumReg quantity 15 37 11 (sumReg quantity×price)÷sumReg quantity 25.83333333 22.21621622 29 the average price by region is the regional sales total divided by the regional number of units sold.


An important trend in Internetware lifecycle model will be reusability, and this can be evidenced by the recent emphasis of publishing, search, discovery and mining in software development, and they are all related to software reuse.

publishing makes reusable assets available, but specific items selected for reuse still need to be searched and discovered possibly by using data mining techniques.


Perhaps the simplest one to perform is based on RMSSD = _ 1 NN-1  2 (2) RRj+1 - RRj the time-domain measures.

the most evident measure is the mean value of RRi N - 1 j=1 RRor, correspondingly,  the mean HRHR.


The scheduler places the consumer operation as soon as the expanded routing path meets a resource that supports the destination operation.

a node-centric approach .rst places the operations and then searches for a routing path while an edgecentric approach .rst checks the routability and then places the operation.


The implementation is a thin wrapper of approximately 530 lines of Java code around an SMT solver and a weighted MaxSAT solver.

we use CVC4 to implement the SMT.Solve function, and Sat4j to implement the WMaxSat function.


They are no longer expanded because the unfolding rule prevent this.

we can see that when an atom of the form loop(...) appears for the third time in the same branch, the branch is stopped.


The results for LSR and DNS are similar, so we omit them due to space considerations.

for LSR the fault-based analysis accurately predicts the reversal of the relation between all-uses and all-branches.


To this end, we can make Exp covariant, by replacing its declaration trait Exp[T] with trait Exp[+T]: then S <: T implies Exp[S] <: Exp[T].

we encode subtyping in the object language by reusing subtyping in the metalanguage.


Variable-argument functions do not need any special treatment in the transformation because of their representation in the BU graphs computed by DSA.

the DS graph nodes for all pointer-compatible arguments passed via the ... mechanism (i.e., received via va arg) are merged so that they are represented by a single DS node in the caller and callee.


Within the Jena2 architecture these views can be generated from an RDF Schema or an OWL Ontology and incorporated within the overall framework.

while the figure shows two instantiations of the top layer, other instantiations can be added.


Yet, such an attempt is detected by the recipient of the query-hit (the generator of the query, ps ), since multiple neighbors of pr , depending on the topology, will report pr s reputation and all of them should report the same value.

a neighbor reporting bogus reputation might be revealed, since it may not be the only one answering, due to the unstructured topology.


The agent outside AP is a basic performer of separate domain.


The internal messages of the relation are only TO-delivered by the RE-CEIVER task when certain conditions hold.

the next relation of messages to be TO-delivered must contain messages for Executed by every process pi 1: init 2: broadcasts .Ø {Output message buffer} 3: tbdelivered .Ø {To be delivered} 4: seq .


Running DrScheme inside DrScheme change immediately solved a large class of memory-use problems.

repeatedly running DrScheme within itself maintains a steady state for any number of runs.


This formula differs from the one introduced in [11]in that it separates clearly between the notions of elementary distance (which does not involve traversing the object structure) and .eld distance, 1We use the term .eld as a dynamic notion corresponding to the static notion of attribute.

classes have attributes, while objects have .elds.


Figure 3: An actor with three di.erent kinds of identities Our problem is how to match all the identities that correspond to the same actor.

we want to .ll the Matches table with as much information as possible (and as accurate as possible).


The subsequent discussions with all the teams made this category even clearer because of the importance of "dynamic diversity."

the "design for one" concept was brought out as an important issue.


The translation we start of with is to replace each ?assertMatch(Result,F un(A1 , ..., An)) in a test by the function name F un to obtain a sequence of function calls.

the startstop test() above is translated into the sequence: + start stop start stop where the leading + indicates that this is a positive trace, that is a trace that is to be accepted by the inferred FSM.


Here S s are Cito states, and stateful predicate statepSqestablishes when the Bedrock IL state suitably implements S. Relation pS, sq Ó asserts that executing s in S will not crash, and pS, sq ó S1 asserts that one possible result of running s in S is S1.

the macro s proof rule says that, if the current Bedrock IL state implements a Cito state that leads to safe execution of s, then a postcondition for running c is that the Bedrock IL state implements some Cito state that could result from running s. This is a backwards preservation property in the sense we adopt throughout this paper, which is a big-step simpli.cation of the backwards simulation relations of CompCert.


MetaLexer splits up the inherited .le and weaves its elements to the corresponding sections of the current module.

headers go in the header section, options go in the option section, rules go in the rules section, etc.


The original contribution of this paper is concerned with a proof of concept that language games can be an e.ective solution to the interoperability problem among heterogeneous and autonomous systems.

we address a speci.c application problem that occurs in distributed annotation systems.


The reduction in block distances when our approach is employed can be easily observed from this graph.

when we move from Default to Default+, the fraction of block distances in the range of [116] is increased by 38.9%.


On the other hand, asymmetric approaches do not fully support aspect-aspect composition.

a component which integrates other components cannot be integrated itself, restricting the integrated system design and implementation.


Intuitively, it means that, if a given program can be made statically typed only by adding static type annotations, then it can already run safely.

the inserted run-time checks would not prevent safe execution, which would have been ensured only by adding static type annotations.


Note that S and D, A are inter-de.nable by each other.


The implementation, in our case, was a demonstrative implementation found in a security book, not a fully faithful implementation of the design.

the implementation was simpli.ed in many respects.


W is the number of uniformly generated write sets.

there is a single memory read and single write access for each set of uniformly generated references because all others will be removed by scalar replacement or redundant write elimination.


Alternatively, Peer-To-Peer (P2P) networks offer significant advantages over their hierarchal counterparts, especially by the way of resistance to failure and congestion.

structured P2P systems based on Distributed Hash Tables (DHTs) such as Pastry and Tapestry [1][3] have become popular communication substrates for data-sharing applications such as PAST and OceanStore [9][12].


for every entry (x.pG(Y) as P) in the de.ne section of a class G, (.x <: G · TR(p,x,Y) where {}) is implicitly exported.


However,many issues make the exploitation of SIMD techniques very di.cult to realize.

complicated vectorizing techniques are often needed to uncover the parallel operations to be  Figure 1: Cumulated distribution of operands bitwidth.


Since we are concerned with highly resource-constrained embedded systems, it is important that the middleware be efficient in its use of the resources required to deploy it.

the code space and memory required by the middleware should be minimized to realize cost-savings in terms of FLASH or EPROM hardware.


While for t = n, the best and the worst assignments are within constant factors (Theorem 4 and Theorem 5).

the worst assignment RAND is actually a distribution, which does not shed much light onto the structure of the worst assignment.


However, it has been shown in [10] that computing the frequency spectrum by FFT is prohibitively expensive given our typical platforms.

it would take approximately 15 seconds to calculate a 512-point FFT using an 8 MHz processor typically available in many of the commercial sensor nodes.


Since the runtime assertion checker cannot win but only gives up when it encounters angelic unde.nedness, it is a better strategy to continue looking for potential demonic unde.nedness.

demonic unde.nedness is given precedence over angelic unde.nedness, so that the runtime assertion checker can signal more assertion violations and thus help detect more bugs.


Similarly, value nodes such as the values associated with radio buttons, check boxes,or select list are pre-processed as well.

we can classify whether a value node corresponds to a concept or a value in the ontology.


Information Flow Although the guarantees provided by our dynamic race detector are desirable, they extend only to a single instantiation of inputs within an enormous universe of inputs, hence the need for a static analysis to amplify those guarantees further.

we use a static information .ow analysis that tracks .ows from data inputs throughout the kernel.


As performance degradation is increased in an attempt to save more energy, the en- ergy savings come at the expense of more and more perfor- mance degradation.


Two of the plausible indirect relationships between the multi-site character of work and MR interval would appear to be ruled out by this model.

the hypothesis that large changes take longer to implement and also are more likely to involve multiple sites is not supported by the analysis.


5.1 Prior Solutions One solution to this problem is to bake in serialization of function values and indeed of all values as a primitive operation implemented directly by the runtime system.

the runtime system allows one to serialize any value at all, and transports it to the other end of the wire.


Despite the lack of any type-safe alternatives, and even admitting they found it to be a clever exploitation of features, they rejected it because they felt like it violated unwritten, and up to that point unrecognized, design principles.

to them Equatable is only meant to describe types via constraints; it is not something to be passed around in lists.


Several studies conducted in 2006 seem to con.rm that this notion of continuous evolution is taking hold [1, 2, 10].

the highly regarded Carnegie Mellon Software Engineering Institute (SEI) study on ULS systems suggests that traditional top-down engineering approaches are insu.cient to tackle the complexity and evolution problems inherent in decentralized, continually evolving software [10].


However we still strongly recommend de.ning all possible constraints in terms of suitable type classes as these constraints scale better with larger systems and are, by nature, easier to specify.

the only time we see the need for constraints on instances of the entity concept nodes is when a particular policy explicitly calls for constraints on entities, such as with object-based separation of duty constraints [15, 14], and models with these constraints do not scale well.


Likemost object-oriented languages, X10 supports classes; however, it places equal emphasis on arrays, a central data structure in high performance computing.

x10 supports dense, distributed multidimensional arraysofvalue and reference types,builtover index sets known as regions.


The Emacs plug-in indicates errors that would occur if the developer were to save all modi.ed Emacs buffers, compile, and test the on-disk version of the code.

the Emacs plug-in indicates problems with the developer s current view of the code.


The following example illustrates this point.

we allocate a fresh extended region ( child) within an existing region parent.


Although the compiler is not yet mature, we have received numerous enthusiastic comments, suggestions, and remarks from participating students.

we noticed that the students were no longer distracted by cryptic type error messages caused by overloading.


3.2 Software The wearable mote runs the SPINE Framework, which has been extended with a custom de.ned processing function to support the CardioShield board.

the function takes care of enabling/disabling interrupts from the heart beat dedicated receiver based on coordinator requests.


We abstract away data values, and retain as symbolic state a path through the program and a multiset of outstanding resource types for that path.

rather than keeping track of which variables hold important resources we merely keep track of a set of acquired resource types.


However, it is also worth noticing that our approach is, at present, less powerful than usual ones with respect to logic capabilities.

lustre data-types are very restricted and there is no notion of recursive functions, though there has been attempts to overcome these limitations [8].


HealthWatcher shows an example of an aspect introduced because of a feature interaction: Aspect HWTimeStamp had to be adjusted to provide special behaviour for the case when Update-StateObserver (implementing the observer protocol) is deployed.

hWTimeStamp maintains a modi.cation counter for objects stored in the database.


for all paths, P from c~ to ~8, g,~(j3) = min atoBfa(P) over all P from There is a shortest path tree, T, spanning the graph repre- senting the ad hoc network, rooted at the reference node, c~.


Requirement 2 It must be possible to de.ne constraints on the values of the properties of the resources.

it must be possible to de.ne relationships among resources.


The goal of this experiment was to determine how much a set of UML diagrams could inform a professional developer (who has reasonable knowledge of the UML) about an existing system one that the developer didn t design or construct.

assess how useful the UML is in helping to understand a legacy system.


The speedup results in Figure 7 show that across the range of core numbers, the fuel-based strategies are consistently more ef.cient than parTreeDepth or parTreeSizeAnn, for depth-based and size-based thresholding, respectively.

a pure fuel version, using just simplistic but cheap fuel splitting, performs best on 48 cores, exhibiting a speedup of 15, and the marked variant of the fuel strategy performs best for core numbers up to 36.


hMSCs provide information on how components can continue once they have completed a bMSC.

they determine a relation between the Start and Stop states of Instance LTSs.


Proof: Suppose the first response that node Vi receives is from ''' ' n node Vj.


With this in mind, this paper proposed a software architecture and an approach, oriented to represent the physical world in a useful, comprehensible and more abstract manner for facilitating connections with the virtual world.

an entity description graph has been used for supporting the information extraction from the physical world and facilitating the comparison among different entities.


The students do score higher, but the difference could be attributable to the fact that students were creating new (and buggy) programs, not merely refactoring existing code.

our logging information suggested the experts made almost no use of the s-expression editing commands.


Consequently, for the web services version we allowed the students to implement the log using polling.

the log is implemented as a client in the client-server sense that runs in an infinite loop that calls the chat server for new messages, displays any new messages, and then performs a delay (using the sleep method of the Thread class) before repeating.


For example, if the model denotes a joint of the head of the robot as a variable x, we need to relate the variable x to the servo motor that controls the position of the head.

we need to bind objects in the model to objects in the target platform just like high-level language compilers bind variables to memory addresses.


ANALYSIS In this section, we present the results of our empirical study, and draw conclusions from an analysis of the data.

we .rst examine whether certain languages are more prone to XSS and SQL injection vulnerabilities.


By entering a layer or exiting from the layer, a program can change its behavior.

a program captures context-dependent behavior by entering a layer.


They helped us to understand the pre- and post-experimental part of the replication, as they contained information not present in the RP.

we were able to ascertain how the experiment was defined, planned and run, as well as the results of data analysis.


The package interface is less precise than the Bigloo module declaration.

because the latter contains type annotations and other information useful for the compiler.


This requires that the application or application wrapper uses the current directory paradigm of referencing input and output files.

all input, output, and control files are referenced relative to the current directory without absolute path names.


2.2 Scalability bottleneck in DBMSs An ACID-compliant DBMS has to implement some concurrencycontrol to ensure the ACID properties, making a DBMS thread unable to work independently with other threads.

dBMS threads are processing their work with interacting with each other.


DS statements make it possible to capture situations in which requests (e.g., from di.erent agents) for executing an activity do have di.erent normative and sanctioning impacts on the requested agent.

dS statements allow to model situations in which requests even for the very same activity induce di.erent norms and sanctions.


Introduction The synchronous model of computation [6, 23] proved to be well suited for the development of reactive systems.

synchronous programs allow simple translations to sequential programs as well as to synchronous hardware circuits so that they lend themselves well to a model-based hardware-software co-design.


Using Theorem 10, we show that the weakest failure detector for strong j-renaming is O (for each 1 <j<n).

strong renaming is equivalent to consensus.


Contextual cues and practices are not likely to bring both groups to the foreground as a useful tool for making sense of the social environment and one s place in it.

in any particular context, both groups independently may not be esteem-enhancing or useful enough to be attractive sources of social identity.


In this case it is useful to analyze singleton sets of interest since suggestion sets for more than one element will be bounded by a multiple of this value corresponding to the number of elements in the set.

the size of a suggestion set for a set of interest of two elements will be at most the sum of the size of the suggestion sets corresponding to the sets of interest for each individual element.


Hence, covered users by the hybrid approach were union of two nearly disjoint users.

the coverage of the hybrid approach was similar to the sum of two coverages (i.e., coverages of social recommender algorithms and NN) as shown in .gures 6 and 7.


Onepossible way oflearning thisdistributionis to use memorybased methods such as K-nearest neighbours.

we can setthepredictivedistribution q(y|x) tobeaconvex combination of the K distributions corresponding to the trainingprograms and microarchitectures that are closest in the feature space to the new(test) program and microarchitecture.


This speci.cation can then be re.ned to result in a speci.cation of a parser that is speci.c for a given EDTD.

there is no need to store the complete XML document as in tree-based parsing approaches such as DOM.


In the last two stages, communications introduced at any point in time but not treated are considered.

during stage 5 decisions are made for combinations involving communications, and in stage 6 the communications with remaining slack are finally scheduled to a particular cycle.


We believe that the answer is simple: the rules for optimizing accesses to volatile variables are quite unlike the rules for optimizing accesses to non-volatile variables, but are similar to the rules for optimizing external function calls.

calls to external functions, like accesses to volatile variables, must not be duplicated, eliminated, or moved around very much.


The subtyping relation is not extended across pointers.


The OWL standard, which may be used to define an ontology of types of "Thing", also has provision for knowledge base representation of what are called "Individuals", these being the equivalent of instance data in a database, but with explicit reference to ontology.

an ontology, whether or not it contains individuals, corresponds to an explicit theory of meaning whereas a linked data resource corresponds to data about things.


With type classes, contexts are implicitly passed, and there is no way to rede.ne those implicit behaviours.

type classes have the same limitation as implicit representations as a version of the TypeCase design pattern, in that they can only work on types.


The waste is measured in terms of the number of instructions.

when a live-in variable is updated in an iteration, we measure the average percentage of instructions that are directly or indirectly dependent upon the updated value within the next iteration.


[1999] taught usersnew travel strategies.Second, evaluation metrics usually involve application-speci.c tasks.

they emphasize the way.nding component of navigation.


The subsequent four rules relate the atomic propositions.

l-SUB says that if x has type t, then it has any larger type.Similarly, L-SUBNOT saysthatif x does not have type t, then it does not have any smaller type.


That credo has only recently been reiterated in public emphases on computational thinking as a way of understanding complex, constructional processes.

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


Firstly, all cuts that are obtained by propagation from the same cut correspond.

the three cuts (in the two boxes) labeled 1 correspond,the two cuts labeled 3 correspond, etc.


The use of the tool also improved operators' interaction and objective task performance during switching (figure 4).

the number of 'target locks' was similar with and without the tool.


Two distinct segments S and S ' in the given program are parallel, and we write S I S ' , if they are not comparable in terms of the relation -.

we have S I S ' if and only if S -S ' and S ' -S are both false.


The main purpose of our approach is to also coordinate the behaviour contributed by di.erent parts of the model.

to coordinate the behaviour contributed by the di.erent aspects.


By respecting the dependence, the schedule ensures that a(i) starts at least d time steps earlier than b(i+d).


JTL has two kinds of predicates: native and compound.Native predicates are predicates whose implementation is external to the language.

in order to evaluate native predicates, the JTL processor must use an external software library accessing the code.


However, it was decided that SLuRp supported this activity better than first thought.

allowing multiple users to apply criteria independently and resolve conflicts through moderation, helped to increase its score.


The use of exact lab simpli.es access control checks to a given tree node, but updates to local labels will impose a non-constant overhead.

if a principal wishes to change the local label on a node, the exact labels of the node s descendants must be updated accordingly.


We have presented a fully adaptive predictor, called STEP, that can optimize itself for any arbitrary workload, while simultaneously offering simple adjustment of goals between energy conservation and latency reduction.

we have proposed a predictive prefetching scheme that combines the most generic and useful criteria to enable data prefetching while being energy safe.


The annotation will only be visible when that memory block is visible.

it will not be visible during the animation until that memory block is allocated, and then only if the visualization view (based on viewing mode and filters) makes the block visible.


To guarantee safety, an assertion is added to the beginning of the conditional jump list to check if the target is among the symbolized addresses.

our code creates a white list of the symbolized target addresses; any unknown (new) target will be captured and thrown out.


Since F0.05 = (4, 3995) = 2.37, and 750.20 > F0.05, so we can reject the null hypothesis that the APFD means of the five techniques are equal.

the APFD values of three different techniques have significant difference (Ha).


In the next section I discuss how the technocratic system played out in practice.

i show, how the project is resisted by the lower-level bureaucrats and how that in turn caused changes to the software system to incorporate the resistance, which prompted new resistance and how it continues to be a constantly moving target.


Refusing to adopt these tasks might have had wider consequences for future coworking experiences and might have seriously hindered the establishment of the trust-relationship between designers and participants.

when dealing with prototypes in complex environments, system failures are unavoidable.


For every benchmark, we the same X10 implementation for all runs.

our single-core sequential runs still use the full, distributed, parallel X10 code.


Then, the different ways to manage the progress of a user through a Web site is described in section 4.

we will show that Ocsigen allows to use two kinds of sessions.


After splitting, because the type [s1] is non-linear, the capability {s : ref [s1]}can be used to read and write the reference as many times as desired.

reading the reference duplicates its contents, at type [s1], but does not duplicate the capability {s1 : .


otherwise r =!p; If the contextual interpretation is enabled, the result variable, r, in the translated code is set to the negation of p,thus preventing a false report of an assertion violation.

the runtime assertion checker assumes that an informal description always holds.


Current simulation tools provide their users with simulation optimisation but only for a single .tness function.

all the objectives need to be aggregated together to form a single objective or a scalar .tness function which is then treated by some classical techniques, mostly simulated annealing and scatter search.


Lemma 3: Trust in CRN is generally irreversible.

t (i, j) t ( j,i) (1) Lemma 4: Trust in CRN is not a metric.


When an interaction test suite T has been already constructed by CIT, traditional CIT would directly execute T .

traditional CIT does not consider the order of test cases in T .


The discussions within the participatory design team that was set up and the user studies performed at archaeological parks during such design experiences gave also the possibility to envision, with different stakeholders, new applications that could have a practical value for them.

the requirements of the system presented in this paper were collected through contextual inquiries performed by observing how several professional guides were leading groups of tourists and school students of different age in the archaeological parks of the Apulia region, in Southern Italy [3, 14].


For any s, the value of f(s) is decided by Csc(s) and Ctc(s).

for any two control .ow switches s1 and s2, if their source blocks are in the same cell and they also share the same target cell, the keys assigned to s1 and s2 are the same.


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

the operations should be invariant under equality.


In practice, some care needs to be taken to ensure an implementation remains ef.cient.

as is usual in such cases, our .xpoint iteration makes use of a worklist, so that iterations only revisit those statements that may in.uence the result.


Heuristics L and R .rst select shorter occurrences, and then break ties left-to-right or right-to-left, respectively.

l and R are two variations on breadth-.rst ordering of the subterms of the subject value.


The result of the cpp program can be one of a multitude of C programs.

someone wanting to parse a system for program understanding purposes has two options: either choose one particular con.guration and parse the preprocessed code for that con.guration, or make the parser more robust so that it understands the unpreprocessed code, which does not have to be valid C. the cpp introduces the following constructs: #define Macro de.nition and expansion.


x1 = x2 + 1) Notice that in(.3((IidII+1),Ieq)) = x1 = x2 +1.

because of the connection ., new assumptions have been generated for the external inputs x1,x2.


First of all, a novel policy for the distribution of LT coded packets is proposed, that is based on the results of [4] and the usage of Bloom .lters [2].

peers are allowed to propagate coded packets in a random mesh overlay following a simplepush approach.


1 We complete the picture by showing that the depen- dency of the approximation factor on az is unavoidable.

we prove that there exist sequences for which no periodic schedule can have cost less than 1 + f~(a~) times the cost of the best relaxed solution.


Flight regulations and restrictions Federal law requires that all aircraft pass through stringent safety checks.

software must be validated and demonstrated to be reliable and safe within conservative margins.


For each unit, the inputs controlled by DART were the arguments of the unique toplevel function of that unit, and DART was limited to running a maximum of 1,000 executions (tests) for testing each unit.

if DART did not .nd any error within 1,000 runs while testing a unit, testing would then move on to the next unit, and so on.


Since Beta-style method overriding is designed to help enforce invariants in the code, it trumps Java-style method overriding in our design.

a Java-style method extension only replaces the behavior of the method up to the nearest Beta method.


s[l' : Nat] CoinBag ' d n l' × (l' l) given a problem (i.e., a value to be represented by coins), if c : Coin is a choice of decomposition (i.e., the .rst coin used) no better than d : Coin (recall that we prefer larger denominations), and b : CoinBag ' c m l is a solution of size l to the remaining subproblem m resulting from choosing c, then there is a solution to the remaining subproblem n resulting from choosing d whose size l' is no greater than l. We de.ne two views [16] or customised pattern matching to aid the analysis.


The .rst way one might attempt to add this functionality in a Java program is as follows: public class Rectangle extends Shape { /* ... */ public boolean intersect(Rectangle r) { /* efficient code for two Rectangles */ } } Unfortunately, this does not provide the desired semantics.

the new intersection method cannot be safely considered to override the original intersection method, because it violates the standard contravariant typechecking rule for functions [Cardelli 88]: the argument type cannot safely be changed to a subtype in the overriding method.


Furthermore, while these workarounds do mimic NST criteria s abstraction of multiple tests, the limitation that each individual test stops at the .rst failure remains: there is no analogue to NST s :each criterion which will ensure that every element of the list passes some subcriterion.

these techniques apply well to multiple tests along the static structure of complex objects under test, but they account less well for dynamic variations of inputs.


For example, from initial con.guration p, code will always, at some some later point, reach a state satisfying q.


In fact, once these tuples have been propagated, if a node moves, only its tuple local value is affected, while all the others are left unchanged, since their position with respect to the source does not change.

a tuple on a node that moves can infer its new value by looking at the tuples stored in neighboring nodes and by considering their coordinates (see Figure 3(b)).


We argue it is because similarity with other users cannot be measured without previous rating.

if user u does not have any item in common with other users, similarity-based approaches can neither use u s rating to predict other s nor give recommendations to u.


Once the division points are identified in the parents, two new children are created by inheriting fragments from parents with a 50% probability.

for each pair of fragments f1 and f2 of the same task belonging respectively to parents 1 and 2, child 1 inherits f1 with a 50% probability, and if it does inherit f1, child 2 inherits f2, and conversely.


A state figure occurring in the head always matches a virtual figure of same type representing the state of the point matched by the (primary in most cases) char- acteristic point.

a velocity occurring in the head matches a virtual velocity figure representing the vector of the real velocity of its primary characteristic point.


In this paper, we not only focus on the distribution of contents already in an online social network, but also the collection and processing and contents generated by users in a social application.

we explore the deployment of social applications based on cloud computing.


In this analysis, we demonstrate PUMA can be used to script similar tests.

we focus on apps that use HTTP and inject null HTTP responses by instrumenting the app code, with the goal of understanding whether app developers are careful to check for such errors.


However it is powerful enough to turn a userde.ned datatype such as complex into one that delivers the same ef.ciency as a built-in type.

the usual arithmetic operations may be de.ned as follows: constexpr complex operator+(complex x, complex y) { return complex(x.real()+y.real(), x.imag()+y.imag()); } constexpr complex operator*(complex x, complex y) { return complex(x.real()*y.real() -x.imag()*y.imag(), x.real()*y.imag() + x.imag()*y.imag()); } This allows us to handle the types that are most frequently considered for placement in ROM and for which the highest number of objects are needed.


One thing that becomes apparent from the properties of orthogonal dimensions outlined above is that the concept of orthogonality is hard to pin down.

it captures a number of ideas which are in tension with one another and cannot be easily reconciled.


In such cases, the idea of placing tasks on their preferred cost-efficient instances may not always save money, because instances are not fully utilized and there could be a large portion of unutilized instances hours.

the benefit of instance consolidation overweighs the cost-efficiency for individual tasks.


We choose string matching because most programmers are familiar with the problem and because we hope to have something new to say.

the BM algorithm has not to our knowledge been subjected to calculational conjuring.


In addition, instead of making a binary decision of whether an item is an iceberg or not, we want to provide accurate estimates of the total counts for all the potential icebergs.

we want to .nd item x along with its estimated total count c, such that c = (1 - E)T , where E is a small constant (say 0.1).


Moreover, the system may also feature agents that are used to govern actuators through the coordination policies enacted by coordination artifacts, in order to implement those control policies that are better delegated to the deliberation of an agent rather than to an automated coordination policy encapsulated within a coordination artifact.

agents manage actuators through suitable artifacts (hereafter called > artifacts) which make actuators uniformly available to the agent s use.


The API that is generated for a guest language is responsible for preventing injection attacks.

even without using the syntax embedding and assimilator, the use of the API guarantees that injection attacks cannot occur.


In GXL, the notion of host graph is defined by the main scope of the application.

there is a "main" graph production which is the only one applied to the host graph and other productions are applied to sub graphs matched by the main production.


From our experiments, we observe that VDGAA runs up to 583 times faster and improves the quality of the output by up to 18.5 times over ICF-GAA.

vDGAA overestimates signi.cantly fewer active variables, thereby reducing the memory requirement and the run time of the derivative code.


Each worklist consists of triples (vj ,.g ,.j )where vj .V * and (.g ,.j ) .PE(vj ).

the worklist consists of path edges incident on vertices that are awaiting processing.


is required to produce an alarm or con.rmation dependent on whether or not a customer request was answered within 10 minutes.

the correct detection depends on the successful detection of a customer request, say er as well as detecting successful answers, say ea.not detecting a successful answer could trigger both a false positive and a false negative, namely an alarm instead of a con.rmation.


In the former, everything we can rely on is the syntax tree itself, while in the latter, we can utilise the semantic relations uncovered by various semantic analysers.

during semantic graph transformations, we have that complete scope analysis, we are aware of side-effect properties, data-.ow relations and unobvious dependencies, which allows us to .nd syntax tree nodes by one-step paths that would otherwise take a grand tour to look up.


However, this form of constraint solving is not powerful enough to enable convenient programming with sensitivities.

the task of providing complete annotations can be dif.cult and errorprone, so we would also like to be able to check the correctness of partial programs where some of the explicit sensitivity annotations are replaced by variables.


We do not claim to have achieved this goal yet, but describe the key ideas behind a new approach that anecdotal experience with prototypes suggests might have the right properties.

we present a new dependent type system that represents a new point in the design space from previous work.


5.2 Instructions and Operation For an operator graph such as that shown in Figure 8, an expression instruction .eld must contain the required con.guration of the tree.

for each operator block, one operator must be selected; together with the addresses or values of the inputs.


Thus, in our model and using the speci.ed policy it takes one state transition for the request workstation to receive the Find command results from the dispatcher.

we can guarantee that the location information received in a FindResult event is equal to the location in the master workstation database exactly one state ago.


determine whether the abstracted program satis.es the speci.cation of P.If it does, P must also satisfy the speci.cation, and the program is successfully veri.ed.


This paper describes a new approach that uses phase boundaries as the gates to monitor and control the memory usage.

it presents three techniques: memory usage monitoring, object lifetime classi.cation, and preventive memory management.


We reformulate the iterative computations of [19] according to a DFS traversal of the computation tree and obtain, as a result, a cache-oblivious variant which exhibits asymptotically improved spatial and temporal locality over the original one.

we show that the DFS variant ensures spatial locality, and describe quantitatively the asymptotic improvements in spatial and temporal locality.


Therefore if there is instruction parallelism in an iteration and there is register pressure in the iteration, exploiting some of them can also degrade the pressure of the requirement of the register and reduce the data that are spilled out.

when guaranteeing the utilization of the computation resource, we also try to satisfy the register requirement of the reuse data vectors because it can reduce the competition of shared data bus.


Therefore, SVD uses only information that is available from program binaries.

sVD uses dynamic instructions instead of dynamic program statements as the unit of computation and SVD uses .xed-sized memory blocks instead of variables as the unit of memory accesses.


CONCLUSION In this paper, we have explored the viability of a DHT service as a general purpose building block for Place Lab, an end-user positioning system.

we investigated the suitability of layering Place Lab entirely on top of a thirdparty DHT to minimize its deployment and management overhead.


The proposed approach can minimize power variations in a software pipelined schedule without sacri.cing its performance or increasing the energy consumption.

this paper addresses the following problem: Problem P Given a loop L and machine architecture M, generate a rate-optimal software pipelined schedule that minimizes |Pt - Pavg|,where Pt denotes the t power consumed at clock cycle t of the schedule and Pavg denotes the average power consumed during the execution of loop L. This paper presents an integer linear programming (ILP) formulation for the above problem.


In order to enhance usability, traditional input interfaces should be replaced with more user-friendly human-computer interaction interfaces.

a 3D User Interface (UI) should allow the user to act in a way similar to real life, making it possible to exploit human abilities in a virtual environment [6].


[22] discuss variability points in Web service .ows.

one of the variability points discussed addresses variability in the di.erent kinds of data exchanged.


Starting and stopping the server don t result in a state change; at least, not on the basis of this single test case.

the picture suggests that one can successfully perform a stop in the initial state, and also start the system twice.


Secondly, in MRSR phase, each sub task that aggregated by VM packing is merged in parallel.

tasks allocated in different VM instances are merged to the single VM instance and processed concurrently.


There are two main advantages of the buffering technique: (i) It increases the CPU utilization.


Explicit identification of these relationships between B-SCP requirements and Map facets allows us to verify each Map facet against B-SCP requirements and their domains of interest.

we are now able to determine how many (and which) B-SCP goals can be achieved when the process of a Map facet is executed, as well as how many (and which) domains of interest are involved in this Map process.


The results in this paper focus on low-level performance, including the new Morton-hybrid representation to take advantage of hardware and compiler optimizations.

this code beats Intel s Matrix Kernel Library and matches AMD s Core Math Library, losing a bit on L1 misses while winning decisively on TLB-misses.


Note that the emptiness problem of .nite automata with multiple read-heads is undecidable, and the traversal allowed for streaming transducers is restricted by design to ensure decidability of key analysis problems.


First, they can perform carrier sensing in order to determine whether or not the channel is currently in use (this is also referred to as collision detection in the literature).

if there is some activity on the channel be it a single message being sent, a collision of multiple messages, or a malicious device jamming the airwaves the protocol can distinguish this case from the case of no activity.


If the quality of performance testing cannot be satis.ed, the testing results will be useless and cause waste of money and resources.

it is critical for customers to obtain reliable services of performance testing.


However, it is imperative to note that all financial uncertainties are difficult to predict and resolve beforehand.

in offshore outsourcing, where coordination costs might be much higher than domestic outsourcing, financial risks may also increase.


email will be sent and received according to the predefined schedule.

we must be able to make a convincing argument that: 1.


2.2.1 By Allocation A user will select the By Allocation view to get a general feel for use of memory over time.

this mode can be used to discover churn, where the same memory is allocated, freed, and allocated again repeatedly.


I that assigns every client to an open facility so PP as to minimize f(i)+ c(j, f(j)).

i.Ij.C the goal is to minimize the total cost of opening facilities and connecting clients to open facilities.


First, if a sound tool ever reports a .ow of 0 bits, then it must be the case that the public output for that execution is the only one that can possiblybeproduced with any other secretinputs(forthatpublic input).

the case of 0 bits corresponds to the noninterference criterion for no information .ow.


Our proposed solution uses IA-32 EL as the execution engine for IA-32 native methods.

when the JVM calls an IA-32 native method, it will pass the control to IA-32 EL, which translates and executes the method.


3.2.3 Threats to validity In our case the reliability of the measures (i.e., I and Mojo) may condition the observed results.

the main issue of the measure used for assessing the evolution concerns the fact that it Version Persist.


Despite the availability of these techniques, their application to analyzing latent information in software artifacts is still a topic of research.

we have investigated a number of text analysis techniques that can be added to an aspect mining tool, so as to take into account the three characteristics stated above.


We observed that the hybrid spectra were generally more accurate than the software-only spectra across both defect types.

di.erent types of defects did not cause any noticeable differences between the relative accuracies of the hybrid and software-only spectra.


The article also shows how overlooking roots enable more powerful versions of past optimizations, and how new optimizations can be devised using them.

it shows a new and aggressive form of lifetime subsumption called ORCS.


A self-enactor is a self-interpreter enact that mimics evaluation: Self-Enactor: t .

* v implies enact( ' t) ' v. (2) if t evaluates to a value v then enact( ' t) is behaviourally equivalent to ' v. Note that this account requires knowledge of the values v and the evaluation process .


We remark that it is the .rst time to discover the .rst .aw (while the second .aw has also been observed by Dawson and Goré [7]).

the discoveries show one bene.t of exploiting a theorem prover for rigorous veri.cation.


4.3 An effect-based CPS transform Instantiating the answer type in a polymorphic CPS transform allows us to obtain more complex CPS transforms from simpler ones.


In short, just as in social structures, scalability appears to demand delegation and diffusion of authority.

while having lots of little components makes it possible to assign precisely the least authority to each one, this over-burdens the programmer who is responsible for linking them together.


Also let w(X, 0) and w(Y, 0) be the initial index locations of the two pointers.

a valid s-step warppath must satisfy thefollowing conditions: The two pointers initially point to the beginning of respective requests.w(X, 0) =1and w(Y, 0) =1.


We developed a PlaceGroup library for ef.ciently managing large groups of places.

we support ef.cient broadcast over place groups using spawning trees in order to parallelize and distribute the task creation overhead.


Among the nine alternate inputs contributing to the bug report, we .nd out which of them are successful , that is, their observable behavior is as expected by the programmer.

the program output for a successful program input should be the same in both the program versions.


In this paper, we present an energy-aware adaptive middleware architecture that tackles some of the challenges of energy-aware middleware.

we propose an architecture capable of handling various types of energy optimization techniques that can be build on top of an adaptive middleware.


Furthermore, in the dual space, l can enter other cells only if it crosses one of the cell boundaries, including, conceptually, a boundary at infinity.

as shown in Figure 3, l cannot intersect p4, before it crosses one of the current cell boundaries.


Therefore, the respondents were asked to indicate how certain UML modeling constructs should be implemented.

the respondents were asked to indicate how strictly they believe the following correspondence rules should be applied in a software project:  The package structure in an implementation should correspond to the package structure in the design.


(ii) We then observe that, on these neighbourhoods, A behaves like an OI-algorithm: A s output cannot change if we relabel a node in an order-preserving fashion, because the changes in the output would have to propagate outside of A s run-time.

our simulation OI r ID will work only on certain types of neighbourhoods (in contrast to our previous simulations), but this will be su.cient for the purposes of the lower bound proof.


ASSUMPTIONS AND THREAT MODEL Assumptions: First, we assume that the two parties of policy owner and request owner follow the preestablished collaborative enforcement protocol.

the enforcementpartydoes enforce thedecision madeby the other party.


The following two propositions establish that the maximal typing, i.e., the typing that maps each x to max(S(x)), maximizes the above objective function.

the maximal typing computed by our inference procedure is the best typing.


The relation /.Val ×(mPat)relates concrete and abstract values such that v / P means that v is abstracted by P. We mention (without proof) that any concrete value obtained during execution of the program can be abstracted by a modeling pattern that is perfectly accurate.

the latter abstracts only one concrete value, which is the former.


Table 1 lists the notations that are used in this work.

variables S, T , and U stand for atomic types; superscripted variables S. , T .


Also, in addition to type annotations on expressions, OCaml provides several ways to introduce explicit type informations (and thus obtain the acyclicity condition): datatype de.nitions (explicit types for constructor and exception arguments, record .elds), module signatures, type annotations on ML pattern variables.

because of its global .ow analysis .avor, OCamlDuce s type system is much less modular than OCaml s. all the call sites of a function which expects XML values as arguments can contribute to the result type of the function.


We are studying techniques for automatic generation and installation of recorders.

we are investigating the possible degree of automatization for different technologies, e.g., Enterprise Java Beans.


The rationaleis clear, as wider candidate scan anglesprovide adaptiveMSP more opportunityto choosethe one approachingthe optimalangle.

8.6 SimulationSummary Starting from basic MSP, we have demonstrated step-bystephowfour optimizations canbe applied ontop of eachother toimprovelocalizationperformance.these optimizations are compatible with each other and canjointlyimprove the overall performance.


(2) Our type analysis works as an extension to bytecode veri.cation, within the existing mechanism for loading and linking.

the analysis does not require any classes to be loaded or linked earlier than they would be in the existing JVM.


In the case of a branch pointing to the future, we consider behaviors immediately preceding the anomaly, i.e., immediately preceding the extension start point, alternative to the anomaly, i.e., between the extension start and end points, and immediately following the anomaly, i.e., immediately following the extension end point.

we consider the event sequences that can be obtained by concatenating the sequences of maximum length k1 that can be generated before the extension start point, the sequences of events that can be generated between the extension start point and the extension end point by traversing each state at most twice, and the sequences of events of maximum length k2 that can be generated after the extension end point.


All members of a lockstep group are within the same workers group.

a lockstep group cannot have members in more than one workers group or more than one control group.


Behaviour T A As we shall see, their implementations are quite different (behaviours are implemented as pull systems, and events are implemented as push systems).

the event function introduces no overhead, but the bu.er function introduces buffering, and so may have a signi.cant memory overhead.


While the example storyboard could be complied into an automaton, not all storyboards can be.

the tool has di.culty identifying State information that is not tagged.


In this case DHCH = 0 if and only if DH = 0, i.e., X1 = X2 = ··· = Xn-f.

if all nodes in subgraph H are fault-free, and Xi * Xj for two fault-free nodes i, j,then DHCH * 0 and hence the check in step 2 of Algorithm 1 fails at some fault-free node in H. We then further show that, for large enough L, with a nonzero probability, this is also simultaneously true for all subgraphs H .


In contrast, weak locations describe zero or more locations, and it is safe to treat null as a subtype of any weak location (U-NULL).

weak references are nullable but strong ones are not.


This suggests that a simpler, less general approach speci.cally tailored to this case would already enjoy a broad applicability.

just the introduction of non-null types would be a very valuable help to practitioners.


100 These parameters show that the logical and compare type of instructions will probably produce correct outputs even though their inputs are partially wrong while move and other type of instructions will de.nitely produce wrong outputs if any input is wrong.

an error will probably be propagated via move and other type of instructions while it may be canceled out via logical and compare type of instructions.


CHECKPOINT SELECTION BASED ON SC AND WC TEMPORAL DEPENDENCY Among CSS1~CSS8, [14] has experimentally demonstrated that CSS8 can improve the checkpoint selection and eventual temporal verification efficiency significantly than other strategies.

cSS8 is the best one among existing representative strategies.


Second, the expression layer is state free, with all local variableinstantiations lost between execution cycles, and the coordinationlayer state is only retained on wires.

explicit feedbackwires from a box s outputs to its inputs enable individual boxes toretainstate between execution cycles, andare the basis of box itera-tion.This addresses many problems encountered in other high levelapproaches to FPGA programming, in which complex synchronisation protocols must be made explicit at the expression level.


Based on the yin-yang principle, we argued that equal attention should be given to the system model as well as the user model in user-centered software development.

we proposed the use of video-based scenarios as a representation of the user model and illustrated the use of scenario videos in a project course.


8 cc uc Y= F1 (X,Xc,Y ,f1) > 1 > > > ··· > < cc uccc Yi = Fi (X,Xc,Y ,Y 1 , ··· ,Y i-1,fi) .

(fi)i=l > ··· > cc uccc > > Y= Fn(X,Xc,Y ,Y 1 , ··· ,Y ,fl) > ll-1 : ' K (X,Xc,Y uc) whatever the valuation of a tuple (x,x c ,y uc ,y c), there exists a valuation (vfi )i=l of (fi)i=l such that yic = c cuc Fi (x,x ,y ,vfi ).


For example, for the Using these local coordinates, the constraint of the top of the hexagons can be derived directly from the constraints of the opposite dependence cone.


The workshop participants enjoy the opportunity to express their story ideas in game form, and appreciate sharing their games with friends or family members.

we have explored how Neverwinter Nights can be used to create interactive stories in which the outcome of the plot can be influenced by the player.


4 This assumes that the .rst instruction for iteration i will be issued the cycle after the branch instruction for iteration i-1.

we assume perfect branch prediction and are thus giving the SPE as much credit as possible.


The behavior of the communication in cases three to .ve is controlled by two parameters, K and D. As can be seen in Figures 1, 2 and 3, K controls the size of each tile and D speci.es the delay (in tiles) after which the application will block waiting for a network operation to complete.

d determines the size of a non acked window.


First, we examine the performance of Memory MISER under jobs that use the entire system, with the individual nodes allocating data at the beginning of execution and deallocating it afterwards.

we examine the energy savings during a run of the Parallel Ocean Program (POP).


This approach avoids the need for a new translator and simpli.es the logic of integrators processing imported requirements speci.cations.

after the paragraph to section transformer has been loaded into In.niTe s structure server, the cohesion integrator can simply ask a requirements speci.cation document for its information in section format.


In this paper we study the expressive power of some of these languages.

we show that: (1) recursive procedures with parameters can be encoded into parameterless recursive procedures with dynamic scoping, and viceversa.


B/n+be To understand the extent of this loss in power proportionality, we built a data layout simulator that allows us to understand thefactors on which thedegree ofpowerproportionality depends.

we investigate the dependence on the total number of datasets stored in the cluster and the number of live datasets.


convertu(downu(D0)) t .T is the current output value; while the parsing phase de constructs a value, the unparsing phase constructs it.

further-if the given set of con.gurations is empty, we return an more, while the parsing phase takes a single input value for all empty set of results.


However, as we keep exploring this component, we discover that it sends the same message again in a different execution, and we can thus safely skip the expensive exploration of the other components under this same message.


For these reasons, the  (b) IBM Real-time Linux (2.6.16RTJ12-SMP) Figure 2: Thread Scheduling Accuracy RTAOTcompiler cannot use information about .elds, methods, or classeswhile generatingcodeaseffectivelyastheRTJIT compiler can.

the AOT compiler cannot perform aggressive inlining and must generate all static, .eld, method, and class references as unresolved.


Definition entry of an Activity          In the definition entry, detailed information like Activity name, launch mode and other attributes are specified.

information about what kind of data can be accepted is defined in the tag intent-filter .


The team members with whom subjects interacted were all actually virtual entities: confederates, which were controlled by a member of our research team, so conflicts could be inserted in a controlled manner in the otherwise unpredictable activity of programming.

both direct and indirect conflicts were inserted in the exact same manner at the exact same time related to when a subject started a certain modification task.


For other EPLs, the action handler is coded as the right-hand-side in the EPL statement itself.

the left-hand-side defines the match, and the right-hand-side defines the action.


The code of the computation-at-jp is reused.

the computation strategy b-control-a is common to call-jp, fset-jp, and fget-jp.


For applications like AMG and phdMesh, we can extract signi.cant similarity with a small increase in metadata.

for phdMesh, if we allow the metadata to occupy even a small fraction of application memory we see dramatic gains in the number of similar pages.


Following the interview, the researcher devised specific level design patterns based on analysis of designers interview data.

the researcher extracted examples addressed in the interviews and searched the other games to find similar segments under the same constraints.


Objects are automatically removed if any change is made to their class or if the project is closed.

the potentially time consuming set up phase, where objects are constructed, must be manually repeated after each compilation.


This inconclusive task timing result is in contrast to the categorical results we observed in terms of the correctness and e.ciency of the code J written by the participants and the synthesized code S derived from the programmer s abstraction function A.

the choice of technology does not have strong predictive value for how long it will take a programmer to produce a .rst draft, but it does strongly predict whether that .rst draft will be correct and e.cient.


The composition in Figure 3(a) results in an undesirable interaction: On the path from (s0,t0) to (s3,t2), message rvm.voicemail; comes after cb.reject; .

we may record a voicemail message from a blocked caller.


Throughout this paper, we will assume that acquisitions and releases of locks are nested.

locks are released in the reverse order of how they were acquired.


In summary, the experiments described above suggest that in most cases, PSE is both scalable and precise enough to diagnose real failures in real programs.

the situations where PSE lacks precision appear to match those where PSE consumes unusually large resources.


In terms of performance, however, the results show that FASTTRACK signi.cantly outperforms the other checkers.

it is roughly 10x faster than BASICVC and 2.3x faster than DJIT+.


this typically implies that the geographic locations of v and w are relatively close to each other, and therefore it is likely that there is also a short path in the operator s backbone that connects v and w. if algorithm A is local (in terms of graph G), then each SDN controller only needs information that is near it (in terms of shortest-path distances in the operator s backbone).


The steps of Figure 1 have been followed to integrate DEUS.

the class DeusState, extending NewState,has been provided, a detailed discussion of which is given in [22].


While it is possible to select the processor from whom to take iterations randomly, in our approach this selection is also made through an analysis at compile time.

for each bin, we associate an affinity index (at compile time)  AI , which points to the bin that exhibits good data reuse between them.


In this scheme, when a disconnected node of higher class cannot .nd an empty slot, it will displace/preempt a node of a lower class.

when disconnected, Contributors may displace noncontributors, whether Entitled-NC or Excess,and Entitled-NCs may displace an Excess node.


For synchronisation, the algorithm invokes any algorithm-speci.c interfaces that components are known to export, as determined in the constraint checking step, in addition to the services provided by the connector class.

connector s block method allows pending requests to be aborted or queued.


The described healing by introducing synchronisation on a new lock is able to completely remove the detected bug, but on the other hand it can introduce new (and even more dangerous) bugs.


THE DEMO The demo illustrates SelfMotion by designing and executing a realistic mobile application for the Android platform.

the demo is organized in two parts: (1) App Design and (2) App Execution.


In the experiments described below, such interactions were resolved in the way that re.ects each language feature s costs most faithfully.

the cost of unnecessary reference counting was evaluated with fully dynamic typing and no unboxing; the cost of container boxing was evaluated with unboxed numbers.


V if and only if v and w are neighbors and share at least one network interface (i.e., communicate).

given a node v, in the following we will denote by NG(v) the neighborhood of v in G. given G = (V, E) we associate with each node v .


, ri(vi)} we de.ne its goodness the following value: X G(R) = RP(ri) · vi i The meaning of the addition and multiplication operators are overloaded in order to cope with the non-natural resource types.

in the case of boolean-typed resources we consider the boolean value true as if it was the natural number 1 and the boolean value f alse as if it was the natural number 0.


When these elements match, the lookahead-based algorithm chooses the bind, otherwise it chooses the unparse.

when one of these elements exist but not the other (as above), unparsing is chosen.


as speci.ed by Expression (11), after scaling the voltages/frequencies of the communication channels, the start times of the Qth iterations of loops x1, x2, and x3 cannot be later than 170, 210, and 190, respectively.


In addition, point (2) suggests that they work on each component not only from less detailed to more detailed representations, but also back to less detailed from more detailed representations and have a rethink.


While we do not posit hypotheses, we expect a distinct social network pattern will exist and in turn will be indicative of eventual success for the central candidate in becoming the Republican Party s nominee.

the candidate sharing the greatest number of donors with the other candidates will likely be more successful in the nomination process than candidates that are not included within this multiple donor network.


taxation, can improve the outcome of Nash equilibria in congestion games with failures.

we can price the facilities to reduce the total social disutility of Nash equilibrium -the sum of the agents disutilities plus taxes paid.


Hopefully, by taking the time to explore the design space for ordering invariants, I have exposed some transferable lessons.

we must overcome our type inference training and learn to see types as pushing requirements inwards, as well as pulling guarantees out.


The assumptions made throughout each of these scenarios is that technology similar to VoiceYourView would be available.

we make no assumptions about more sophisticated forms of NLP but restrict ourselves to semantic tagging and semantic analysis in corpus linguisitics-based approaches.


Notice that, in the interference graph model, each variable/name is considered as an atomic object, i.e., it will be placed in the same register all along its live-range.

borrowing the subtle title of Cytron and Ferrante s paper [15], what s in a name has already been decided and no more live-range splitting [13] will be done.


30 95440 Bayreuth, Germany felix.schwaegerl@unibayreuth.de 95440 Bayreuth, Germany sabrina.uhrig@unibayreuth.de 95440 Bayreuth, Germany bernhard.westfechtel@unibayreuth.de  ABSTRACT Inadequate version control has been identi.ed as a major obstacle to the application of model-driven software engineering.

sophisticated support for merging model versions is urgently needed.


Most fundamentally, Rugina computes the size of arrays backwardly, i.e., he draws information from array accesses, we do it forwardly, i.e., we draw information from allocation sites.

from an array access such as *a = e, Rugina assigns to a a minimum index given by e. and a maximum index given by e..


Second, our experiments show that on current architectures, a single level of cache tiling and modest prefetching are adequate to generate high-performance matrix multiplication code.

it is su.cient to tile approximately for the L2 cache on most current architectures, so adapting to all levels of the memory hierarchy by generating a range of tile sizes using divide-and-conquer appears to be unnecessary.


Finally, constructor Close represents a behaviour on a channel system with an open channel c and continues with a behaviour with that channel closed.

the behaviour r' = (Close c r) has channel c open, but its continuation r must have it closed.


While various implementation techniques and frameworks exist for de.ning DSLs, language composition has not obtained enough attention and is not well-enough understood.

there is a lack of precise terminology for describing observations about language composition in theory and in existing language-development systems.


Let P (l) be the set in the generated partition P(l)  PF (l) of largest cardinality and c(l) = |P (l)|.

max (l) (l) cmax represents the largest consent found between the nreplicas at the end of voting round l. Then, in order for the majority voting procedure to be able to adjudicate the result of the scheme, there should be a consensus amongst (l) an absolute majority of the n(l) versions, i.e.


Both the multicast tree and mesh protocols use a shared data structure approach.

they assume that for a given multicast group, there may be multiple senders.


To solve this problem we impose the rule that if a process loses in A when it has already won a (deterministic or randomized) splitter object in RatRace, then the process continues to execute RatRace.

we use the following rules to combine the two executions with the help of an auxiliary LeaderElect object LEtop.


Fixing an input vector x to a randomized balancing network induces a probability measure P on associated events.

it induces for each layer f with 1 = f = d(Bw) a random vector y(f); y(f) is determined by (i) the (random) input vector x(f)and (ii) the random variables rb corresponding to the orientation of the balancers in layer f. Write y = y(d(Bw)) to denote the (random) output vector of Bw;hence, Bw(x)= y.


However, we identi.ed some important limitations with the current state of the art as will be discussed in more detail in Section 2.

most of the approaches require (1) browser modi.cations or server-side pre-processing e.g.


A pre-condition (condition C2 in [16]) necessary for the validity of the procedure in [16] states that for every state s in model M, the probability that a path starting from s satis.es .1 U .2 must not lie in the range (0,d2/(1 - ps)N], where N is the number of states in M , and d2 and ps are user-speci.ed positive parameters.

if the probability of any path satisfying .1 U .2 is p (> 0), then d2 must be selected such that p>d2/(1 - ps)N .


Type array s second parameter, ß, is a stamp used to tie it to its capability, which must have type ß cap (where ß matches).

the type of new indicates that it returns an existential containing an array and a capability with matching stamps.


So to encode halt, we ll use non-termination; that is, we use the nonterminating program Omega as the abstract encoding for termination.

we apply the following rewrite rule after conversion to a binary CPS that contains a halt primitive: halt =.


The set of symbols of arity k is denoted by Sk.

s0 is the set of constant symbols (representing terminal tokens in AST), S1 is the set of unary symbols, , Sk is the set of k-ary symbols.


a value from (v1 ,v2 ,...vn), we create a new version of the speculative state.

the speculatively computed results generated by each of the executed sections of code in Figure 6 are separated from each other.


Transformation-The core of our approach relies on model transformations.

we propose a process language named AF-RDL (Aspect-oriented Framework-Reuse Definition Language) that takes as input a framework model (e.g., aspect diagram) and based on inputs from application developers generates application instances models.


Table 6 describes test results achieved by the Similarity Flooding algorithm, the V-Doc System and the Cupid algorithm.

table 7 summarizes all their global performances along with the Indigo s. the two last columns present the results obtained with Indigo forboth (1)averagebased and (2) stacking-based alignments.


The purpose of con.nement is to restrict possible dependencies via pointers, to facilitate local reasoning.

we consider an instance-oriented notion of con.nement: a single object can own some others called its reps thatmustnot bepointedtoexceptbyeach other and by the owner.


This poses a more subtle problem when having to select the right order in which to solve them (in the fully imperative case), and also serves as a stress test for the transcoping process presented in this paper.

for simpler invariants (such as, for instance, that of singly linked lists: merely acyclicity and the size matching the number of nodes), the different alternative con.gurations are just a few, making the problem of correctly selecting the right order for generation a much easier one.


This phase ordering problem of register allocator and scheduler could also have negative effect on the code quality, resulting in an even worse WCET.

[14] and [15] pointed out that scheduling solutions are especially critical for VLIW style machines.


While the .le can be loaded, there is a restriction on commands that can be used to manipulate the .le [28].

due to changes in the underlying representation, the command INTEGER PRI-MARY KEY is disabled; after upgrading the .le format to 2.2.0, the command INTEGER PRIMARY KEY can be used normally.


In recent years, the emphasis of research and practice on CBSE has changed from functional aspects to non-functional ones.

reliability of component-based systems is considered as one of most crucial and non-functional properties in CBSE.