We also consider a class of action constraints, reminiscent of Featured Transition Systems [11].

while transitions in FTSs are sub ject to the mere presence of features, in our approach we associate arbitrary constraints to actions rather than transitions.


Obviously, the risks and bene.ts of switching to a COTS component at this time vs. struggling on with the in-house implementation must be assessed very carefully.

we believe that developers in such a switch or struggle situation cannot simply resort to established COTS requirements engineering [7], risk assessment [6] and candidate selection [3] methods, as the late project stage enforces much tighter constraints than those methods assume.


Similar to the Java Card VM, Java Card applets execute forever (or until they are explicitly uninstalled).

applet instances return to the suspended state upon power loss.


At the boundary of two regions, equal contribution comes from each of the regions.

at the pixels near the boundary, closer region should contribute higher.


Typically, the static analysis results direct where the dynamic analysis should be applied (e.g., the placement of code instrumentation by a compiler).

the blended analysis paradigm uses dynamic analysis results to guide a subsequent static analysis, that may itself use dynamic information to achieve greater precision.


On one hand, this data supports the distribution of modules better than the data in non-aggregate descriptors since modules may be further segmented and distributed at processing nodes down the tree.

this data is very useful from the point of view of special resources.


Clone detectors automatically locate code clones, resolving the .rst issue.

programmers still need to update code clones manually one by one when the same change is required, leaving the second issue unresolved.


Moreover, as shown in the previous section, cheating by exploiting misplaced trust can lead to the theft of information, improper modi.cation of game characteristics, or both.

these traditional aspects of computer security are insu.cient to cover all the consequences of online game cheating.


aim to determine short-term resource demands and long-term capacity requirements for multiple applications sharing a common set of resources[2].

this problem is di.erent from ours: the problem there is to arbitrate between multiple disjoint applications competing for the same resources.


On one hand, it is able to withdraw data from business systems and submit data to data center.

it realizes the function of transmitting data received form data center to business system.


This also has to be considered when deciding whichcomposition technique should be used.

virtual classes can be hidden from the application developer in some scenarios: 1.


Alpha and Beta were formal reuse efforts but they were also small efforts since they only consumed the attention of a small division of the corporation.

reuse has also been tried at a much broader scale, which I call reuse in the large.


It is possible to have more than one thread to execute one actor and similarly to have only one thread executing multiple actors.

the actual message processing is always executed by one thread at the time and the messages must be immutable in order for the model to work correctly.


Our tool 676 358331 396 69 42 42 CP-Miner 582 534202 251 55 13 13 CP-Miner also assumes that inconsistencies among clones indicate bugs.

its de.nition of inconsistencies is local to the Table 7: Comparison with CP-Miner (Linux kernel 2.6.19).


The setStyles method, on the other hand, already existed in the .rst version of jEdit we studied.

during its evolution, it became incohesive and rede.ned a token type, silently contributing to the syntax highlighting feature.


In the last years many researchers have migrated work.ow systems onto the Cloud.

the current implementations mainly address a single Cloud.


Additionally, introducing new accessors in a trait results in a ripple effect, as all client classes must now provide implementations for these methods [8], even if there are no other changes.

cZ allows a class to multiply inherit other classes, which may contain state.


We and others have typically claimed that we want to modularize feature representations to make features explicit in design and implementation, to reason about their implementation locally, and to compose them .exibly.

others have repeatedly challenged that many contemporary forms of feature-oriented programming provide merely syntactic compositions, lack proper interfaces, and provide only closed-world reasoning.


Based on this aspect, HybridFS was designed to keep metadata in SSDs.

in HybridFS, data are sequentially stored in HDDs because HDDs generate good I/O performance with sequential, big files.


With this limit, Figure 4 shows that all the traditional mechanisms can only support around 2000 players in the same game.

the proposed hierarchical mechanism is able to support more than 4000 players and is therefore much more scalable than the traditional mechanisms.


Delay in scheduling these tasks directly impacts job completion time.

scheduling just these last few tasks preferentially has little impact on other jobs since it is taking away only a small amount of resources.


The techniques presented in this work can be applied to any online class.

presenting this work in the context of a data mining class is especially rewarding.


We perform model checking directly on the multithreaded program.

in order to gain reuse and scalability in our analysis, we present a novel method to compute procedure summaries even in the presence of multiple threads.


Source-to-View Functions with Equality Tests In the previous section we already used Eq-constraints for delivering good put-functions.

the get-functions taken as input had to be fully polymorphic, and for good reason.


In summary, the design metrics and anti-patterns produced by both JDepend and SA4J led us to focus our attention on certain components in the architecture.

these tools could not help us with further reconstruction and deeper analysis of these components with the customizable capabilities we need.


Critically, these predictions only use EEG data recorded before the students even saw the cloze question.

certain independenceassumption violations put the strength of our significance tests in question.


The JAC authors propose implementing JAC by source rewriting, creating a new type readonly T that has as methods all methods of T that are declared with the keyword readonly following the parameter list (and then compiling the result with an ordinary Java compiler).

the return type of any such method is readonly.


Usually, SSE2 FP instructions run faster than x87 FP instructions on Pentium4 processor.

for those FFT programs, the -O3 option achieves better performance than -fast .


It is generally understood that, in order to follow the REST style, URIs should be assigned to anything of interest (resources) and a few, well-de.ned operations (e.g., HTTP operations) should be used to interact with these resources.

for example, the state of a purchase order resource can be updated by POSTing (or PATCHing) a new value for the its state .eld.1 as it has been identi.ed by other authors [5][7], there are actions that cannot be easily mapped to read or write operations on resources.


When pointers are interpreted as integers, we see that on the Alpha two adjacent and aligned integers must have appropriate values in order to be interpreted as a pointer.

thus it is unlikely that integers will be mistaken for pointers on the Alpha) point- ers map to only a single (though large magnitude) integer on the Pentium and SPARC; thus it is more likely that a conservative garbage collector will retain dead objects on these h;rdware plat- forms.


The type system of XDuce has similarities with string analysis in the sense that it is based on the theory of formal languages.

xDuce does not directly work on strings, but on trees representing XML documents.


To sum up, the advantage in chaining PVeStA to DEUS (if this would be possible), would be the possibility to express queries, and to automatize and distribute their evaluation.

the implicit ability of reusing simulations by logging would be lost, leading to a sensible degradation of performance when evaluating several expressions.


The language can be used to compose SPL models for a given set of features.

this work does not provide heuristics to identify features.


VMware partially addresses this issue by incorporating device drivers for a small set of supported high performance I/O devices directly into its ESX hypervisor product line.

this issue is non-issue for COS based systems where all I/O operates at native speeds.


In general, this segment is read-only for program instruction fetching.

in the case of applications with dynamically generated code (i.e., self-modifying code), the text segment could be overwritten.


Although the RTSJ does not de.ne any feasibility analysis, the setIfFeasiblemethod allows the Processing Group to be guaranteed.

it is not clear in the RTSJ speci.cation if this means that the budget is guaranteed, or that any schedulable objects assigned to the processing group is guaranteed.


Dynamic pointer-tagging wins on pure performance: a 13% performance improvement compared to semitagging s 9% on the 32-bit processor (14%/ 7% on the 64-bit processor).

semi-tagging wins comprehensively if we consider complexity: the changes to the compiler were small and localised, whereas dynamic pointer-tagging changesthe fundamental representation of pointers and hence requires non-local changes to the compiler and runtime.


While a relatively small amount of information is transported, this approach suffers from the problem that HTTP was not designed for implementing remote applications, but rather for sharing static data.

the remote frame buffer approach operates on the premise that compatibility with existing applications is paramount at the expense of network bandwidth.


This poor design decision resulted in useless instructions like SetWatch(hour,minute) in which hour and minute can only be integer constants.

there are tens of thousands of RCXs in circulation.


Infact,as wewill seelater,inourtranslation,a methodinvocation requires no run-time checkifthe receiver andactualargumenttypes are all dyn-free.Then,a classdefinition that passes the standard type checking will translate toitself, without run-time checks.

the problem is more subtle than it might have appeared,duetothepresence of type variables.Ingeneral, type variables should not be considered dyn-free simply because type variables canbeinstantiated with dyn.Infact, the following classes, which are typed under the standard type system ofgenerics class StrCell extends Cell { void set(String x){ ... x.length() ... } } class Foo { void bar(Cell c, Y x) { c.set(x); } } willraise a run-timeerrorwhencombinedwiththefollowing code: new Foo().bar(new StrCell(...), new Object()); Thelast expressionpasses a StrCell and an Object to Foo.bar(), which expects a Cell and dyn, and this is allowed due to the extended compatibility relation we have already mentioned.


Objects in the sticky heap are born local, and can be reclaimed by local GC.

if necessary they can be globalised without changing their address, by .ipping a global bit attached to each sticky object (details in Section 5.5).


When we inspect the runtime structure as above (F6), all advices seem to be applied correctly.

the problem is revealed when inspecting the hook frame at the breakpoint on the .rst execution of getLine(), right after the advices have executed (F1, F3).


If CARE thinks that the user is walking alone, it will show search results or ads of restaurants within the user s walking distance from the current location.

if it believes that the user is driving with their family, it will provide a list of family restaurants within driving distance.1 CARE relies on (i) a set of extractors equivalent of the pre-processing layer of Fig.


Since publisher mobility causes expensive reconstruction of advertisement and multicast trees, it may be tempting to eliminate advertisement .ooding and .ood subscriptions instead.

subscrib ers typically outnumber publishers, so the savings in publisher mobility induced tree rebuilding cost do not justify subscription .ooding.


Systems like PIER [16] abstract details of transport protocols, message formats, marshaling, etc., away from the data.ow framework, and operators only deal with fully unmarshaled tuples.

p2 explicitly uses the data.ow model to chain together separate elements responsible for socket handling, packet scheduling, congestion control, reliable transmission, data serialization, and dispatch.


Cesar s sequencing analysis is based on a state propagation algorithm similar to the state mapping algorithm described in this paper.

cecil is restricted to sequences of procedure calls and does not provide means to specify assertions and maintaining knowledge.


At present, we have not identi.ed large threats to establishing internally valid treatment-outcome relationships from the experiment.

future investigations may reveal confounding or missing variables that should have been included in the analysis.


This is because the migration operation requires frequent mapping/unmapping of memory pages owned by a guest VM to the address space of the management tool.

our survey indicates that most commodity operating systems (e.g., Linux, Solaris and BSD) usually use a per-process lock to serialize mutation to an address space.


Finally, Maya allows overloading of syn- tax based on arbitrary static types sad does not require the base-level program to explicitly refer to metaprograms.

open Java only allows syntax overloading based on classes that explicitly instantiate a metaclass.


This reorganization a.ords several advantages, including improved locality of reference and faster allocation, but comes at a cost: copying objects requires additional time and space, and potentially dirties more pages in the cache.

non-copying collectors [23] only attempt to reduce fragmentation by using unoccupied space to satisfy allocation requests.


This is possible because the greedy algorithm, which we use to solve the single-objective NRP, produces a single solution to an instance of NRP problem.

the NSGA-II, which is the algorithm we use to solve the multi-objective NRP, does not produce a single solution, but a set of solutions that form Pareto Frontier.


With the increase in the number of subscriptions, the number of groups in the hierarchical organization also increases (to scale with the computational load as mentioned above) and therefore the neighborhood information across the groups at the same level degrades, resulting in some loss of cluster quality.

the quality of clusters obtained by NCut can be enhanced by increasing the percentage of landmark subscriptions.


garbage collection is triggered after Thread 1 increments n at G but before Thread 2 does at H and the garbage collector moves shared object at address 0x8c to address 0xbc.


Federated computing has been explored in various contexts and has been demonstrated to be an attractive and viable model for e.ectively harnessing the power o.ered by distributed resources.

resources themselves may also exhibit dynamic behavior with varying capabilities, capacities, and availability over time.


Figures 6a and 6b considered each .eld individually.

an object may contain both mutable and immutable .elds, rendering the entire object mutable if it contains just a single mutable .eld.


One reason for this is, certainly, the criticality of the e-Voting process among all other democratic/governmental processes.

another equally important, in our opinion, reason is that the system proponents attempted to tackle the e-Voting domain in an abrupt, all-inclusive approach.


Task preemption The analysis of task preemptions led us to recognize that the RMA model of what constitutes a response is limited in a number of ways: A response to an event may involve multiple tasks of different priority.

the invocation of these tasks is deterministic in response to an event and thus has to be seen as a single activity.


ASPost .nds a relationship between the old and new o.sets of *PtrEndText.

this relationship is weaker than the manually provided one on which the inequality is an equality.


Proposals for architectural description languages and associated analysis techniques have .ourished [Luc95, Mag95, Tay96, Gar97]; constructive techniques have also been proposed for architectural re.nement [Mor95].

little work has been devoted to date to techniques for systematically deriving architectural descriptions from requirements speci.cations.


(3) Furthermore, the fragile ad-hoc network can bene.t strongly from the redundancy and resilience provided by structured peer-to-peer networks.

the random movement of nodes in a mobile ad-hoc network makes it challenging to deploy a structured peer-to-peer network.


Thus, Figure 1 shows the structure of the Composite pattern as an UML class diagram.

even class diagrams allow a developer to implement some aspects of the structure in many different ways.


A common time series processor, whose input is a time series with time stamps and values only, is merely in the position to provide a result which contains no information about the context of the data it processes, and the result needs to be processed again by another processor (typically a so-called Semantic Processor) to add a meaning to the output data.

a time series processor for processing semantically enriched time series has the ability to provide a result which already contains all necessary information regarding the meaning of the output, and therefore can be directly used in the targeted domain.


it cannot manifest on any sequential interleaving of the threads.

the .rst two manifest in a sequential interleaving.


On the one hand, there are works related to analysis of accessibility requirements.

works which follows MDD or a model-based design are included.


We initially tried to label bottom types with a single label ... .

that approach fails to capture the correct blame tracking behavior.


the cleanup code is completely different.


Of course there are substantial individual differences in the rate of decline and the amount of decline.

in general, aspects of memory (e.g., keeping a lot of information active in working memory), online reasoning ability, and aspects of attention such as attending to more than one source of information all show age-related declines.


Furthermore, it is estimated that the Web is still constantly growing at a rapid pace, doubling in size every 8 months.

most Web documents are designed primarily for graphical display and interaction.


This check violates our assumption that b should not check a.

if we adopt the earliest-start heuristic, lifetime a will be allocated .rst to register 0, and lifetime b is forced to be allocated to register 1.


The basic idea is similar to the sketched k-set approach to store data at k positions in the ID-space.

we are still in the process of designing a cheatproof spatial index we can use to e.ciently perform range queries to request the state of the game world in a certain area.


However, with the increased popularity of rating systems on the web particularly, sparse datasets become denser by time as ratings build up on the dataset.

most of the existing reputation models don t consider the distribution of ratings for an Permission to make digital or hard copies of part or all 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.


dev The driver was tested on a platform that con.gured the device in the memory-mapped mode.

the co-veri.cation environment simulated both modes, which allowed detection of the error.


Aligning the work performed, thus the data accesses, by a given processor across similar phases of a computation reduces its data access costs, potentially improving performance.

this needs to be achieved without interfering with the essential dynamic load balancing bene.ts of fork/join programs scheduled using work stealing.


This representation is higher-order and supports both re.ection (i.e., to map the representation of an expression to the expression itself) and rei.cation (i.e., to map an expression to the representation of the expression).

it handles rei.cation for complex values such as functions in a manner that seems too limited to support (practical) meta-programming.


4.1 Scenes The narration in  games is structured in interactive scenarios where the action takes place.

it is not the purpose of the platform to provide a complex, fullyfeatured tool for the creation of scenarios, but to simplify the game development process.


, EK inductively (for some appropriate value of K), where Ek, 1 = k = K, is an execution over k rounds.

with increasing k we decrease the number of processes participating in Ek.


The library as we have described it in this paper suits our current needs perfectly, as indeed we believe it will suit many other applications.

there are some areas in which it could be extended.


The actor model in particular appears to be more and more adopted in the mainstream programming technologies as an alternative to multithreading.

such an adoption often concerns the implementation level and the role of conceptual modelling and design is often overlooked.


Hipikat [32], which was developed at UBC, is similar in that it creates links between di.erent types of software artifacts.

these links are based purely on heuristics and Hipikat functions as a recommender system rather than a browsing and annotation system.


OpenVZ claims to be the virtualization tool that introduces less overhead, because each VPS shares the same operating system kernel.

openVZ is less .exible than other virtualization tools, like VMware or Xen, because OpenVZ execution environments have to be a Linux distribution, based on the same operating system kernel of the physical server.


Moreover, the gap between the energy consumption of our solutions and the lower bound is less than 6%.

we do not intend to show that our approaches are always better than slack reclamation for general cases, but, for multiframe tasks, we would like to show that existing slack reclamation approaches might not perform very well.


In the case of a write barrier, a runtime typically interposes itself on pointer .eld updates, conditionally remembering updates of pointers in certain conditions.

a return barrier [36], interposes special se mantics upon the return from a method (which corresponds to the popping of a stack frame).


At all times, the network should treat packets of types A and B from untrusted hosts as potential threats (e.g., A and B might capture packets destined for certain administrative servers), and monitor and possibly deny these packets based on an access control policy.

all packets from hosts attached to ports 3-6 should be allowed to pass through the network unmodi.ed.


Thus, managers and inspection planners have focused on maximizing the number of defects found in an inspection, and using that as a benchmark for comparing the effectiveness of different values for the inspection planning parameters (team size, meeting length, and page rate).

in the current political and economic context, efficiency has become a competing goal.


Dependent types have emerged in recent years as a promising approach to ensuring the correctness of software, with high level veri.cation tools such as Coq [8] and Agda [25] being used to model and verify a variety of programs including domain-speci.c languages (DSLs) [26], parsers [9], compilers [16] and algorithms [34].

since these tools operate at a high level of abstraction, it can be dif.cult to map veri.ed programs to ef.cient low level code.


The accuracy of these mappings can directly influence the results of the recovery heuristics.

to the best of our knowledge, we have relied on mapping heuristics that exploit feature mining techniques [12].


They rely on type-based alias analysis, and so their techniques should be much less precise than ours.

their paper demonstrates that even simple techniques can be surprisingly effective in .nding bugs.


In particular, architecture-based self-adaptation [17, 23, 25] leverages architecture models to enable highlevel reasoning about the best way of adapting a system, and is regarded as a promising approach to building resilient software systems in a cost-e.ective manner.

although architecture-based self-adaptation has been applied in practice and recent results indicate its potential bene.ts in terms of cost compared to embedded code-based adaptation mechanisms [8], there is still a lack of evidence supporting the arguments for its bene.cial impact on system resilience [31].


Source code of a drawImage method 5.3 Structural Clone Retrieval Using LCS The frequent statement sequences indicate the existence of the given sequences with the number of occurrences, as well as their location in the source code.

programmers would need to know all fragments that partially match a statement sequence.


Since Catamount only runs on X86-64 processors, SMARTMAP is currently limited to this processor family as well.

the concepts are generally applicable to other architectures that support virtual memory.


This leads to a di.erent set of design choices; for example, they use segregated free lists instead of a pointer-bumping allocator.

their collector also uses residency to determine which objects should be relocated and to balance the tradeo.


In addition, IDEs usually encompass tools to access software dynamics: debuggers to follow the execution .ow of a system, inspectors to study objet state and pro.lers to analyze the ef.ciency of speci.c system executions.

the ever-increasing complexity of software systems requires us to think about novel means to navigate large software spaces.


Naturally, such rules would have to be automatically generated to remain unobtrusive.

the behavior of the inliner and the INLINE pragma has changed substantially in the HEAD version of the compiler, including the introduction of a CONLIKE modi.er which increases the occasions where inlining is performed.


The bottom line is that all of them cause a substantial slowdown in execution time of the instrumented binary, in some cases to up to a factor 20.

since the virtual machine communicates with the dynamic binary instrumentation tool through an event handling mechanism, we can optimize the self-modifying code support.


AO language researchers have sought solutions in extensions to [20] and constraints on [1] join point models and advising.

providing new language features is costly and incurs risks in semantic complications, runtime costs and ultimately lack of adoption.


In the long run this challenge can only be faced by advanced software development techniques like product family engineering.

up to now product family engineering research has concentrated on software systems, where static diagrams like class diagrams or component diagrams represent the main blueprint for the development of the software system while process oriented software, i.e.


These times are then synchronous relative to each other, but the information about the real time gets lost.

our prototype implements the first option and calculates time offsets after measuring, since the results will be the same for both types of implementations.


We compared the minimally occupied selection heuristic of our greedy algorithm with random selection heuristic to .nd that our heuristic performed better, as expected.

since the overall fragmentation is not overwhelming, the random heuristic takes less time and might work well in practice; a theoretical bound on its time complexity is needed.


However, ODGs obtained from the previous parameters are superior to those of the new parameter set, since the previous parameter set was tuned using contemporary music included in the RWCMDB-G2001 database.


The cost of an operation, such as a move, can usually be represented by a cost on the edge that represents the move between allocation classes.

this is not the correct model for storing to memory.


As a .rst observation, we can see that for Zipf 1.2 and 1 fragment (i.e., experiments in Section 4), the load is severely unbalanced.

as we increase the number of fragments, the load balances itself quite well, and even for Zipf 1.2 remains below 1.3.


One consequence of the use of templates is that an error introduced in a template appears in all the components that use that template.

this is not a problem, as this multiplicity makes it easier to .nd and it can be .xed by a single modi.cation.


The above systems e.ectively enforce encapsulation for object .elds.

to support constructs like iterators, they allow method local variables to violate encapsulation.


APEG avoids ambiguities using ordered choice, so composition is, in principle, always possible using APEG.

if there is some overlapping between the rules of two or more extensions, the .rst option on the ordered choice clause will prevail.


Things are different if only assignment compatibility to supertypes of Superclass is required: as suggested by the example of ActiveTestSuite (Figure 3), this can be restored by letting Class subtype them directly.

if these types are interfaces, Class 3 In the literature, refactorings are often specified using preconditions alone.


Moreover, we wanted manyteams to get somewhere into the contest, and at least a number of teams to get very far.

getting very far should not be a direct consequence of being very knowledgeable about any niche domain within or outside computer science.


Indeed, we implemented a prototype of MLF and veri.ed on a variety of examples that few annotations are actually required and always at predictable places.

further investigations are still needed regarding the syntactic-value polymorphism restriction and its possible relaxation.


This problem was minimized through the development of content distribution networks, which bring the content to the user through proxies, thus preventing network bottlenecks between users and content servers [21].

the wide diversity of contents, users, networks and access devices led to the need for on-the-fly adaptations of Internet contents to meet user expectations, device constraints, and improve the use of network resources.


The two most important technical novelties of this paper are: We infer relevant object typestates in the presence of inter-object references automatically.

previous work has either required manual speci.cation of typestates, has restricted aliasing in certain ways, or has ignored inter-object references completely.


So, if one client struggles with a poor estimate for C(t), other clients are not penalized.

synchronization errors do a.ect the integrity of the motion reported by clients during update synchronization.


Characterizing Real-Time Reflexion-based Architecture Recovery: An In-vivo Multi-Case Study Nour Ali Jacek Rosik Jim Buckley Lero-The Irish Software Engineering Lero-The Irish Software Engineering Lero-The Irish Software EngineeringResearch Centre, University of Research Centre, University of Research Centre, University ofLimerick, Limerick Ireland Limerick, Limerick Ireland Limerick, Limerick Ireland Nour.Ali@lero.ie Jacek.Rosik@lero.ie Jim.Buckley@ul.ie ABSTRACT Architecting software systems is an integral part of the software development lifecycle.

often the implementation of the resultant software ends up diverging from the designed architecture due to factors such as time pressures on the development team during implementation/evolution, or the lack of architectural awareness on the part of (possibly new) programmers.


We further observed that when contrasting two slightly different con.gurations of an experiment (conditions), feature models allow to precisely pinpoint the varied con.guration element by comparison of the respective con.gurations on basis of a formal notation.

the value of the varied element can only be determined by comparing both con.gurations in their entirety even though only one element di.ers.


In the rare event that three buses are present at a location, the communication will happen only between the .rst two buses that arrive at that stop.

once one of the buses leaves the stop, the remain  to be deployed in a 4 km ×4km region.


INTRODUCTION Recently in various information systems the big technology development storage systems of the data (have received hardware drives, a web ± the environment, cloud computing architectures), allowing to store, practically, nothing information limited scope, productivity of the processor systems providing handling of such data has essentially increased.

in such situation the primary goals solved by information systems in a web ± the environment today, are connected more to handling of characters (data searching, inference).


An actual partitioning has to be performed to decide if actors have been .ssed enough number of times.

a good partitioning is achieved only when actors have been .ssed into suitably small units.


PERFORMANCE EVALUATION We have conducted simulation experiments using the QualNet simulator to evaluate the performance of the described resource discovery, resource distribution, and replica invalidation schemes.

due to space limitation only the performance of the replica invalidation is reported.


Whichever way, the undertaking is expensive.

this paper s approach allows for the direct reuse of existing data-.ow transformations.


In the case ['current has been mapped with MS', this means using the design criteria and metrics proposed in the paper, we were able to find a valid solution for 65% of the total process graphs considered.

using AM to map Fcurren t has led to a situation where IMS is able to find schedules which satisfy the deadlines for o~y 27.5% cases.


In fact, DINAR may not be the only reason for the improved performance because the subjects have different programming skills and familiarity with refactoring tools.

developers were not assigned to groups randomly but according to their programming experience to reduce the gap between the different groups.


Given a set of cover images, in principle it should be possible to extend the distortion function to measure distortion in multiple images (perhaps by simple summation, perhaps by a more sophisticated de.nition) and apply Gibbs embedding to the entire set of images, performing at a stroke both batch allocation and embedding using a strategy which optimizes distortion.

this is not straightforward: the de.nition of distortion should not necessarily be simple summation, particularly if the cover images are of di.erent sizes or very heterogeneous; there is the underlying limitation that the optimality of the embedding depends on a close relationship between distortion and detectability; .nally, there is as-yet no available implementation of Gibbs embedding in multiple images.


In particu- lar, stall time is reduced by 32% when PrefClus is used compared to the MDC solution, while it is hardly reduced when MinComs is used instead.

the DDGT solution increases com- pute time.


As a result, lpWDA-AC consumes more energy than lpWDA.

in lpWDA-DP,since the lower-priority tasks are usually complete its execution before the preemptions, the unused time of the lower-priority tasks can be utilized by higher-priority tasks, so that the higherpriority tasks can be scheduled with lower clock speeds than in lpWDA.


According to the obtained results presented in Table 13, 96.4% of cases can be correctly classified as type 2, 3, 4 or 5.

estimating misclassification rates in this way is known to be too optimistic and different alternatives for estimating misclassification rates in discriminant analysis have been proposed.


Semantically this leads to the presence of non-strict and non-deterministic functions, which have been shown quite useful for practical declarative programming.

equational reasoning is non valid for reasoning about programs because of the non-determinism.


On one hand it is straightforward to see that a VPA for XML document validation can be represent as an ASM naturally, ASMs provide the much more expressive computational model.

the advantage of the ASM approach is that it provides a single speci.cation dealing with any kind of EDTD only an encoding of the EDTD in two input relations element and sibling is required.


msecu onse time res and server is switched, a user is not aware of VM migration because the connection between VNC client and proxy is preserved.

all the pending data in a VNC server and virtual devices is lost at a source host.


High-level languages allow users to de.ne compound types.

these types are often by default boxed .


For example, a graduate student spends all her time dreaming about her .rst tenure-track job, and she feels a peak of happiness when she .nally secures it.

our new professor now moves in social circles where all her friends have tenure, leaving her feeling like she s not doing as well as her friends, causing her happiness to return to the baseline.


On one hand, geometric predicates compute Boolean-like properties, like the orientation of three points in the plane, or the decision whether two segments intersect.

geometric constructions build new geometric objects or numerical quantities, like the computation of a distance or the intersection point of two lines.


The KS-Test decided according to our manual decisions for the test data series.


For all capacity levels in Table 4, Zombie results in the largest number of writes among all realistic failure tolerance mechanisms.

the best ZombieSLC mechanism is not the same for all phases.


In a sequential program, a program with instrumentation may only run slower.

in multithreaded, distributed, and concurrent applications, such disturbances may change the timing of thread/process synchronizations, therefore, altering the execution paths in the global state space.


The BPMN editor may also be used to display the query results on top of the original model (for example, by coloring the result set).

in case of large result sets it becomes hard to di.erentiate between di.erent matches, and there is no generic, editor-independent way to implement this functionality.


It performs 5 iterations of gradient descent in a mini-batch and therefore potentially gains more information about the higher order structure than SGD.

the convergence is much more stable when solving the conservative subproblem by coordinate descent.


It is not dif.cult to see that the skip graph has logarithmic diameter and maximum degree and allows hypercubic-style routing between any pair of nodes in O(log n) time, w.h.p.

the nodes cannot locally verify the correctness of the skip graph topology.


Our proposal can help programmers develop software systems with hard a.nity.

not every scenario is suitable for hard a.nity, the developers can choose hard a.nity when they can assure the a.nity they set can improve the performance of the program, comparing to the automatic scheduling by the operating system.


Aircraft#1 is available on Thursday (Th) to support Flying, but the Cargo is not.

both the required Labor Resource and Aircraft#1 are available on Wednesday (as indicated by a pair of green bars) so the quadruple can be set and added to the schedule for Maintenance.


Notable examples of applications ideal for perpetual operation include wildlife tracking (ZebraNet [13]), volcanic eruption monitoring [31], and forest .re detection [20, 12].

despite their deployment advantages, systems that employharvested energyface numerous challenges.


Such an idea exactly re.ects the intuition that a re.ned component more easily reacts to invocations to its provided methods.

inreal CB-MDD,comparison between components should include not only the ability of reaction to invocations fromtheenvironment,butalsothe functionsof their corresponding methods.


The semantics of the adds clause for A in P1 is that its contents should be added to the class A.

thus, one could suggest de.ning the the resulting closed package P1 as follows: package P1 { class A { void m(Object o) { ... } void f() { m("Hello World"); } void m(String s) { ... } }} the source code for A shown directly above does not preserve the behavior of A as it was de.ned in the template T1, since the call to m in f will now bind to the overload taking a String instead of the original version taking an Object.


To solve this problem, contents providers have been used a content creation method that creates multiple versions of same contents by devices types.

this method also has the problems that are rapidly increased maintenance and creation of costs by the number of devices and contents.


The data transfer delay can be minimized as the initiator device can simply choose nearby devices to execute tasks.

it is much more dif.cult for a complicated communication graph, such as the complete bipartite graph used in MapReduce [13], to achieve low delay among intermittently connected mobile devices because the optimization problem associated with mapping the general graph onto them is complex.


Raw types are proposed by Bracha, Odersky, Stoutamire, and Wadler [7] to deal with compatibility betweenlegacymonomorphicJava code and newpolymorphic Java code.Ageneric classC canbe used as a rawtype C, without type arguments, and assigning a value of C to a variable of C, or even creating an instance of C via new expression are allowed.Thisbehavioris similar toFGJdyn sif we consider C tobe an abbreviation ofC.

with raw types, even statically typed code can go wrong.


Inter-firm relationships were commented on by some respondents, who claimed that it is sometimes difficult to receive the necessary involvement of other functions/disciplines when software related issues had to be solved together.

one of the interviewees did not consider this a problem.


RELATED WORK Cloud gaming systems have been implemented for both commercial use and research studies [17, 3, 4].

most of the existing work has focused on measuring the performance of cloud gaming systems [10, 24].


Video is responsible for the majority of streaming media requested by home users.

in the business user workload, 4.50% and 58.77% of the requests access live and on-demand audio, while 0.30% and 36.43% of the requests access live and on-demand video, respectively.


Peers that still have a reference to P do not know how to contact S(P ), thus, operations that are routed through the faulty peer will fail.

this can be circumvented with a simple retry mechanism and the support of a name service.


With the strong help of compiler vendors, this approach has many bene.ts.

to identify the exact speci.cation for such a major step earlier experiences are needed.


In this case, IT is seen as a supporting process helping to run the main operational business processes that have nothing to do with software production.

reuse in their division s IT landscape is very muchdesirable, mostprominentlyintheirERP solutions.


This approach could enlighten how to specify for security.

the tight relation between dependability and security was clearlygivenin[3], wheredepend ability encompasses di.erent system attributes, concretely reliability, availability, maintainability, integrity and safety.


You realize that you have a lot to teach your students and want to use the time well.

the important thing is not what you do, but what your students do.


NoHeapRealTimeThread objects that are involved in processing real-time critical events must be assigned high priority.

it is possible that the high priority tasks in the system will starve the low priority tasks of any CPU time; this is particularly true for memory region allocation.


The design of the process and its tool thus should promote the formation of heterogeneous groups, which might be hard to realize.

the existing homophily in online social networks can be used as an advantage when aiming at bringing together people with similar ideas to make them join forces.


Solutions for programming exercises are typically small in the number of variables used and objects created during run time.

reading any available variable values from the stack frame and the object heap produces a signi.cant time overhead.


Secondly, such a centralized model does not .t the dynamic and changing topology of these networks.

p2P IP telephony systems like Skype [1] and P2P-SIP [9] have emerged in the Internet.


The model is used to predict the performance of the system given its current state (e.g., current workload).

due to the variable performance of Cloud VMs (compared to dedicated physical machines), it is di.cult to accurately model the performance of the services running in the Cloud.


INTRODUCTION The W3C and OASIS have defined many standards in order to enable Service-Oriented Architectures (SOA) and the emergence of Web Services (WS).

there is no standard programming language to implement WS.


We currently have many adaptors that implement it.

many middlewares only provide a subset of the functionality that the JavaGAT API de.nes (e.g., many protocols do not support third party copies, or copies of directories).


In the paper of Liu and Liebermann it is not mentioned how to describe sequential sets of commands, like it can be done with NLC and contemporary programming languages and if there is an API, which provides at least basic fixed commands, upon which user defined actions could be defined.

we think, it wouldn't be too difficult to extend Metafor with such functionality: for instance, sentences like If Pacman loses then the program terminates.


It has been useful to polish the ideas presented and to test di.erent heuristics for constraint solving identifying problems in it; we are currently working in the design of a more powerful constraint solver based on the experience gained.

the prototype is not strong enough to be applied to more real world situations; it is mandatory the design and implementation of a full-.edged type specialiser.


100 100 608 921 Figure 4: Computation results for some timed Nphilosophers problems eral timed PV program allows nested resource actions and thus are richer than these JSS models.

to test the performance of our approach, we did not try to exploit this particularity and treated the job-shop scheduling problems as if they were problems with more complex types of constraints.


JAVA Generics are known to have several limitations, especially when compared to C++ templates (we refer to Ghosh [36] and Batov s work [4] for a broader comparison between Java generics and C++ templates).

jAVA generics have already been accepted by a huge community and we want to target full JAVA compatibility.


Note that releasing instances, from both EC2 and SLURM, takes around 5 seconds per instance.

such time is not billed and not visible to users.


In principle, any kind of program event can be de.ned and used in HAWK formulae.

currently we support only a limited number, namely, method calls and returns.


DVS can effectively reduce the dynamic power consumption by dynamically varying the processor speed as low as possible.

scaling the job speed extensively can stretch the job execution time, which will increase the static energy consumption.


If the user observes this behavior, they will note that they can not make easy inferences about what a small input change will do to the output.

if an unsophisticated or inattentive user does not notice this, they may make seemingly an innocuous assumption that as long as the input is very close to a previously solved case there is no need to compute a new solution clearly this is not true in the presence of instability.


The collector assumes that it has an unmodi.ed copy of the object, as it was when the sliding view was taken.

when sequential consistency is not guaranteed, it is possible that the collector read the contents of the object after it was modi.ed, but because of memory access reordering the setting of the LogPointer .ag has not yet become visible to the collector.


There is a rationale to consider design pattern types (creational, structural, or behavioral) or Open Source software versus commercial software as a possible dependency, where the type of pattern or system accumulates different types of grime at different rates.

we did not have enough data to support a causal relationship.


Component based engines, conversely, minimize this problem by exposing features through components instead.

due to strong coupling that can still be introduced when using direct access to provide component communication, dynamic entity adaptability may be hindered.


Navigational Transitions for Fulfilling Business Processes: In current commercial workplace products, a business user has to locate different application UI components and navigate through them in order to fulfill business tasks.

the business users are often overwhelmed by the rich and complex functions in the user interface.


Again, we can see that there is a significant difference between both samples (with p=0,03), but we have this information alreadyfrom the previous section.

the important information is the 95% confidence interval which states that with the probability of 95% the development time using the dynamically typed language is between 777 and 17461 seconds less than the development time using the staticallytyped language.


A Comparative Survey of Scenario-based to State-based Model Synthesis Approaches * Hongzhi Liang School of Computing Queen s University Kingston, Ontario, Canada  liang@cs.queensu.ca Juergen Dingel School of Computing Queen s University Kingston, Ontario, Canada  dingel@cs.queensu.ca ABSTRACT Model Driven Development and Use Case Driven Development methodologies have inspired the proposal of a variety of software engineering approaches that synthesize statebased models from scenario-based models.

little work has been done to comprehensively compare these different synthesis approaches.


After that, many works [1] [2] [6] [11] [21] based on the efficient software transactional memory implementation have been presented.

none of these works touches the correctness issues of running the lock-based programs using transactions.


As shown in Figure 14, IBM Product MPI does not perform well in general because of the random placement of nodes belonging to each sub-communicator.

there is a sudden spike in performance when the number of subcommunicators is 8 (divisor of 16) because the sub-communicators in that case are parallel planes.


State-of-the-art processor chips often have multiple voltages for example, giving memory arrays a slightly higher voltage than the core for reliability reasons.

the .rst general-purpose CMP to support a form of core-level DVFS is the AMD Quad-Core Opteron [6].


Requirement-based selective testing may significantly reduce the number of test cases (20% - 50%) as compared to system testing while preserving high quality of a test suite.

the existing requirement-based selective technique can still generate a relatively large number of tests.


Passive tracing is therefore our preferred mode.

while we have successfully collected and analyzed passive traces, none of the experiments reported in this paper are based on passive traces, so (given space constraints) we will only brie.y discuss the issues associated with passive tracing.


Given the above, from Figure 12 we see that although the thread Ti has executed the post primitive (and has written the value p to the post wait array), the thread Tj is forced to spin-wait until a new iteration is allocated to thread Ti (and Ti overwrites the value p in the update array).

from the .gure we see that a bubble in the execution pipeline of thread Ti causes (unnecessary) idling of thread Tj .


In some cases the duplication was between sibling classes in the inheritance hierarchy and so could be removed by introducing a common superclass; in other cases the duplication was contained in the very same class and could be factored into one method.

we found that the java.io hierarchy is quite well-factored.


Thus,if alargerbudget offunction calls would have been available, this approach would have won (seealsoFigure1).

thescopewasto .nd theroots quickly,andinthiscaselocal methodsareadvantageous(if they converge).


This can be achieved by adding another proximity callback for the original radius or by adding a periodic update method.

both these solutions will require some book-keeping, e.g., registration and de-registration of the correct proximity listeners, which will result in a significant amount of code.


it is not possible to build such modules with the weaving mechanism presented above.


One suitable algorithm was proposed in [10].

it does not provide optimal synchronization.


Due to time constraints, not all aspects of the current price calculations were re-implemented during the proof-of-concept.

we implemented the features that we best felt contributed to the validation with regards to complexity, size and performance.


When we applied our technology to a large client-server application written in Visual Basic, the impact was on the order of 50 times!

it is clear that the trace generation performance impact would apply to whatever dynamic clustering technique.


4.3.3 Propagate weights through blocks and edges After the previous phase, every basic block with samples in it will have a weight.

due to incompleteness in the pro.le, it is possible that not all basic blocks have a weight computed for them.


At least this is no speci.c problem in checking UML diagrams, but a common issue in any string-based pattern matching problem.

this problem can be solved to some extend with JGraLab.


Node v4 is also in this correlation overlay, because peer P5 has downloaded v4 and is downloading v3 in the same correlation overlay.

node v5 is not in this correlation overlay, because none of the peers (P6 or P7) that is downloading or has downloaded video v5 appears in other single video overlays.


Therefore, models are usually enriched with capabilities to explicitly specify variable parts by means of annotations denoting selection conditions over feature parameters.

a major drawback of model-based engineering is still its lack of scalability.


An artefact can be anything that is created for developing software.

for our discussion of abstractness only human-readable documents are of interest.


The performance tests were entirely conducted by our team.

there are online benchmark tools available for test them.


We have proven it for all the three semantics of our running example and extracted a general proof methodology presented in this paper.

the main language-independent soundness theorem (Thm.


At .rstglance,it may appear that randomly sampling O(logn)presents trivially solves the single round Bad Santa problem.

this strategy has a (small) probability of failure, which is unacceptable.


This seems to indicate that the expo method leads to reservation schedules that are the most correlated to those of the real-world Grid 5000 reservation schedule.

we found that the real method leads to better correlations than the expo methods when used for some of our supercomputer logs.


Compilation of a .le is deferred if its cumulative length does not meet the .le size threshold.

if the compilation of a .le is deferred, it is marked as processed in the adjacency matrix in order to allow source .les that depend upon the deferred .le to be considered for compilation.


1.3 Contribution of the paper Despite its limits, the approach proposed in [DPC+09] seems to us interesting and well adapted to the veri.cation activity in industrial context.

asynchronous reactive system often contain symmetries (because the systems are often designed to be insensitive to the arrival order of certain events).


Since stencil computations are characterized by a regular computational structure, they are amenable to automatic compile-time analysis and transformation for exploitation of parallelism and data locality optimization.

as elaborated later through an example, existing compiler frameworks have limitations in generating ef.cient code optimized for parallelism and data locality.


One option to cluster jobs is to group them based on their single-run times.

jobs with similar single-run times may need very di.erent times to .nish in co-run scenarios.


To achieve this, we introduce a special lattice element lalloc j corresponding to sj, and we propagate it inside method mi during phase II.

during this phase, the value is not propagated back to the callers: if the value reaches a return statement, instead of back-propagating lallocj we backpropagate ..


Central to many of these approaches are the representation of streams and computations about them.

notably missing are the connections between stream computation and the related laws.


On the programming level, mature, industrial-strength tools like the de-facto standard AspectJ exist.

on the modeling level, there is as yet little support for AOSD.


Certainly, attempting to demonstrate the benefits of Multiple Inheritance through 20 lines of code is impossible.

a better approach would be to show how a range of large scale systems can be more easily built and maintained through Multiple Inheritance, and how its use can significantly reduce the number of Lines of Code (LoC) necessary to implement those systems.


Thus, developers can focus on implementing correct adaptations of behavior in their contextaware applications without worrying about asynchronous nature of context events.

a future represents a promise to deliver the value [12].


Since the read authorization also is intended for the .le s inode, we mark the .le s inode as authorized for readas well.

after classi.cation, one inode controlled operation is not authorized.


Higher the number of cells, the more protects M-Process is from dynamic observation.

as the number of cells increases, function xorAll is called more frequently, which leads to higher overhead.


Indeed, to establish our lower bounds we establish and exploit a relationship between superconcentrators and circuits computing good codes.

despite this relationship, circuits computing good codes behave differently from superconcentrator graphs.


For example, inclusive gateways and complex gateways in BPMN have complex semantics as compared to UML decision or fork nodes, and require specific patterns of UML elements to implement these gateways.


Optimistic fairexchange protocols guarantee fair-exchange of two electronic items between two mutually distrusting parties by utilizing trusted third parties (ttp).

they reduce the involvement of a ttp to only those exchanges that result in a con.ict.


This is because these benchmarks runfor along time(tens of minutesto afew hours), resultingin more consistentoverallperformances.

3.1 BenchmarkCharacteristics Table1describeseachbenchmark and thepossible sources of contention obtained through source codeinspection.The numbers of threads generated by these benchmarks vary signi.cantly.In addition, the numbers of shared objects and contended objectsalsovary signi.cantly.Also notethat we report the number of objects that are accessibleby multiple threads(shared objectsin thefourth column).not all of these objects experience contention; therefore, we see that there are shared objects experiencing no contention in jbb2005, jAppServer2004, and ECPerf.


If the current_user is not an administrator, the PHP header function will be called, redirecting the user to / .

the sensitive information will stillbe returnedinthe output,thusleaking information.


For example there is less formal management controlling the FLOSS project as compared to a closed source software project: Developers who are not paid for their work leave the project if their interest in the project subsides.

this is not an issue for all FLOSS projects, as some FLOSS projects are maintained by commercial companies and developed only by paid developers.


Its key idea is that if modules only use relative addresses rather than absolute addresses, they are relocatable.

compiling such relocatable code  Figure 1.


In particular, timeliness cannot be guaranteed if throughput constraints on the client are not also speci.ed.

our results indicate the maximum level of monitorability possible if timeliness constraints are includedin anSLA.


Therefore, v will be reduced quickly until enough eligible inputs are available, so higher values of v will have similar performance.

it should be noted that generally speaking, a higher v will have smaller F-measure than a lower v. In summary, the above observations imply that e.ective FSCS-ART with .ltering by eligibility needs a high initial value of v (say 0.9) and a large r (say 0.9) in order to keep v large and its approaching to 0 at a slow rate during its application.


In practice, we expect that predicted residency would be used in combination with a form of generational or incremental collection (as we will discuss along with other related and future work below).

to better understand our technique, we consider it in isolation.


Department of Computer Science Allegheny College {belanim, gkapfham}@allegheny.edu cases according to some priority measure.

these approaches often ignore the time constraints of the test ing environment.


In terms of scalability of the approach, the simulation results show that the performance provided by the platform in terms of delivery ratio and delay of persistent messages and messages with higher priorities is good.

it is worth noting that, in general, it is quite di.cult to o.er high degree of scalability in peer-to-peer middleware for mobile computing due to the characteristics of the devices (limited memory to store temporarily messages) and the number of possible interconnections in ad hoc settings.


Because they are actually shared among the generations, region reuse cannot help separate them into different regions.

region reuse can help with splitting the skeletons and then reclaiming them.We mimic region reusefor life byreplacing the assignmentbetween twogenerations (likethe one at(2)in q)with a call to a procedure that copies the list skeleton.


Parallel concepts could be taught using groups of robots.

robotics packages aimed at younger students such as Mindstorms [19], PicoCricket [2], and Arduino [1] focus on single-processor single-robot programming tasks.


Schwer showed in [9] that context-freeness is decidable for trace languages of VAS.

the proof is long (almost 50 pages), very complex and intricate, and the resulting decision procedure is based on .ve technical conditions on an unfolding of the coverability graph that ensures the iterability of loops (see also [10]).


The .rst was to have an ignition key physically inserted in the NSE and each EPE.

while this might be acceptable for the NSE, it is not acceptable for the EPEs as our model can consist of tens of thousands of EPEs.


even if the null hypothesis is true, it is expected that in about 5% of all cases, the 95% of this con.dence level will be reached.


To achieve such automation, SWISH uses semantic similarities among window titles.

one of SWISH s problems is that it may not correctly group windows when window titles depend on the application.


These protocols addressed both issues related to mobility and unreliability.

these protocols have mainly focused on single hop wireless networks where base stations or satellite beams cover large areas.


There are trade-offs between these opposing options which will be addressed later.

we would like to note that the tool we developed supports various views of what interfaces are and the level of the interface one should commit to.


In Android, permissions to access re sources, such as sensors and devices, are granted and enforced at the granularity of an entire app.

many apps are composed of multiple packages obtained from different developers.


estimated Number of Publications 30 25 20 15 10 5 0 Figure 2: Extract from a 2005 Motorola Phone SPL    01 02 03 04 05 06 07 08 09 10 11 12 13 14 Year Figure 1: SBSE for SPL Papers Since 2000 As well as the many subject speci.c SBSE surveys, there are several publicly available SBSE tools for release planning [121], design [115], testing [4, 45, 51, 78, 88, 147], refactoring [117] and repair [94].

hitherto, there has been no survey of SBSE for SPL.


After compaction, pages that have no used blocks are reclaimed as free pages and can be used for other size classes.

whatever compaction is used, there may remain a page that has both used and unused blocks.


Instead, the orchestration could be run on a remote server, however in that case you may not be able to achieve the real bene.ts of orchestration like reduced network tra.c.

it is suitable to choreograph the external services (according to the local orchestration results of the smart devices) since: i) choreography always provides the global view, ii) we can achieve the parallelism by simultaneously executing the independent services, iii) it is possible to reduce the number of messages by directly feeding the input/output from/to the service producer/consumer, respectively, and iv) it is certainly not an issue to install a choreography engine for such services.


Continuing with the example above, to de.ne a cluster constituted of the two less powerful VMs previously de.ned and specifying the maximum round-trip delay to the server as 0.6 ms, the SLA could have a third group, named Cluster, instantiating two Small_VM and the RT_delay.

recursive de.nitions are not allowed, that is, a group cannot (directly or indirectly) refer to itself.


The .nal step in improving the performance of the language is to create a full-blown virtual machine (VM) with a just-in-time (JIT) or ahead-of-time compiler.

only few dynamic languages reach this stage.


The performance of the proposed algorithm varies with the offered workload.

for a setup that is arguably close to the scenarios that will be seen in practice, the proposed mechanism achieves up to 10x better compression rate, compresses the data up to 2x faster, and enables migrating a complete application up to 3.5x faster than alternative techniques.


They compared the costs of barriers generated by an adaptive, optimising compiler for different Jikes RVM collection algorithms on different hardware platforms.

our work seeks to measure the locality of different write barriers independent of the platform, virtual machine or garbage collector used.


The focus of SELinux is on securing system processes.

the focus of our product is on limiting administrator access and on crossplatform user provisioning based on business requirements.


Moreover, some methods, e.g., accessor-methods, can be examined rather quickly.

the scenario clearly shows the bene.t of favoring our method-level prediction model over .le-level prediction models.


Like FTKL, it centers around the notion of function signatures and type variables.

it has no notion of higher-order functions or parametric type constructors.


Procedure integrateL(o) adds o into H by the e.ects relation order.

if the submitted o is an undo operation undo(i), we .rst check its original operation H[i]to see whether it has been undone or is depended on by other operations (line 6).


For programs that use only POSIX mutexes, it isquitepossible to hard-code theknowl edge aboutthePOSIXAPIintothedetector(mostpopular detectorsdo this).

ifthe testedprogram uses other means of synchronization, we have to explain them to the detector.


Regardless of the strategy chosen for integration testing, the classes are integrated with others which, by de.nition, were already developed and tested individually.

in some cases, classes may be in different phases of software development cycle.


Here are some examples that illustrate how literals work: >:t 2 (Width a) => Bit a >:t 2&B11 Bit 2 Notice that, when used on its own, the number 2 has a polymorphic type the system is telling us that 2 has type Bit a for any a that is a valid width.

if used in a particular context, 2 will be converted to the correct length using the function fromLit.


We had little control over architectural improvement activities in the first case study.

as already mentioned, in the resource access control case, we ensured that the assessment would be followed up duly by adding the identified problems and issues to the "Open Items" section of the architectural description document.


In contrast, the process of simplifying complex symbolic expressions using concrete runtime values can be accurately simulated using uninterpreted functions.

those concrete values are necessary to effectively compute new input vectors, a fundamental requirement in test generation.


In[17] weintroduced a subset of regularpath expressionsthatallowsfor as muchexpressivity as we needforpractical applications, and showed that if we restrict the regular path expressions used as templates to this subset we can .nd all the principals that can access a particular resource in polynomial time on N, the number of principals.

the exponent of N may be large, and the most straightforward method of .nding this set of principals may be expensiveinpractice, as we willseeinSection6.


While using CodeGenie developers design test cases for a desired feature .rst, similar to Test-driven Development (TDD).

instead of implementing the feature as in TDD, CodeGenie automatically searches for it based on information available in the tests.


JMS [6] was the .rst, largely available publish-subscribe infrastructure, to provide a concept of reply.

it does not provide a fully integrated reply mechanism as we propose here, while it merely de.nes the basic mechanisms to send replies back to the publisher.


In summary: Our results suggest that when risks are controlled and managed by the PM, we will get good requirements.

there are risks outside the control of the PM, such as concurrent projects, that can compete for scarce resources.


For AspectJ aspects to become extensible systems, standards must be developed that will help prevent modules from interfering that originate from different sources [12].

currently only a partial precedence of aspects within an extensible system can be defined, since authors of aspects cannot predict the future interaction of aspects from different authors.


This will prohibit crackers from writing aspects that aim to attack those join points, for AspectJ compiler cannot accept those illegal join point specifications in an aspect.

after second thought, we realize that this idea does not work.


OCaml [20] combines objectorientation with a mutable annotation on .elds (for example, references are implemented as a one-.eld mutable record).

without a notion of read-only types, users are forced to hide mutability via use of interfaces and subtyping, which is less .exible and expressive than our proposal.


With the demise of wide issue superscalar processors in favor of multicore processors, interest in this kind of techniques has decreased.

given the power efficiency difficulties that future processor and multicore architectures are facing, it is likely that techniques originally intended for wide superscalar processors can be revisited focusing on their energy saving potential.


According to [16], if there is some processes in the system such that the rest of the processes have no knowledge whatsoever of its identity, there is no algorithm that implements a FD with weak completeness, even if links are reliable and the system is synchronous.

the O FD can be implemented without the membership knowledge.


Therefore, general AOP is clearly more powerful than our scheme.

our scheme has the advantage that it is statically typed, and that scope and order of advice can be precisely controlled using the semantics of mixin composition.


Indeed, much effort has recently been invested in applying .nite state model checking to check that SDN programs behave correctly.

generally speaking, .nite-state model checking of SDN programs suffers from two main problems: (1) scaling these methods to large networks is highly nontrivial; and (2) .nite-state model checking might identify errors, but cannot guarantee the absence of errors.


5.3 Replay Evaluation After replaying the entire recorded architectural process, which embeds the architectural knowledge, the resultant architecture has to be evaluated as if created from scratch.

as previously emphasised, the recorded architectural knowledge encompasses the architectural analysis results.


In comparison to our algorithm, InvGen terminates faster in the majority of cases.

invGen fails in roughly 40% of the benchmarks and returns a wrong veri.cation result in two cases.


Furthermore, it can be argued that only the first two, CORBA-based solutions, support R6 to some extent.

these solutions address several of the other requirements, and have certainly influenced our work.


Therefore, it may take longer time for the female developers to adjust themselves.

we could not verify this point through statistical measures.


This restriction might seem to decrease the obliviousnesspropertyof GluonJ.The reader might think that a source .le must be modi.ed to include a using declaration and hence reusing a whole program as is wouldbemadedif.cult.


This realizes a consistent world state such that the experience of the virtual world is the same for all users.

the maintenance of absolute consistency does not scale with an increasing number of users as all have to be synchronized.


In SWC (right), only the required elements of rgnNodes are fetched for(i=0;i <num blocks; i++) { for(ipin=1;ipin <n pins; ipin++) { num conn = get num conn(i); bnum = plist[ ipin]; if (block[i].type==CLB) { x =block[bnum].x; ... y = block[bnum].y; } ... } // LOOP1 } // LOOP2 (a)Regular Access (b)Irregular Access Figure 3: Multiple access modes for same array (block) large heaps, conventional techniques would fetch the heap data element-by-element into the SPM through expensive DMA.

the reuse can be naturally exploited if the array is fetched through the SWC.


With Async, the client is not limited by the rate of con.rmations from the secondary site, causing the client to receive many unsafe replies (CV > SV).

with Pipelined synchrony, these unsafe replies do not oc cur because network packets are buffered until the secondary s acks are received; as a result, PipeCloud is able to provide clients with the same guarantee as synchronous the data for any response they objectives and RPO deltas [10].


At the time when the project started, the most appropriate SLA approach was WSLA, due to its schema structure that well matched the management tasks implemented within the system.

since OGF has recommended WS-Agreement as the way to go for SLAs, one of the future task will be to modify our system to be WS-Agreement compliant.


S(vf ,vg,x2)) In this example, the .rst application of Eq.

(2) (to remove g) did not hinder us from applying the equation a second time to remove the function f. when reversing the Skolemization of an arbitrary SO tgd, this may not always be the case, i.e., a rewriting step may result in a formula that can not be further unskolemized using this equation.


For example, Java regular expressions can easily be replaced using the excellent cl-ppcre library.

many other Java APIs do not have any correspondence in Common Lisp.


Auto-correction is actually implemented as a special kind of create, so a question about auto-correction will be displayed for the appropriate text.

in this case we added a custom question method to specifically describe the automatic features and dependencies.


3.1.4 Access Control SpongeFiles are designed to be used in a collaborative environment.

if access control is needed, tasks can encrypt their chunks before storing them, as once stored the data can be accessible by anyone in the cluster.


In the course of various research endeavours, a plethora of methods and approaches to RE have been proposed.

when it comes to evaluating the contributions in practical environments, which is a prerequisite for providing insights into factors relating to the practical impact of the contributions, we can observe that available evaluations are often not in tune with the (practical) problems they are intended to address.


In the DSM algorithm, the overhead of one load balancing operation was about 0.3 seconds, which was acceptable when a simulation day lasts more than 10 seconds.

splits and merges were occasional operations involving a few mappers.


For example, Figure 4 shows that the accuracy of RETRO is clearly better than that that of ReqSimile.

the e.ect of using RETRO in a speci.c traceability recovery task is not that clear, as our pilot experiment suggests.


(a) Ideally-effective Intercommunication  [1:1] Pattern [1:N] Pattern [M:1] Pattern (b) Three Interoperable patterns Figure 2-1.

intercommunication via interoperable patterns with SSAD, we have to consider the possibility that there are diverse types of data flow that is attached to service processes.


Other bloggers have noted it is the biggest time-saver I ve stumbled upon [24], and a command I use religiously [25].

despite the acclaim given to this command, based on Eclipse Usage Data Collector [26] data for May 2009, of the more than 120,000 people who used Eclipse, more than 88% do not use open resource.


Finally, for simplicity, we assume an adversary that can coordinate malicious processes as well as process crashes.

we assume that the adversary cannot subvert cryptographic hash functions we use (SHA-1), and that it cannot spoof the communication among non-malicious processes.


For example, a pro.t-driven publisher in the TV category has a strong tendency of publishing torrents in the Porn and Movie categories as well.

pro.t-driven publishers in single torrents mostly publish torrents only in a single category (mostly Porn) as shown in Figure 13 because pro.tdriven publishers who publish single Porn torrents often use the textbox in the webpage rather than the advertisement text .les.


It shares our framework s goal of lowering barriers for building sensing applications.

unlike ODK Sensors, this application focuses primarily on customizing surveys and frontend visualizations of real-time data.


It is typically supported in most IDEs out-of-the-box, including Eclipse, so it is a natural candidate to use in any team project.

cVS emphasizes the wrong set of features from those needed for group software development in an introductory programming class.


Such a software cache can maintain correctness and exploit reuse among references, especially when complicated aliasing or data dependences exist.

the software cache introduces the extra overhead of cache lookup.


A bigger set of concurrent programs have to be analyzed as much as other properties.

to check other properties, one has to de.ne them for each program, increasing the costs of applying this approach.


4.2.3 Switching the Color of New Objects By regarding new objects allocated during a GC cycle as unmarked, the collector can reclaim short-lived objects promptly.

allocating white tends to repeat concurrent marking phases many times, because it produces many unmarked objects during each concurrent marking phase, some of which may be pointed to from the nontrapped area.


As an example,thepurchasing agentpresentedinSection2.2 may want to check whether the chief purchasing o.cer has already started to view the proposed products -or otherwise wants toabortprocessexecution.

iftheprocess migrates, it must be speci.ed which participant should access which management action.


Overlapping Communication with Computation Resolution: Moderate (3/5) Explanation: Parallel Quicksort can exploit overlap between data movement and computation by merging data chunks as they arrive.

every step each processor only receives a few chunks so this .exibility is rather limited.


When at t=4 a Smoke event is detected, the rule that uses the each-within operator combines it with every Temp event greater than 45, which result in two di.erent Fire noti.cations.

the rule that uses the last-within operator results in a single Fire noti.cation, that combining the Smoke event with the latest Temp event greater than 45 (i.e.


The existing schemes [22 24,26] achieve this objective by allocating, in the o.ine analysis phase, a separate recovery task with any task that will be executed through voltage and frequency scaling.

both the recovery and DVS mechanisms essentially compete for the available system slack.


Fully streaming engines circumvent this problem by carefully memorizing the parts of the stream which will need to be used later in the computation of a result, so that rewinding in the source is not required.

partial engines perform no memorization and cannot evaluate some queries in streaming mode, even though they are formed of language constructs supported by the streaming engine.


Most of them earned good marks on the exam.

the impact of the use of ETV on student s performance cannot be validated.


For both FUSE and Java-Fuse, the block input test contains a spike in the throughput due to caching e.ects caused by the synthetic nature of the benchmark; in the previous step (per-character sequential input), when the .le can no longer .t in the page cache, the Execution Time (Seconds) 40 30 20 10 initial part is written out to disk.

the latter part of the .le still resides in the page cache, and is thus accessed directly in the current step, causing the spike.


However, the local sv is still advanced to acknowledge the fact that the e.ect of o has already been re.ected in the data replica of this site.

if H[i] has not been undone yet, we set H[i].uv to o.v and combine H[i].v into o.ov.Then o is transformed and integrated into H similarly as a normal operation.


Related Technologies We are seeing efforts on the Web to embed RDF in HTML [5].

it should be noted that our approach is different in the sense that we only need a small portion of the RDF vocabulary to enable this programming paradigm.


In model-driven software engineering, out-place transformations are very popular for implementing model compilers that produce concrete code from more abstract models.

transformations are not limited to be applied for producing code.


Figure 4(a) shows that our design consumes considerably more logic resources (in relative terms).

even at 32K objects we use less than 1% of the logic resources of the chip.


According to this de.nition, a vulnerability that results from a development mistake is a fault.

vulnerabilities that result from design or con.guration mistakes are not faults.


The attestation request works as previously shown for the identity property.

in this case, instead of validation of the AIK Certificate of target, the appraiser gets the PCR s values, which are hash values for each application on target, then compares them with whitelist and returns the measurements decision result to attestation proxy before the certification phase (see Fig.


The staging and treatment phases exhibited good and stable connectivity.

the rescue phase posed signi.cant challenges to reliable communication.


During each iteration, CoLoRS performs parallel, concurrent marking from pending objects.

this time it stops marking the object graph once its sees an object with the recent .ag set.


It enables the use of semantic web technologies in building applications around that data.

the idea of Linked Data itself does not solve the problem of data infrastructures in the communities of interests.


With this technique, tasks can interfere by using common areas of the SPM.

this requires to update these areas during context switches, which involves considerable overheads.


It is straightforward to prove that ~_ is an equivalence re- lation.

it is not obvious that _~ should be pre- served by all operators of the calculus, due to the fact that ~_ is, intrinsically, higher-order.


This is different from page-based virtual memory implemented by most general-purpose operating systems (such as Windows or Linux), which requires a full-featured MMU.

in order to switch between the different trust levels in a controlled manner, the MPU registers are programmable only if the CPU is running in supervisor mode.


Our union types can be considered a hybrid of the two kinds; thanks to the fact that every object is inherently tagged by the name of the class from which it was instantiated, explicit tagging is not needed to construct an expression of a union type and, furthermore, as we have shown, both case analysis and direct member access are supported.

in our language, unlike ML datatypes, forming a union of the same type results in a compatible type of the original type, so it is not meaningful to perform case analysis on such a type (the .rst branch will always be taken).


Hence, they are more focused on results rather than process.

hofstede & Hofstede (2005) mention that to be result-oriented is not always bad; similarly, to be process-oriented is not always good as both of poses their own set of characteristics.


The current set up uses a slightly modified heuristic operator set in that the sequence of right-hand side (RHS) symbols can appear optionally or iteratively.

induction of bigger grammars remained elusive.


To enable development of predictable real-time applications, RTSJ introduces, amongst other constructs, new types of threads (RealtimeThread, NoHeapRealtimeThread) having precise scheduling semantics and that may run at higher priority (NoHeapRealtimeThread only) than the garbage collector, and special types of memory (ScopedMemory, ImmortalMemory) that are outside the scope of action of the garbage collector to ensure predictable memory access.

the introduction of new memory regions complicates the development of hard real-time applications.


This means that the eager coercion calculi does not independently specify a deterministic strategy for casts.

the derivation of labeled types, in concert with the space-ef.cient evaluation semantics, amounts to imposing an order of evaluation on eager coercions.


In previous work, we could show that intended and actually implemented variability (i.e., the KCONFIG feature model and the variability points in the code) do not necessarily match.

many con.gurability-related defects, such as dead #ifdef-code, and bugs, can be found upfront by better tool support [29].


In cases where the analyst is interested in checking a property on only finite executions, the property has to be modified in such a way that it always holds on all infinite executions and vice versa.

with our proposed classification scheme the analyst explic- itly indicates whether the property is specifying finite, infi- nite, or both finite and infinite sequences, as well as indicates whether the property is to be checked on finite, infinite, or all executions of the system.


These emulators allow designers to layout mobile UIs on their Pc using a traditional mouse and keyboard.

since these emulators run on a Pc, they do not provide the same interaction experience as the actual mobile target device.


Both monitoring and detecting of noti.cation leads is technically possible to solve by using CEP.

to step beyond academical usage it is necessary to incorporate complex approach and build much more than just a proof of concept.


Several model transformation approaches uselangagesin order to specify and execute transformation rules.

it is di.cult to know if the transformation process is led correctly in many work.


an ongoing change in the software industry today; towards open processes, closer customer involvement, volatile domains and intra-organizational collaborations calls for some rethinking of how we view and practice SPLE.


Avoiding excessive internal fragmentation would require managing multiple pools, at which point a general-purpose allocator seems more sensible, which is what we used.

we found that this choice can lead to signi.cant overhead when using GC.


Notice that the heap size is large enough to hold two heap working sets (e.g., working sets for T1 and T2).

interleaved execution prevents each thread from allocating its working set.


They are able to ful.ll several tasks such as emailing, Internet browsing, gaming, video capturing, uploading, and replay.

due to their roundthe-clock usage, their energy consumption has become an omnipresent problem.


There are many proposals to virtualize transactions that grow too large for hardware resources, and our data indicates the importance of such schemes.

both of these issues in bonnie++ could be addressed in TxLinux by using cx_exclusive to protect the critical region in dput that creates the transaction that has dif.culty completing.


It means the appearance of standard start codons and their complementary codons must be avoided.

there are many alternative start codons discovered and analyzed which varies by its species [20].


For v t1 = log(2 mE/| A||||x0| )/| A| , | F [0,t1]-Bm(F [0,t1])| = E. e Using the ti in the de.nition of Lemma 5 is desirable since it gives a closed form expression for computing the ti.

the problem with the above expression is that the expression being computed might not result in a positive number in which case we are in trouble.


This works perfectly well when it is enough to just generate the picture, or the animation without further inspection of the data.

one drawback of the approach is that, when a deep reasoning is required, we need to refer back to the capabilities of the original tool that manipulates the actual data.


Periodic sampling at once every millisecond results in a 1 ms upperbound on the duration of each metric sample.

the metric samples for each request typically do not follow synchronized steps due to non-deterministic request context switches in concurrent server environments.


3.5 Specify transitions So far we have de.ned the basic .ow of the system, making it possible to check at runtime if the trace of tasks execution is valid.

in order to de.ne the system behavior in the face of optionality, multiplicity and alternatives, we need to know when a particular task should be triggered.


For very highly scalable applications (e.g over 60 processes), systems like iQudu will provide better performance than EC2.

eC2 appears to perform better than commodity systems.


QACO-U does not have the precise information and can only estimate using an mean/expected value.

qACO-K , knowing the service demands of all pending requests, estimates the possible processing times of given requests more precisely.


The other school of approaches provide classes of possible mismatches between interactions models and then propose adaptation templates based on design patterns or adaptation operations to resolve the mismatches (e.g., [14, 11, 18]).

in all of these approaches developers need to manually inspect the protocols and identify the mismatches.


Nagappan [18] evaluated thepossibilityof inter project reuse of error prone prediction and negated the possibility.

there are several researches about inter project reuse or cross-company e.ort prediction [14, 13, 16, 15] and defect prediction [18, 19].


For example, checking whether a credit card number has 16 digits does not reveal anything sensitive in this case, the auditor need not review the body of the conditional.

if the auditor decides that the conditional predicate is sensitive, he/she must rule out any implicit information .ow that violates the .ow policy.


e's extend statements, in contrast, do not enable this form of reuse at all.

definition linearization for mixins, just like for multiple inheritance, is hard to handle in cases of ambiguities (as is observed in e.g., [2,24]).


The results from Example 5 are well within the range of cache sizes normally used on systems from SGI, SUN, Compaq, and IBM (Power 3 based SMPs).

it does indicate that systems with only 1 MB of cache may have performance problems for moderate to large problem sizes.


Existing techniques can be applied well on the constructed test suite.

it is possible and necessary to optimize testing requirements before test case generation.


In Web2.0 applications, most of the transactions are sent on-line and users are not willing to accept long response time which, in some cases, may be considered as a denial of service.

many Web2.0 applications are not critical, and users may be likely to trade quality (for instance data freshness) for better response time.


More speci.cally, we make the following claims: Symmetry-breaking issues need not be a hurdle in the design of e.cient protocols for SDN networks.

prior results related to the di.culty of .nding good solutions to optimization problems still apply.


This means that, if cores i and j share a cache at level t (1 = t < s), they will share caches at levels t + 1, t + 2, · · · , s - 1 as well; consequently, after the .rst occurrence of a zero value, say, dt = 0 is detected, all the values from dt+1 to ds-1 will be 0 in the core difference vector dii,j.

our model is general enough to capture other (possibly, asymmetric) cache connections as well.


This is based on an application-transparent coexistence of incremental and nonincremental log modes.

like the aforementioned works, this solution optimizes log/restore parameters by relying on an analytical model not targeted at capturing the above discussed locality and thrashing e.ects.


These processes and methods typically define the outcomes and the steps to achieve those outcomes.

the implementation of a process or method needs to be tailored for each organization.


Thus, we consume nextsample countdowns gradually over time.

the rate of consumption is slower than that for raw coin tosses: n countdowns for 1/d sampling encode, on average, nd tosses.


These numbers indicate the potential benefit of field level coallocation.

the effort required to obtain them and the hit-and-miss process involved suggests automatic implementation in a type-safe language, such as Java or C#.


Since the combination of Eden and high-performance array libraries has not been studied before, we evaluate this high-performance style as a reference point.

these optimizations can indeed yield sequential performance within a small multiplicative factor of C. this kind of manual transformation is exactly what skeletons should make unnecessary.


In this paper, we present a practical approach to define software security metrics taking into consideration of time as well.

our time here in this paper is a coarse grain of time, namely, we count the occurrences of vulnerabilities over a time span in months.


As a result, for small sized messages, our multicast based implementation performs worse.

when the message size is large (see Figure 8), the acknowledgement processing overhead is insigni.cant, and sending one multicast data packet instead of multiple unicast packets provides a signi.cant improvement.


Javeleon performs all necessary transformations in order to support these situations.

consider what would happen if a method in a non-final system class had been declared as native.


In fact, the summary computation described in [7] is only sound under the assumption that no points-to relations are killed by summary application.

summaries generated by our analysis are used to perform strong updates at call sites, and for the recursion-free fragment of the language from Section 3, applying a summary is as precise as analyzing the inlined body of the function.


This dynamic strategy can be softened by setting the worst case result similarities smaller than 1: simmij < 1 for matchers that have not yet been executed.

similar to the static .lter condition this could change the result of a matching process in comparison to the unchanged process.


For example, instead of decomposing an 1G-point fft into two groups of 32K 32K-point ffts, we can have a 3D decomposition with three groups of 1M 1K-point ffts.

this 3D decomposition requires 2 extra memory sweeps, which are measured to have more overhead than one core-to-core read required in our .ne-grain parallelization scheme.


That is, one could write require(cpuUtil(0,50%)) to obtain exclusive access to half of the existing allocation of utilization on core 0.

a nested require statement may make requests for some utilization less that 0.25.


Developers have to write code to map new object types in their SCM systems into atoms and collections.

in Molhado, the details of mapping an object to physical storage are not exposed to developers.


An example of this would be the integration of tools such as Facebook and Twitter in learning platforms.

digital immigrants were not born immersed in an ICT-saturated environment, and had to adapt themselves to the emergence of these new technologies in their lives and their learning (and teaching) processes.


In the case of CASN, storing node s context locally is more suitable and can result in significant energy saving.

it is not as simple as just storing all the contexts on each node.


Disallowing pre on events thus eliminates a potential source of programming bugs.

yampa, because discrete-time signals are realised as continuous-time signals carrying an option type (see Section 3.1), cannot rule out pre being applied to event signals, nor can it guarantee the proper semantics of such an application.


While there has been much research on TLS, it is hardware based requiring redesigned architectures [7, 21, 31, 37] or non-trivial modi.cations to the existing architectures such as special buffers [10, 25, 26], versioning cache [9], or versioning memory [8].

the hardware features are not present in any commercial multicores and this makes software speculation attractive as it can be used on existing machines.


For anyo> 0, there exists a local (1+o)-approximation algorithm for packing and covering LPs, assumingaboundeddegree graph and bounded coe.cients [10, 11].

as shown in Theorem 1, this is not the case with max-min LPs [7].


Both sampling and the observer effect complicate race detection evaluation because they change the reported races.

our evaluation (which currently evaluates only frequently occurring races due to experimental resource limitations) suggests that PACER achieves its theoretical guarantees, .nding each dynamic data race with a probability equal to the sampling rate.


6(3), the hoisting of chk b leads to reordering against chk c, but the hoisting of chk a does not against chk c nor chk b.

once chk b is deoptimized and returns to its sentinel, chk a in turn must be considered to be hoisted beyond the exception dependency.