It is for example not allowed to delete an alert.

consultation and modi.cation are possible.


Rashid and Chitchyan [3] describe how aspects can be used to add persistence to existing classes.

their implementation requires these classes to ful.ll certain qualities.


The above problem is solved by Triage using its software architecture and amortizing the transition cost of a long interval of time.

we .nd that the USB-transfer cost is a potential bottleneck for both the Triage and WoW* systems and the performance of Triage could be improved if the bottleneck is eliminated using low power DMA (direct memory access) between the Mote and the Stargate.


A unique feature of the MapReduce framework is speculative execution, which provides high availability and robustness of the cluster [7].

speculative tasks are not free; the downsides are duplicated tasks and more resource contentions, especially in the virtualized environment.


With the former, one can make good predictions with very little space, whenever there are regular/strided reference patterns.

they may not do a good job when there is no such regularity.


The aforementioned steps are only a few of the required ones for enabling an application to run on both processors and coprocessors.

they are adequate to illustrate that there is a pattern or a set of mechanical steps involved in the process of adapting or parallelizing legacy applications for a particular platform.


Since it is quite unlikely that world updates run at the same time on di.erent nodes, player character positions will not be consistent most of the time.

they will always be consistent when an event is being processed and no rollback occurs, as the world and thus all entity positions are .rst updated to the time of the event.


On the one hand, it can be explicitly manipulated by its owner due to AmbientTalk s re.ective properties.

the underlying actor system also updates the mailbox when certain low-level events occur, for example when a message is transmitted from the out mailbox of one actor to the in mailbox of another.


Many overlay network protocols have been proposed to organize peers into various topologies with emphasis on different networking properties.

applications are often stuck to a specific peer-to-peer overlay network implementation, because different overlay implementations usually provide very different interfaces and messaging mechanisms.


(.x.M) where F may appear in M. As usual with recursion, one can write nonterminating programs, so weak normalisation fails.

the Church-Rosser property holds, and types and supports are still preserved by .ß.


than Root Set, and in fact Random with f =1 is as good as Root 34 Set with f = .

this difference diminishes as f is de   4.4 DHT replica placement In this section we compare two common strategies, Root Set and Several limitations of the traces likely underestimate the long-Random, for managing .le replicas in distributed hash table-based term bene.t of Random over Root Set.


Therefore, we recommend limiting the data held within business processes to a minimum.

it is not always worth introducing costly changes to an existing design just to restrict the size of such data.


This does not only increase readability but also portability of the source code as each back-end can resort to its speci.c SIMD ISA.

type and control-.ow vectorization must still be handled manually by the programmer.


This means that a particular sequence of characters is interpreted as the same token everywhereinthe programtext.For syntactically simple languagesthat have been designed with this restriction in mind this is not a problem.

modern languages tend to become combinations of domain-speci.c languages, each providing syntax appropriate for its domain.


The most commonly used way for defining the concrete syntax is via grammar-based systems.

there are multiple semantics specification frameworks but none has been widely established as a standard.


If that happens, p will detect it when executing line 55, and will then wait to be signalled in line 56.

another process can only signal p (in line 78), after handing over the root-lock to p (line 77).


OWL-S provide means to semantically describe WS using three elements, and that is, service profile: describes what the service does, process model: describes how the service operates, and service grounding: provides details on how to automatically access the service.

wSMO semantically describes WS using four elements [4]: (1) Ontologies: provide domain knowledge that can be used by other WSMO elements, (2) Web services: describe functional and behavioural aspect of services enabling machine-interpretability, (3) Goals: represent the request(s) that the service consumer might need the service to fulfil, and (4) Mediators: deal with heterogeneity challenges between conflicting semantic concepts.


After testing the application on Windows, we ported it to the gateway platforms running Linux (with the Linux version of MVM) for the final evaluation.

the application kept failing on the gateways.


As the contribution is not rewarded, nor the lack thereof is punished, the old downloaders have no incentive to upload.

figure 1(b) clearly shows that downloaders with the higher upload rate .nish earlier.


Forexample, studiesshowthatuser-providedjob run-time estimates used for back.ll algorithms are inherently inaccurate[22].1 Using ourde.nitionof uncertaintyfromSection 1All of our presented simulations assume perfect run-time estimates.

repeating all of the experiments using the actual run-time estimatesfrom usersdoes not signi.cantly change the results; we omit thesegraphsfor space considerations.


In our environment, a barrier to carrying action to reflection was the cost of running.

previous tinkering research has shown that when the cost of running can also be too low, encouraging some end Figure 3.


Thus, the results of snowballing approach, might be biased by over presenting speci.c authors research.

database searches methodperformssearchesonallpapersinthedatabase which eliminates this risk.


In [15], scopes were modeled in which a user can physically interact with each device e.ectively.

that work focused on monitoring and reacting to events by the runtime system, not the development phase and tasks involved there.


The degree distribution of a random graph is a Poisson distribution with a peak at P(k).

research has demonstrated that the degree distributions of most large networks can differ from a Poisson distribution.


The .ring duration of the AEC actor is de.ned in [17] as 9.091ms which means that its maximum transfer rate is 80 > 8.

the AEC task contains a 48 taps .lter 9.091 which causes the .rst 48 samples to be used only for .lling the taps.


The parameter vectors for the measurements were assumed to be arbitrarily distributed.

a high density of measure mentsatareaswithhighgradientinthecostfunctionwouldim- prove the function approximation.


One current library that achieves a similar goal is OpenNI2, which enables processing images for natural interaction, allowing developers to extract user positions and skeletons from a scene.

using this library requires specialized hardware, with appropriate drivers, such as a Microsoft Kinect sensor.


Information retrieval commonly allows keywordbased searches.

developers are searching for source code in terms of features, functionality, and requirements; source code is written in a programming language, while search keywords are in natural language.


For example, the functionality of sensor nodes may need to be changed based on newly sensed events and the constraints imposed by limited memory space will necessitate remotely reprogramming the device as opposed to storing all envisioned codes locally.

the flexibility of field upgrades provided by such remote reprogramming also makes the code vulnerable to eavesdropping and execution in an unauthorized device.


From these scans, we can select one value p(x, y)j as new pixel p(x, y)stego.

due to the noise inherent to the scan process, it is not likely that we will .nd scans where four pixels are identical to the pixels of the stego image.


Our goal is to guarantee that every step executes in bounded time, and that overall program execution occurs in bounded space.

we cannot make such guarantees for arbitrary FRP programs, and thus we de.ne a subset of FRP called Real-Time (RT-)FRP for which we can make such guarantees.


The current estimate of number of devices sold is around 500 million [1], and growing to a billion in the next couple of years.

the number of desktop PCs has saturated to around 500 million [1, 2].


Our microbenchmark results showed significant differences between Linux and Windows.

for the application benchmarks the differences were much smaller.


Our current implementation does not implement the recovery scheme described in Section 4, so we do not have accurate measurements for the amount of duplicate evaluation detected and recovered from.

we have reason to believe that the .gure will be small in the case of GHC: we measured the number of times a GREYHOLE thunk was entered, in a version of ghc-smp compiled with grey-holing support.


We focus on the representation of a single page of code, though current trends in the visualization of code focus on the management and representation of large-scale programs  and despite the fact that we appreciate that interaction with 2.3 Differences between textual and visual languages code is important [5, 7].

we think that represen tation at the level of the page is overlooked: understanding a single page of code is still required since the very act of programming (i.e., editing code) is often done at this level.


The reason for this heuristic is that while the cost of mispredicting a short-hammock 3When there is a chain of CFM points, the probability of merging at X in Alg-freq has to be modi.ed to compute the probability of both paths of the diverge branch actually merging at X for the .rst time, instead of just reaching X.

for the diverge branch candidate A in Figure 4, probability of merging at C = pT (C) * pNT (C) = 1 * P (BC) = P (BC), where P(BC) is the edge probability from B to C. probability of merging at D = pT (D) * pNT (D) = P (CD) * P (BE) because if the not-taken path of the branch at A takes BC, the actual merging point would be C instead of D. T F  Figure 4.


For example, there is a Graph-Node to represent internal transitions of the state, even if there are no such transitions in this particular UML model.

this is the XMI[DI] representation as produced by the Poseidon tool.


Thus, we include only operating-system-dependent techniques as well as some code transformations in the energy feature library.

the idea is that the library can be extended by others providing their own techniques.


Co-scheduling of tasks: An important advantage of NIMBLE is its ability to design an entire application as a series of encapsulated, reusable tasks.

executing each individual task as a separate job can result in excessive startup costs and lost opportunities for data reuse between tasks.


Both parties, Alice and Bob, could simply encrypt and sign their RSSI measurements, and a third party, Victor could compare the RSSI trace results, measure the correlation coe.cient (much as we have done), and if he calculates a value r > 0.9, he can be certain that the .ngerprint is valid.

there are issues with using raw RSSI values as link .ngerprints: for one, both parties will have to store every RSSI value for every transaction in memory which may not be feasible for memory-constrained sensor devices.


For example, we were not able to draw conclusions about the results of P[44].

authors noticed that future defect prediction models need to use more information from developers and micro level interactions for effective defect prediction.


-Interviewee 4  The subjects also quoted Non-functional requirements as factors that affect the effort estimation in Web projects.

subjects mentioned specifically maintainability, scalability, and usability requirements.


4.3 File I/O Since we generally run the program for many hours, the extra eight seconds of File I/O at the start was not a big concern.

we nonetheless pursued the question of how to get the Ada code to do I/O faster.


The expansion of Web services has increased the attention given to processes, because processes are how services are composed and put to good use.

current approaches are inadequate for .exibly modeling and enacting processes.


Typically, we can deal with nondeterminism via a uni.cation-based approach, which integrates well with AGs [5].

some applications require a more powerful approach, with an algorithm that actively tries out alternatives at choice points.


Stateless .lters are amenable to data parallelism, as they can be replicated any number of times to work on different parts of the input stream [20].

stateful .lters must be run in a serial fashion, as there is a dependence from one iteration to the next.


In our case, performance will be used as the .tness func tion.

the following two considerations have been taken into account in the design of our .tness function: 1.


Second, it avoids message reordering because mouse events are guaranteed to be processed in order on the player s host and moves can be requested over a single, ordered stream.

executing this untrusted code locally aggravates the trust challenge and requires the avatar to understand the details of sandboxes to ensure security.


an inspection of a set of regular applica- tions, the SPEC floating point benchmark suite, shows that loop bounds, although not compile-time constant, are rela- tively constant at runtime (see Figure 2).


Prototypes can be easily created as a package of slides and widely distributed because of PowerPoint s wide install base.

designing interactive prototypes using PowerPoint can be a time consuming process given the intended use of the application.


Both CnC and Hi-PaL, share the goal of helping the end-users develop parallel applications at a high-level of abstraction, have long-term goals of supporting multiple architectures, and intend to provide separation of serial and parallel concerns.

as previously mentioned, there are a lot of differences related to the approach to parallelization from the implementation perspective and usage perspective.


These claims are justi.ed by consensus agreement in the programming language community.

there are also two other claims which fall into the desirable language properties category that are presented without evidence.


In such scenario, it is frequent that existing alternatives are not explicitly recorded because they reside in the architect s mind.

recording all the alternatives considered during the development of the system seems quite useful (e.g.


Also, formal <: work has been performed mixing gradual type with type inference [17].

we are not aware of any programming language that implements gradual typing.


This is problematic as the students who need the most feedback are those who are also most likely to have less developed skills at reading patches directly and using version control tools to be able to find and review grading feedback.

gradeBoard does not require students to use any command line utilities to read and understand grading comments.


A reasonably high predictive accuracy of IFN models is important if we intend to use them as automated oracles in regression testing, but expecting them to become perfect predictors of all outputs in complex software systems is certainly unrealistic.

as shown in [21], the inherent compactness of these models can help us to recover the most dominant requirements from execution data and, consequently, to build a compact set of test cases.


Therefore, there exists an integer-valued function g; fsuch that g(x) <g(y)and gis certainly called when f (x· a)and f (y· a)are evaluated.

since state(x)=state(y)holds, g(x)<g(y)implies g (x)= g(y)= 8.Now let ube the boundary used in f ; then, g (x)=8 implies ++ g(x)>u, because f ; eimplies g; efor any expression e. g(x) = f(x· a)holds from construction of f,which implies u<f(x· a).


Conversely, normally sub-commands are not shown to users in the why menus, and instead just the top-level command would be included.

if the programmer wants to allow the user to ask about a sub-command, then its Show-In-Why-Menus can be set to true.


Time (days) It appears di.cult to obtain a closed-form solutions for these 10: Proliferation with abandonment and non-linear di.erential equations.

they can be e.- Figure freeloading their attempts to get a good copy, so that in future they are discouraged from trying to download any other content.


The dominant paradigm for concurrency in desktop programs is multithreaded programs where shared-memory accesses are protected with locks.

programming with locks is error-prone: too many locks can slow down or even deadlock an application, while too few locks result in data races.


A  1The goal is that applications conforming to each compliance level should be capable of being certi.ed to the highest level of integrity.

it is accepted that the e.ort required to certify at compliance Level 2 may be signi.cantly greater than at Levels 0 and 1. notable restriction of the Level 1 programming model is that use of Object.wait() and Object.notify() is prohibited.


The second run of the algorithm will (very likely) invalidate this spurious equivalence since the probability that b mod q1 = b mod q2 for randomly chosen large enough q1 and q2 is very small.

note that this technique does not discover the equivalence y = bx; in general it does not discover equivalences that involve constants that are larger than the randomly chosen prime numbers.


in their paper [11] provided a detailed survey of di.erent integrity assurance mechanisms that are in use today to tackle the problem.

little work has been done on studying the real cost of providing checks to verify integrity of the data, particularly in the context of a parallel .le system.


The discussion in this paper makes a few simplifying assumptions for clarity: one, it assumes that developers push to and pull from only the master repository; two, it assumes that developers only make a commit when all their tests pass.

our approach in general, and the Crystal tool, in particular, handle arbitrary pushes, pulls, and commits.


From Table 2, the average number of parents is always less than 2.

the number of ancestors in a type hierarchy can be 29.89 times larger than the number of types.


This level of precision ensures that injection points are unique on each tested execution path, and all possible library-level faults can be explored.

this produces a large fault space, and introduces the possibility of test redundancy (we will show how AFEX explores this space ef.ciently in §7.1 and mitigates redundancy in §7.4).


The correct implementation of the function search should .nd the largest, max, and the second largest, second, keys in an array L of n keys by sequentially scanning the array and keeping track of the two largest keys seen so far1 .

the implementation of the search function given in Figure 1 contains a seeded fault at line 10, where instead of assigning L[i] to second, L[i] is incorrectly assigned to max.


Most of the prior work on memory disambiguation has primarily focused on pointer analysis, and either presents only static estimates of the accuracy of the analysis (such as average points-to set size), or provides performance data in the context of certain individual optiraizations.

our study is based on a complete memory disambiguation framework that uses a whole set of techniques including pointer analysis.


The di.erences (D1) and (D2) still hold between [35] and our approach since the applicability of transformation rules has to be restricted by NACs, and all kinds of model modi.cations and not only well-de.ned delta operations can be modeled.

the di.erence (D3) does not hold as the transformation rules in [35] also reuse the concrete syntax of the corresponding modeling language.


The worker basically executes statementbefore ( set a piece in Figure9 as do ), statementbody , and statementafter ( remove the piece inFigure9 as undo )inthisorder.

duringthe execution of statementbody , statementafter is also executed as an undo clause before an attempt to invoke an older task request handler.


The third model was proposed as a solution for both these drawbacks: the models are more compact and compositionality is inherited from Reo automata.

the applicability of the latter model is also constrained by the lack of tool support.


Here, to match with previous papers in the domain, we use a 32-walker simulation.

applying self-organization, we see that most of the time, the performance in terms of hops almost doubles.


Regardless of the instrumentation used, most public Java tracing tools are limited mainly to recording method invocations.

such information is rarely sufficient, and better means are needed to instrument the application.


Pickle Veri.cation We argue that the design we have presented so far ensures type safety for pickles in the sense that there is no way to corrupt the runtime system from within the language: for any pickle written by the system, unpickling is always safe, regardless of type mismatches.

there remains the obvious possibility that pickles are forged outside the control of the system (this may include the use of the library s low-level I/O subsystem).


In implementations of most statically typed languages, it is important that the type safety of the whole program is guaranteed when type-safe modules are linked together.

in C, intermodule type safety is not guaranteed in usual implementations.


However, we currently do not provide a module for merging developer pro.les and experience levels scattered on several pro jects.

this aspect has already been studied and should be easily included in XTic in a future work [12].


A survey article on refactoring [11] shows that most of the scientific work has focused on tools and metrics.

industrial literature has reported different refactoring techniques and various structures that, according to the authors , need refactoring [2, 3, 18] the role of humans as decision makers whether to refactor a piece of code or not, has been mostly neglected.


Given this, errors in the machine description are likely to have been found and corrected.

the reverse-engineering described here was able to .nd errors in the resource maps for three instructions, shr, shl, and shr.u.


Selecting Object-Oriented Source Code Metrics to Improve Predictive Models Using a Parallel Genetic Algorithm Rodrigo A. Vivanco1,2 1Biomedical Informatics, Institute for Biodiagnostics, National Research Council Canada Winnipeg, MB, Canada +1 (204) 983-7393 Rodrigo.Vivanco@nrc-cnrc.gc.ca Abstract Predictive models can be used to discover potentially problematic components with source code metrics as input features.

there are many structural and design metrics that capture related measures of coupling, cohesion, inheritance, complexity and size.


[[r]]full(a) as [[objt r]]type where e has type tempt r = unpack a, x =[[e]]exp in x.mt.m x where a and x are fresh = unpack a, x =[[e]]exp in x.f where a and x are fresh = unpack a, x =[[e1]]exp in pack x.f := [ e2]]exp,a as [[objt r]]type where e1 has type objt r and a and x are fresh = .x ' :t.let x = pack x ' ,t as t ' in [[e]]exp where x.e:s has type t ' I s and x ' is fresh Figure 2: The Translation O typing derivation.

i present it as a function of O expression syntax and indicate the typing assumptions.


[9] Although they have not published results of applying Echelon to components, in theory, the tool seems to be applicable to test selection for COTS components.

echelon is a large Microsoft internal product with a significant infrastructure and an underlying bytecode manipulation engine.


The most important dependen- cies are those involving assignments such as x = y and z = y+l.

an assignment such as zl = !y can be ignored, since changing the type of y has no effect on the range of values of zl, and so the type of zl does not need to be changed.


In particular, they summarize the variable de.nitions of a procedure, which in the context of Java programs will require static points-to analysis.

we only seek to identify the inter-phase dynamic dependencies which can proceed e.ciently without any points-to analysis.


Hence a higher value of measurement is preferential.

a higher value of measurement indicates a higher chance of more complete subgraphs, i.e.


Our work relates to these models in the sense that rigorous formalisms are used to describe valid and invalid interaction patterns.

these models are becoming increasingly untenable because of the increasing need to seamlessly handle dynamically unfolding events and the associated need to dynamically change policies.


The performance of AVM (on average 127.6 test cases) is slightly better than RS (on average 115.8 test cases).

from the Figure 3, we can also observe that the performance of RS does not stay stable, i.e., sometimes, only few test cases such as 78 can be prioritized but more than 150 test cases can be prioritized the other time.


We observe the heaviest users ( 99% ) becoming more active beginning almost immediately within a week of the event.

we observe a delay in increased usage in the 90%ile and 95%ile users, which does not begin until late February.


Aspect-oriented programming languages provide us with a way to capture abstractions as named pointcut signatures (a name and a set of parameters), which are logically grouped into pointcut interfaces.

no guidelines are available on how to identify the abstractions that lead to reusable pointcut signatures Section 6 gives an elaborate account about this lack of guidance.


The CPU usage drops for high resolution after its break point as seen in Figure 4 (b).

as the frequency of adaptation increases for low and medium the CPU usage increases beyond using a single CPU (upto 170%).


[2] analyzed problems with sharing external resources such as .les, sockets, and environment variables in replicated application sharing systems.

these problems are much more tractable in our work because ICT assumes application knowledge: File accesses in editors can often be detected and managed, e.g., by the editors APIs; only editor states and state changes need to be captured for synchronization purposes; most external resources are but sources that cause state changes; and editors in general are deterministic.


The view for the administrative interface, on the other hand, is maintained centrally, and consists of a large number of JSP pages that are pieced together with Struts templates.

because the administrative interface is identical for each clone of the Kiosk application, we are able to maintain a single set of the admin source files and deploy them automatically with each new Luwak copy.


This behavior can be explained because while nitg-e has the most dynamic type tests, those are essentially on resolved types.

in shoot, there is so much erasure tests that nit-e is 9,5% slower than nitg-s. On the unsafe versions for nitg-e and nitg-s, we can conclude that the cost of the checks are not a major overhead.


In fact, to guarantee termination, it is suf.cient to have C := T in line [5].

covering more abstract states per iteration will reduce the number of iterations of the algorithm.


Therefore a high temperature alarm should be suppressed in this situation which can be done by con.guring the EKC parameter alarmDelayAfterDefrost.

reading different sections of the documentation gives several possible interpretations: 1.


When the heap size goes beyond the point, both the total execution time and the number of page faults increase dramatically.

the number of pages faults correlates better with the execution time.


listing all of them would go beyond the scope of this paper.


The feature is represented by the binary existence of a word in a commit message.

if all single words generate a new feature, we would have two problems: the number of features would become too big for fast processing in a MLC;  words which carry the same meaning, for example .x, .xing, .xed, would be considered as di.erent.


it will never miss summaries which include the value being searched for.

index lookups may yield false positives, where a summary matches the query but when queried the remote sensor .nds no matching value, wasting network resources.


InterState objects start with one state to match the simplicity of property sheets [34], which allow programmers to easily see and modify an object s settable properties.

whereas property sheets can only specify the look of an application, InterState s state machines scale to allow programmers to specify its behavior.


The response times of both clients increase steadily with an EDF scheduler.

with the FSFQ and RW schedulers, the response time of client 2 remains steady at around 18 ms. 5.2 Differentiated Service Quality In the next set of experiments, we investigate the effectiveness of interposed proportional sharing in differentiating the service quality received by two clients according to their con.gured shares.


When calling a method obj.m(), the method s this pseudovariable is bound to obj, as expected.

when accessing a method as a property obj.m and storing it in a variable meth, as is done in the above example, the function loses track of its this-binding.


present in Ker- Meta as do..rescue blocks.

to the best of the authors knowledge, these languages do not support an explicit instantiation concept nor multi-threading14 .


3]d) (val) .r 3  The closure still does not capture a binding for x (see *).

in the following application reduction (**), the dynamic binding of x propagates and is therefore available in the .nal function body evaluation.


Thus, information that a user has installed a particular application is known to the third party search engine.

we found that the name of the application through which the toolbar was installed was transmitted every time the tool bar was used.


If the row contains a great part of white boxes and no dark gray or black boxes, the file can be considered completely new, otherwise a certain part of other files has moved the code in it.

by analyzing the columns we can deduct that a file of the old version has been eliminated if the column contains only white boxes.


It can show the execution history of join points related to particular AO elements, e.g., where a pointcut matched or did not match.

the granularity of such elements in TOD is as coarse as in the other presented approaches for debugging woven code.


There is no change in the structure of the selection, simplifying the compilerimplementation.

there is poor readability as it is not possible to tell that the entire array is being accessed.


It is worth mentioning that, when a new type is added, the encoding of the parents of the new type must be modi.ed.

tS is around 10 times less ef.cient than CPQE in terms of encoding size.


(Beh b)))) ; lift (forall (a)((Beh (Beh a)) .

(Beh a))) ; switch Parametricity (forall (a ...) C) is merely notation that may be interpreted in a number of ways.


VHDL contains the ability to perform precise timing simulations, while Promela has virtually no timing capability.

the SPIN model checker can be used with Promela models6 to explore extended behavior, which is not currently possible directly with VHDL models.


Vulnerability discovery models may prove to be a useful tool for estimating and predicting vulnerability characteristics in software.

the current literature almost universally ignores signi.cant ambiguity and theoretical concerns.


As the link utilization increases, their FCT increases only modestly.

the average throughput loss for large .ows is less than 3% In fact, the average throughput is not expected to experience a signi.cant loss under the SRTF policy if the .ow size follows a heavy-tail distribution [20].


Java has popularized the use of multithreaded programming to address multiple concurrency issues in applications.

threads are not always .ne-grained enough to be successfully applied in all circumstances, especially when it comes to programming on customer electronic devices such as mobile phone or personal digital assistant.


3.2 Proposed Formal Representation wireless infrastructure networks.

the dynamicity is present in mobile/portable devices and their communication with base stations in the proposed architecture.


No security mechanisms is provided, and due to uncontrolled implicit rebinding it is not clear how a sandboxing mechanism could be programmed.

acute provides other features not directly available in Alice ML, e.g.


In ordertofacilitate comparisons withearlierworkon atomicity, ourpresentationfollows that of[20], with thekey addition that we now verify cooperability in addition to serializability.Thispresentationformalizes our resultsin terms of anidealizedlanguage, but prior workproduced expressive type and effect systemsfor verifying atomic speci.cationsinJavaprograms[5,19 21,23,40,49], and webelieve that such techniques couldbe adapted, mutatis mutandis, to also verifyyield speci.cations.

a Motivating Example We illustrate the utility of yield annotations via the code fragment shown inFigure 1(a).At a high level, this codeperformsthe update x = f(x) ontheinteger shared variable x.to avoidholdingthelock m protectingx duringthe computation of f(x), the code .rst reads x into a local variable y, computes f(y), and then acquires the lock to perform the update of x.


Evaluating P of them could take O(P × (V + E)) operations.

in practice, we expect P « V and heap queries are much less frequent than heap updates, and hence for large program heaps, this approach is likely to be superior to Name Semantics Description running() stack(Thread t) {r.obj | L(r) = running}{v | (r.stack, v) .


The combination of virtualization and IaaS therefore holds the potential to revolutionize software service life-cycle management.

several key challenges are yet to be addressed to ful.ll the promise: Challenge 1: Solution Design.


That is, in the case of architectural styles, the instantiated fragment can be seen as a refinement of the base style to get an architectural model for the system.

in the case of framelets, the resulting fragment is actually an objectoriented system produced by a conventional framework specialization [20].


When failure is predicted, the FTM proactively initiates failure aversion.

in t, if failure aversion is successful, P transits either to c or p. if unsuccessful, P enters r and the FTM initiates a reactive strategy.


THE LOGICAL MODEL In the past years, some interesting approaches have been proposed for de.ning a formal speci.cation of commitment protocols using di.erent logics such as CTL [4].

specifying protocols that ensure .exible interactions is necessary, but not su.cient to automatically verify the conformance of these protocols with some desirable properties.


Solution domain analysis is advantageous for at least two reasons: solutions are likely to have addressed more concerns because they have been tested in a real-world environment and they provide a source for reusable code.

such solutions may be too implementation-speci.c so as to inhibit code or design reuse.


Needless to say, that satisfiable requests may still be rejected if current configurations do not allow to distribute the requested sensor readings.

the requesting entity must be informed about the acceptance decision for the request.


It ensures that a TLAB, allocated to a thread comes preferably from its local memory node.

this doesn t solve the problem of remote object scanning and copying.


One can argue that using the multithreading capability of the IXP, someone can hide this memory latency.

as it was demonstrated in [10], the overhead for the context switch, in the case of multithreading, exceeds the memory latency and thus this IXP feature cannot increase the performance of the memory management system, when external memories should be accessed.


Tasks already scheduled complete at t = 250s.

the capacity scheduler proceeds unaware; the resulting contention lowers disk throughput leading to both straggler tasks and delays in ingestion.


For the pure .-calculus as well as the two extensions with only continuations and only mutable references, enf bisimilarity is strictly smaller than contextual equivalence, that is, enf bisimulation is a sound but incomplete method for proving contextual equivalence.

for the full calculus with both continuations and mutable references, we prove that enf bisimilarity is fully abstract in the sense that it coincides with contextual equivalence.


This optimization may improve program locality since the monitored program and the analyzer can work on their own working sets in disjoint phases.

the additional buffer increases the memory pressure and its size needs to be chosen carefully.


Llanas current conclusions are that the level editing tool was simple enough to use for both students and teachers.

his field experimentation highlights some needs related to the Serious dimension.


On SMP and NUMA platforms it is safe to assume that an ef.cient implementation will be done using shared memory.

on the MPPA-256 platform, the RE will forcibly employ shared memory for intra-cluster and the NoC for inter-cluster communications.


This is because the detection of aliasing relations in programs is undecidable [9].

the proposed type system handles recursive data structures ef.ciently and precisely at the cost of coercions and type annotations by programmers.


And the operating system also provides algorithms for enabling processes/threads migrationtolessbusycores.

we may choose to alter default behaviors to optimize the performance.


Subregions and Portals Shared regions provide the basis for inter-thread communication.


In addition, it is noteworthy that the worst performance of FSCS-ART-C is similar to RT s e.ectiveness, which may imply two bene.ts: (1) Compared with FSCS-ART, FSCS-ART-C has more characteristics of RT; (2) For any faulty program, FSCS-ART-C can be used to replace RT even if it meets the worst situation.

these two advantages should be further investigated.


Since with high probability a failing execution terminates di.erently than a regular execution, AVA frequently generates this interpretation.

it exists at most one occurrence of this interpretation per analyzed failure.


However, unlike MX honeypots, honey accounts are created across a range of e-mail providers, and are not limited to addresses a.liated with a small number of domains.

since these e-mail addresses must also be seeded distributed across a range of vectors that spammers may use to harvest e-mail address lists (e.g., such as forums, Web sites and mailing lists) the quality of a honey account feed is related both to the number of accounts and how well the accounts are seeded.


They proposed .rst inferring temporal properties that generally hold for the dynamic traces, and then merging states, while ensuring that the merge does not violate the inferred properties.

this approach only considers the observed execution sequences and does not consider internal state information.


Whenever the Java virtual machine(JVM) for an application needs more space for its heap, its own memory allocator requests the global memory manager to give a heap area.

the garbage collector in the JVM relinquishes its surplus heap areas back to the global memory manager.


In Section 5.2, we show that there is a placement f0 that maps all elements in U to a single node v0 in the tree TG and minimizes the congestion of the tree edges.

this placement has very high load, and since our goal is to achieve low loads in addition to a low network congestion, this solution is clearly not acceptable.


Enabling this property for every possible block would avert the problem of over-/under.ows completely.

each check requires processing time and may lead to dead code.


To correct for this, the loop would have to be unrolled 10 times, using 10 counterexample-guided re.nement steps.

consider the PathBound abstraction, with an abstract state t representing all the segments in the loop.


The descriptions of design patterns given in [8] are guidelines for their application.

a design pattern can be rei.ed differently based on different environments.


Approaches for Impact Analysis have been developed to assist developers with changing software.

there is no solid framework for classifying and comparing such approaches, and it is therefore hard to .nd a suitable technique with minimal e.ort.


The transaction-ordering rule prevents this reordering.

it allows statements from T2 that ran before T1 committed on the primary to be run concurrently with statements from T1 on the secondaries (such statements are guaranteed not to con.ict because strict two-phase locking would not have allowed Q2 to complete on the primary if it had any con.icts with Q1.)


To be consistent with the ACO basic features, during each iteration we could dynamically update a graph by adding and deleting some edges associated with the newly generated and eliminated input values.

since all the pheromone information is surrogated by the PDF that is learned only from the test cases in the population, we no longer need the graph structure to modify the pheromone information.


The bene.ts of this scheme get explored specially in cases where there is high variability in the execution characteristics of benchmarks, like ferret and sphinx.

even for benchmarks like streamcluster, httpd and .uidanimate, LIMO shows bene.ts.


Hence, privatization should not be considered as a replacement to synchronization, but is rather complementary to it.

privatizable accesses are not all necessarily (though they are often) related to concurrency bugs.


As mentioned already, for linearizability our result holds for some sequential executions.

when implementing an algorithm, it may be dif.cult to differentiate the sequential executions of a given method for which the result holds and those for which it does not.


Most assignment operators return the same value that is assigned to the variable to which they are applied.

the postfix increment and decrement operators are different.


For a given part of the UML metamodel, it is possible to generate all model configurations within a finite number of instances for the metamodel types present.

the number of models increases rapidly due to combinatorial explosion.


The rationale behind this is that we want to keep the object size in shared memory optimal.

when mapping a shared class to a private class in a context other than allocation, we allow both private and shared .elds to remain unmapped (if they do not have a match).


We pointed out that different aspect-oriented programming languages support different conceptual models of join point selections, and consequently provide appropriate means to select join points in correspondence to those conceptual models.

as soon as developers wish to specify join point selections relying on a conceptual model other than the supported one, they usually need to implement cumbersome workarounds which do no longer reflect on the conceptual model underlying the corresponding join point selection.


This might lead to unexpected states or results, for instance when two services are joined in our implementation.

such unwanted interactions can already be detected on the level of interaction patterns in our service model and are thus best handled on this level, not on the level of aspects.


Hence, tr acts as a (compositional) compiler.It is easy to see that this corresponds to the usual interpretation of typed .-calculus.


Comparing the patterns in Figure 8(a) and 8(b), there exists strong correlation between the L2 cache miss event and the cycle event, which implies that those targeted loads triggering the L2 cache misses are likely critical.

when helper threading is applied, there are some sample phases when L2 cache miss reductions do not convert to similar reductions in cycle counts.


INTRODUCTION Query containment is a well-known problem, with many proposed algorithms.

when embarking on an implementation, we found no guidance in the literature on how to modularize the software or apply published algorithms to a commerciallysupported language.


Our work accomplishes similar goals for sensor datasets.

a key difference with most work on watermarking is that we do not regard the user of the data as an adversary who is attempting to detect or remove the watermark.


Some researchers propose using model-based oracles [5, 18, 29].

there are major challenges in accurately modeling web applications, such as addressing the ability to navigate web pages through a browser (e.g., a user accesses pages through back and forward buttons or by typing the URL directly); the inability to statically determine control .ow due to user input and location; and the existence of numerous technologies and languages.


Since aspectual components encapsulate crosscutting concerns, this means that the usual situation would be one in which the same aspectual component affects different connections between base components.

without using queries to specify roles, it is not possible to avoid that the same aspectual binding rules appear replicated through different connectors.


All those techniques proposed on SCMM contain its description store in the Component Evaluation s Repository and should be reused in order to increase the productivity in this step.

if a new one technique was adopted in the last activity (Define SCMM level step) it is necessary develop this documentation from scratch and, at least, should contain: the name of the technique/method, the reference in literature for this technique and the description.


This reference to speed was discussed within the context of flexibility.

as research on the definition of agility has placed such emphasis on rapidity, it merits an adjustment to the definition before it can be applied to the term agile.


When one .ctitious rendez-vous event occurs, the executing ob ject simply performs a dummy read operation into the state of an adjacent cell.

we do not really enable ECS synchronization (in fact, no matter whether the dummy read access is not processed in timestamp order on the hit object), rather we only trap the access and open the stock associated with the ob ject hit by the read operation.


It is connected with horizontal scaling which adds or removes the number of VMs and vertical scaling which expands or reduces the size of a VM.

it is still deficient for accomplished resource requirements of dynamic workloads because it is lack of the consideration of resource usage during execution of an application.


This is indeed the most demanding as pointer adjustments do not pardon any error.

accessor simulation (AS) involves pointer adjustment and represents a convenient lower bound of the overhead yielded by subobjects.


Qualifiable code generators, such as SCADE, which endorse a certification of the application software, do exist.

they only make it possible to reduce the amount of some of the verification activities but do not allow them all to be omitted completely.


This policy allows an operator to accurately follow the uncertain movement of a neighbor by creating an uncertain plan for the operator.

it yields a high computational cost, because it requires to maintain many time-graphs.


As a simple example, concept assignment would relate the human-oriented concept buyATrainTicket with the low-level implementationoriented artefacts: { queue(); requestTicket(destination); pay(fare); takeTicket(); sayThankYou(); } Often, human-oriented concepts are expressed using UML diagrams or other high-level speci.cation schemes, which are far removed from the typical programming language sphere of discourse.

implementation-oriented artefacts are expressed directly in terms of source code features, such as variables and metho d calls.


The Essence of Command Injection Attacks in Web Applications Zhendong Su Gary Wassermann University of California, Davis University of California, Davis su@cs.ucdavis.edu wassermg@cs.ucdavis.edu Abstract Web applications typically interact with a back-end database to retrieve persistent data and then present the data to the user as dynamically generated output, such as HTML web pages.

this interaction is commonly done through a low-level API by dynamically constructing query strings within a general-purpose programming language, such as Java.


d) Communication using Shared Memory: INSPIRE does not prohibit the exchange of information using references to shared memory locations.

as usual, the content of memory locations updated by other threads remains unde.ned until a synchronization between the source and target thread occurs via a common call to redistribute or the forwarding of information using a channel.


This would be ine.cient, since BDD size, and therefore performance, is very sensitive with respect to the number of state bits.

a program typically uses only a small fraction of the address space.


However, if convergence is too fast it can lead to algorithm failure, as Cant´u-Paz [8] states referring to parallel EAs: Rapid convergence is desirable, but an excessively fast convergence may cause the EA to converge prematurely to a suboptimal solution.

as statedbyDenzinger andKidneyin[11], the e.ect of this high-.tness immigrant in the population will usually be to reduce diversity via combination with other high-.tness individuals, which will eventually lead to a diversity collapse, as high-.tness individuals are circulated from one node to others.


A non-incremental strategy can incorporate any changes in the rules and facts by abolishing all memoized calls, answers, and various dependency structures, and re-issuing the same query which will again generate all information with respect to changed facts and rules.

such re-computation is often wasteful as typically in network the changes occur are small which typically results in small changes to the already computed information.


At any given moment, there is one active application that processes user inputs, runs animations and other ongoing activities, and updates the display.

pDAApplicationSwitcher has its own version of the Stage interaction loop that calls the active stage s doOneCycle and also: 1. checks for ride reservation state changes 2. checks the battery level 3. polls the location sensor 4. returns to home card after a few minutes of idle time 5. optionally, puts the device to sleep when idle  Of course, one could also use threads to perform these background tasks, but threads can be tricky to reason about and debug.


In general, Mc2FO R cannot handle arrays where number of dimensions are not known at compile-time.

it can handle arrays where the size of particular dimension changes at runtime.


[5] used logistic regression to control what optimizations to apply in JikesRVM.

they do not attempt to control the order of optimizations and instead only turn on and off optimizations given the hand-tuned .xed order of optimizations.


In our experiment, we considered only basic remote communication concerns, not implementing distribution issues such as caching, fault tolerance, and automatic object deployment for load balancing.

we believe that those issues could be implemented essentially using the presented approach, revealing no further conclusions about the use of AspectJ.


This is not a complete solution as the disk cannot capture the access patterns correctly due to three reasons: (1) caching of blocks by OS, (2) changing access patterns, and (3) the fact that replicating all blocks would consume at least half of total disk space.

type-awareness enables SRDs to know the relationship between blocks stored on the disk and selectively replicate meta-data blocks.


Therefore,itis noteasytodraw anygeneral conclusions with respect to the RQ2.

given the overlap, despite only conducting the .rst part in the guidelines, it indicates that the actual conclusions are at least not highly dependent on whether using database searches or snowballing.


We can easily prove that the rules in Table 1 satisfy the requirement by checking the de.nitions.

if two users change the same location to di.erent values, we say that the two updates by the two users con.ict with each other.


These scripting languages are very powerful: they already provide convenience functions for the most common tasks (e.g., compiling, .le copying) and allow integration of arbitrary other tools via extension mechanisms.

their .exibility comes at a price in many cases, the build systems designed with such languages are monolithic entities that are very di.cult to reuse and compose.


In terms of cost, the concept of capturing the trace links for the entire system and decomposition levels may make the cost of establishing this trace links higher than other methods.

the approaches in former sections focus more on the traceability for a part of the system and its design procedure.


If the process is waiting for output to be released, it could be worthwhile to consider whether it is safe to allow that output.

the system s performance as a whole may suffer if the boundary of speculation expands too far.


There is a large body of previous work on fault-tolerant design of on-chip cache memories, mostly proposed for single core processors .[8].[9].

they face severe limitations when they are applied to emerging NoC-based multi-core/many-core architectures with distributed on-chip memories where the number of access points (cores) and memory banks are numerous, access latencies are not unified, interconnect backbone affects the reliability, and both memory and redundancy are shared among all cores.


5.4.1 Code Visualization The bp module supports any unstructured code, as long as it uses init, add, start and sync.

if the code has a speci.c structure, it is possible to produce a visual representation of its behavior automatically: A module named bp_vis produces a diagram of a transition system depicting the b-thread.


In the ps I grep X example shown in Figure 7, the system calls read and execve are .agged as a race because they are concurrent, they access the same resource, and at least one, execve, does a store.

the system call exit of P3 also stores to the same resource, but is not .agged as a race because it is not concurrent with any of them as read happensbefore exit and execve happens-before exit.


The user may manually retract the con.icting training example if she decides that it was a mistake.

the user may instead just select an inconsistenthypothesisif she so desires.


In system design and documentation informal approaches like box-and-line diagrams and natural language prevail, mainly due to .exibility and ease of use.

informal approaches lack the accuracy and precision of formally de.ned architecture descriptions.


In such a code, there is no way to extract a sub-behavior and reuse it for designing new objects.

the STATE pattern does not objectify events which may lead to memory exceeding when cyclic behavior occurs (methods that materialize state changes will be overlapped).


In order to realise the vision of true pervasiveness [1], computer systems must be able to seamlessly interact with each other and share context.

achieving such interoperation has proven difficult, especially, across a multitude of legacy and emerging systems.


[32] uses software model checkingtocheckforanumberof .le-system-speci.cbugs.Relative to ourwork,FiSCemploysaricher(moredomain-speci.c)modelof .le system behavior, including properties of on-disk representations.

fiSC does not check for errorpropagationbugs and has been applied to only three of Linux s many.le systems.


As shown in Table 3, sync-schedules are unsurprisingly deterministic for Apache and streamcluster, because no races are detected according to the corresponding sync-schedules.

they are not deterministic for the other .ve programs, illustrating one advantage of PEREGRINE over the sync-schedule approach.


1) Implementing Trigonometric Functions: One solution for implementing trigonometric functions is to execute them in software and pass the values into hardware.

because the PowerPC has no hardware support for these operations, this would introduce a bottleneck.


For example, safe state of the log grabber controller of harvester head during normal operations is to keep grabbing the log whereas the safe state during maintenance break is to keep grabbers open in order to prevent the maintenance man getting crushed between grabbers.

each actuator or controller in the system should know at any given moment which is the safe state that should be entered if a malfunction occurs.


It was shown in [20] that such hybrid routing strategies employing both coding and replication are more robust than simple replication.

these works are either very simplistic or do not have realistic assumptions.


With the advent of multicore CPUs in the PC market, the general public can readily use multiprocessors for the first time.

this also means that the industry will flood the market with computers that will run an application at full speed only if that application is parallelized.


A meta mechanism is introduced to support extension of new skeletons and for optimizing skeletal parallel programs.

most high-level parallel programming tools use a programming model that suffers from a lack of openness, making it dif.cult to tune performance.


They may also o.er computational completeness and, as in the case of XQuery, an appropriate notion of static typing.

procedural algebras .t into a well known computational model inclusive of update.


Hence, naive model checking does not terminate on this example.

the body of foo consists of one transaction, since all action sequences in foo consist of a sequence of right movers followed by a sequence of left movers.


To represent this in our model, we use an ellipsoidal constraint as others have done in the past [Garner and Pandy 1999; Maurel and Thalmann 2000].

instead of using only one ellipsoid, we have chosen to use two, with one for each side of the rib cage (Plate 6).


No inconsistencies were found in the fields Title, Abstract, Claims, Description, Patent Number, Publications, Inventors, Patent Citations and the US and International Classifications.

2 false negatives and 48 true positives were found for the Examiner field.


One danger of computing squashed images is that, for periods containing a transition from a non-keyboard scene to a keyboard, the averages will be polluted by pre-keyboard pixels.

as we will see in Section 5.2 users type passwords much more slowly than ScreenPass checks the screen.


We believe that the strategies that we have developed for modeling mid- dleware event services can scale reasonably well to larger systems.

for systems with 1000s of components as one would find in product-line applications, we plan to 171 investigate the use of compositional checking.


In comparison, the write-centric approach must propagate all elements that are written in the targeted loop, which may consume much more storage and time.

the read-centric approach has a potential down side: if most of the time the set subtraction results in a non-convex set, we will need to decompose the result into several convex sets, because the solvers of the mathematical systems normally require the sets to be convex.


To schedule tasks as lightweight threads in the Qthreads, the run time must support more general dynamic load balancing whileexploitingavailable locality among tasks.We implemented a modi.ed Qthreads scheduler, L, to use LIFO rather than FIFO queues at each shepherd to improve the use of locality.

the round robin distribution of tasks between shepherds does not provide fully dynamic load balancing.


Essentially, user actions trigger both native UI events and component-defined events.

native UI events are captured by the underlying UI toolkit and processed by the components internally, whereas component-defined events (which signal state changes) are exposed externally.


Similar to [4] we consider this as a valid objective of SPL approach.

our cost savings function considers the evolution and maintenance cost savings in addition to the development cost savings.


The simulator would be much smaller and contain only the locking behavior that we are interested in.

implementing this analysis pattern requires three tools: an abstraction mechanism for .ltering, a tool to combine the abstraction results into a simulator, and a tool that can analyze the abstract simulator.


Macro recorders record the user's actions verbatim.

a programming by demonstration system creates generalized programs --possibly with conditionals and loops -- from the recorded actions [5].


we believe that it is not possible to express such weakest preconditions using (a minor adaptation of) the Ambient Logic to the trees-with-pointers model.


Flow Sensitivity Flow-insensitive algorithms ignore the order of statements and need only maintain a single points-to relation for the whole procedure [2, 9, 11].

.ow-sensitive algorithms follow the program control .ow, maintaining different analysis solutions at different program points [6].


Naturally, a recon.gurable SMR can support our dynamic R/W memory problem.

our work solves it without using the full generality of SMR and without reliance on consensus.


Often, the disagreement is due to a tool timing out; we killed either tool whenever it took more than three seconds longer to analyze a variant than it took to analyze the original, unreduced version of the program being reduced.

there are also real differences between the sets of programs that these tools consider to be well-de.ned.


The Kaplan-Meier survival curve for STD (figure 9) shows that both curves are close to each other and have almost the same trend.

it also shows clearly that SBE curve is under the wizard almost all the time which indicates that higher number of users finished their tasks using SBE in less time as also figure 8 shows.


It turns out that complexity metrics can successfully predict postrelease defects.

there is no single set of metrics that is applicable to all projects.


Tounderstand whythe energy cost changes only marginally,note that GreenSlotmaynotalways changeits scheduleasa resultofan inaccuracy; it only does so only if a change would reduce cost.

some inaccuracies may increase cost when jobs start consuming expensive brown energy as a result.


To implement null checking, we use implicit null checks wherever possible.

in some cases we have to use explicit null checks in order to meet the Java language specification.


It can be seen that only standardised elements such as ITEM_DOMAIN or OFFER_CONSTRAINT are used, thus simplifying the parsing of instance documents.

there is no constraint that the WORKSTATION.CPU type is required in the offer.


There is a considerable body of work on the problem of refining software specifications into programs, e.g., [8, 1, 38]).

this paper is concerned with the much less explored, upstream problem of refining declarative goals into operational software specifications at requirements engineering time.


We made a usability trade-off here, in that we do not want to disturb workers at night.

this prevents capturing events such as eating breakfast or brushing in the morning.


An aspect-based implementation of Future is presented in [3] that modularises thread spawning code within an aspect.

management of futures must be written in the classes that use them.


Substituting the estimated costs of the bytecodes by the actual worst-case costs of the instructions and using our approach, the WCET is expressed as a cost function parameterized by the size or values of input arguments, providing tighter WCET approximations.

wCET work has produced more accurate (but, unfortunately, non-freely available) timing models which take into account many low-level parameters (such as cache behavior, pipeline state, etc.)


On the one hand, transparent adaption promotes the use of an extra collaboration adapter for each application which signi.cantly increases the transformation e.ort.

the GCI is only adoptable by web applications which expose a data model accommodated in the DOM.


As previously mentioned, the Oldest heuristic fails to uncover the error because it always returns the same null value for every access.

the Oldest-But-Different heuristic causes the crash with high probability.


We were also interested in how frame approach blended with component-based systems, component platforms, Object-Oriented analysis/design methods for distributed applications and programming languages such as Java.

netron s Fusion toolset is tightly coupled with COBOL, in terms of both tool environment and frame command language.


Alternatively, a path language for JSON could be used.

as our approach requires some advanced features of XPath2 not present in XPath1, it might be possible that these languages are not powerful enough.


When the producer FU fi and the consumer FU fj are directly connected (there is a wire from the register .le at the output of fi to the input of fj ), constraints (5) may be asserted as before.

when there is no such connection, the following constraints are asserted instead, which prohibit operations i and j from being scheduled on fi and fj : 0@ Xj,fj,tj  1A (6) modulo schedule.


So, in this model of component based systems we can use the Unifying Theory of Programming and additional rules for the real-time speci.cation of designs to verify if a method is implemented properly or not.

in order for this model to support the veri.cation of the temporal and real-time properties, we have to give a formal meaning for threads, and a formal speci.cation for real-time properties.


e) OpenCL: The Open Compute Language (OpenCL) programming model is not of.cially supported on Android devices.

on recent devices, like the Nexus 4 smartphone and the Nexus 10 tablet, a working OpenCL driver can be found within the system libraries.


structures maintenance as it eliminates the redundancy in the structures of the individual topics, thereby reducing the overall structures size.

when a subscriber is interested in some of the cluster s topics, but not all, the reduction in maintenance comes at the expense of an increased cost for event dissemination -some redundant events are now being sent to the user and .ltered upon arrival.


Users could specify 100%heapfullness, which would wait until completeheap exhaustionbefore using the stale space.

comingcloseto running out of memorybringsthe application to a virtual halt because garbage collection becomes extremelyfrequent.In MOVE & MARK, Melt moves all objects still markedtothe stale space.It marks all objects that remainin thein-use space, so they canbe movedto the stale space later if still marked.


This is decided by the application component developers.

the design is tailored for applications with real-time requirements.


6.3 Dynamic Memory Overhead The static analysis reveals that no program requires heap duplication, just separation.


This may happen for low memory bandwidth applications as the performance of these benchmarks is directly affected by CPU frequency.

power saving on HS21-XM is less than power saving on JS22 since HS21 has a lower frequency processor.


In our method the interference checks are performed on pairs of aspects, and the results of these pairwise checks are shown to be su.cient to determine interference freedom for all the aspects in the library.

as shown in Section 4, to enable such incremental proofs we have to pay by additional incompleteness.


The number of processes participating in the rendezvous may be greater than two.

cCS rendezvous is of two-way rendezvous semantics, which can be formally described as .


We certainly cannot expect the transformed program to always be welltyped in MLGX, because that would amount to requiring the frontend to perform complete type inference for MLGI.

we should be able to guarantee that the transformed program is also well-typed in MLGI.


This is exactly what the model checker does for us.

unguided symbolic-execution based methods would have to precisely execute many more paths, resulting in scalability problems.


network access is expensive and often unpredictable), we cannot expect the system to be perfect.

since much energy is consumed due to interactive, user-initiated events such as starting downloads or playing a media .le, it is reasonable to engage the user in the enforcement strategy.


The model extraction process described above re- quires that the predicates be supplied externally.

if directed, MAGIC can also try to discover suitable sets of predicates.


However, the server-centricity leads to several problems: Need of maintenance  Cost  Vulnerability  Poor scalability  Legal issues  The first-generation architecture itself is feasible and a working model for mobile devices, since peer applications can be very light.

the centralized architecture needs maintenance, which somebody has to pay for.


In related studies, a common way to de.ne dependencies between units of work has been through code level control/data .ow dependencies, or co-changing of the same .le [3], [8].

our discussions with some senior members of the development team revealed that generic code level dependencies are likely to be too .ne grained in our context, and that unrelated work items frequently involve updates to the same .le.


A .rst try for providing secure .le operations is to provide the following two functions: readSecIO :: File s -> IO (Sec s String) writeSecIO :: File s -> Sec s String -> IO () These functions do not destroy non-interference, because they do not open up for extra information-.ow between security levels.

the data read from a .le with security level s is itself protected with security level s, and any data of security level s can be written to a .le of security level s. the above functions are not enough to preserve con.dentiality of data.


Each EPC has an associated value (from [9]) that indicates the predicted effect and the extent to which unreliability will change due to the EPC.

there are different levels of significance for any EPC.


The reason is, that only variants can be generated that either enable customers to withdraw money (without checking the balance) or to check their account balance (without withdrawing money).

the desired solution is to allow variants with both features, as re.ected by the feature diagram in Figure 5.


If lexical variables were allowed to map to rigid types, including other in-scope type variables, we would not have to rule out the above example.

we think that this choice leads to confusing behavior if lexical type variables can name rigid but not wobbly types.


It is desirable for fuzzers to allow targeted generation of programs that showcase speci.c language features and behaviors.

the predominant program generation technique used by most language fuzzers, stochastic context-free grammars, does not have this property.


Finally, it turnes out that IP-ART is among the best methods regarding the mean F-measure.

it cannot be con.rmed that IP-ART performs as good as D-ART resp.


We can make some assertions on the quality of load balance in a parallel sorting algorithm, such as its parallel scalability and asymptotic complexity.

the actual performance of the given load balancing technique can be tied closely with the initial distribution and therefore the application semantics.


Applicative order,3 like call-by-name and call-by-value strategies, is a uniform strategy, it does not rely on another strategy and is de.ned only in terms of itself (see for example [19]).

normal order is a hybrid strategy, it does rely on a subsidiary uniform sub-strategy, namely, call-by-name.


Finally, the hyperblock formation algorithm in the compiler attempts to .ll blocks as close to 128 instructions as possible to minimize per-block overheads.

it may be that in some cases, overly full blocks constrain the scheduler too much, and that better performance may be possible if the hyperblock generator leaves space in those blocks to provide .exibility to the scheduler.


For example, Table 2 shows the top ten patterns in GO MF.

on the one hand, the activities in this ontology seem to be quite relevant due to the 7051 repetitions of the simple pattern activity.this pattern is not aclass so the analysis of its super-patterns is required to obtain further details.


Thus, when creating selective mutation operators for object-oriented programs, these mutation operators can be omitted.

our study used one sample program and did not consider mutation operators for exception-handling.


Applying Theorem 7 we know that consensus does not have representative failure detectors.

if we consider the universe of query-based failure detectors, we see that consensus has a representative query-based failure detector, which we call a participant failure detector.


The signi.cance of this method has persuaded the ISO C++ Standard Committee to add a hint parameter to the STL allocator s interface (1).

existing locality improving strategies impose code restrictions(7; 30).


In other words, as long as there is not enough SPM space, we keep selecting a new victim block, and either send it to the off-chip memory or compress it within the SPM.

if a (victim) block is compressed, we count this as an access to that block, and this delays its transfer to the off-chip memory.


Infact, different set of queries are required for generation of attack graph for different analysis query to database.

xSB s top down evaluation is tuple-at-a-time [24] where it is easy to capture dependencies between tuples.


[16], there have been few attempts at developing formal models or type systems for APL.

recent development in dataparallel language implementations [5, 12, 14] have resulted in promising and scalable techniques for high-level programming of highly-parallel hardware, such as GPGPUs.


In some domains privacy is a concern (e.g., if the workflow processes genomic data), in those cases the publication as Linked Data would not be appropriate.

there are many areas of science where privacy is not an issue and that would benefit tremendously of a more open architecture for sharing both data and workflows as Linked Data.


Note that if 2Technically, this restriction turns the unate covering into a binate covering, which is fundamentally more dif.cult than unate covering.

this formulation has two characteristics missing from generalized binate covering, which makes this formulation easier to solve: a solution is guaranteed to exist, and adding subgraphs to the cover will never make the solution infeasible.


Overall, macros tend to hide manyof the complexities of grammars, abstract syntax trees, and semantic analysis from developers and thus are more accessible and precise.

as a result, they are also less expressive and more suitable for relatively targeted language modi.cations.


Finally, the Doppler effect has been used extensively to estimate the velocity of tracked objects or to improve the accuracy of tracking systems.

we are not aware of any sensor network system that uses RF Doppler shifts for tracking mobile objects.


Tradeo.s are made everywhere to guarantee that there is no performance bottleneck.

such a general-purpose kernel is often suboptimal in a speci.c application scenario.


By writing Stork submit file, users can specify the location of the source data whose format follows SRM.

users need to write different format of submit file for data placement jobs than regular condor jobs to use Stork.


The result is usually long, rather unreadable code that needs to be re-written or re-tuned with every platform upgrade.

the performance penalty for relying on straightforward, non-tuned, more elegant implementations is typically a factor of 10, 100, or even more.


Since the use-cases are associated to business function, we have a way to associate the clusters of classes to business functions.

the execution trace files of all but trivial programs are generally very large.


In theory we can use HBench:Java to predict the running time of SPEC programs.

since SPEC programs spend little time in system classes, the few system classes serve as poor sample data for measuring JIT quality, resulting in large error rate.


In general, monitoring interfaces such as JMX [22] and ARM [2], are good candidates for the PaaS and SaaS while hardware and operating system counters can satisfy the requirements for IaaS.

the volume of the monitored data, the distribution of the data to a central management node, and the availability of the data for different control and optimization schemas raise serious challenges.


In order to validate certain properties of distributed cloud systems, it is often the case that large-scale hardware testbeds are used for observing the application behavior under conditions similar to those met in production environments.

getting access to such large, distributed testbeds can be dicult, and reproducing results is often not possible, due to the use of shared physical computing and network resources.


The Protégé tool was used to add the relations and concepts of the evaluation into the generated skeleton ontology.

this tool presents a complex interface and it would be interesting if the domain engineer could abstract much of the Protégé resources.


their bytecode counterparts is that symbolic execution does not require to build a dedicated symbolic execution mechanism and we use standard execution.

we need to supervise execution in order to guarantee termination while performing useful unfoldings.


Although x is live-in at 10 no use of x is reduced reachable from 10.

the use of x at 9 is reduced reachable from node 8, which is the target of the back edge (10, 8).


INTRODUCTION While the use of polymorphism, re.ection, and dynamic code loading limits the applicability of static analysis in modern Walter Binder University of Lugano Lugano, Switzerland walter.binder@usi.ch Lydia Y. Chen IBM Research Zürich Laboratory Rüschlikon, Switzerland yic@zurich.ibm.com object-oriented programming languages, dynamic program analysis is becoming increasingly important because it supports a wide range of software engineering tasks such as debugging, performance optimization, and program comprehension [11].

the feasibility of complex dynamic analyses is often impaired by the large runtime overhead introduced in the base program, which in some cases can run more than 1000x times slower [13, 14].


Scholars require access to the vast knowledge that is contained in the collections of cultural heritage institutions, and they demand access to be on par with born-digital resources [2].

the aim of fully integrating intellectual content into the modern information and communication technologies environment requires full-text digitisation: transforming digital images of scanned documents into searchable electronic text.


Participants valued the active wiki for its support of rapid prototyping.

because of a perceived lack of security, robustness and performance, participants did not regard the wiki as a viable platform for larger deployment.


its module mechanism is simpler and more powerful than that of Java.


4.1 Compilation Model There are many potential compilation models that could be applied to C++ templates [69].

existing C++ compilers implement the so-called inclusion model of templates, where the de.nition of a template must be available wherever the template is used.


In our study, the architecture produced by the study team consistently showed all the components and connectors needed to implement the tactics they selected.

the architecture produced by the control team was missing several connectors that were needed to implement their selected tactics.


FIPA [1] and OMG/Masif [2] are standardization activities related to mobile agents.

neither refers to migration between di.erent kinds of mobile agent platforms.


The capacity of buildings in the dataset is typically between 1 and 2 kW h/.F.

some -10 buildings exhibit very large heat capacities.


[11] proposed an extension for OpenMP tasks on the Cell BE.

the major drawback of this extension is that it has not been standardized.


If there are a lot of free pages in a primary block, this primary block should not be erased during merge operations in order to fully utilize its space and reduce its erase count.

if there only left one or two pages in a primary block, this primary block can be erased like the conventional scheme, since only one or two pages may not be valuable for reusing.


We initially aimed for simple, one-page, single bug examples with the narrator demonstrating a real debugging session.

we found that real debugging sessions often yielded unexpected side bugs resulting in lengthy sessions.


So far, only two measures are generally applicable (the number of false positives and the number of false negatives).

in order to compare di.erent AM techniques, based on the obtained results, evaluation measures are needed.


2.2.2 Calculating Minimal Steady States For a general stream graph, the minimal steady state can be calculated in a linear algebra framework by formulating a set of balance equations [17].

with StreamIt we leverage the structure of the stream graph to calculate steady states in a hierarchical manner.


higher performance and lower power consumption than previous uni-processor systems.

programming such MPSoC platforms remains a grand challenge for embedded SoC providers and users today [20].


However, these languages do not provide graph-speci.c semantic information which is essential to our approach.

gremlin [1] is a graph traversal language that is designed for querying on-line graph databases.


record Abstract : Set where .eld type : Set decEq : Decidable {type}= Usually, a Set .eld must not occur in a record of type Set, and we would have to give Abstract a larger type Set1.

agda has a .ag to assume Set : Set, and we use it here in a non-essential way to save the work of having to lift most of our other de.nitions into Set1 as well.


(Despite the more extensive hardware in Combined, its reliability can be made equivalent to that of Multi-speed, as we discuss later.)

multi-speed has two disadvantages: (1) it suffers from the performance overhead of changing speeds on the critical path of disk accesses, whereas the equivalent overheads in Combined can be hidden; and (2) the low-performance disk in Combined can be aggressively optimized for low power consumption, whereas Multi-speed does not allow such .exibility.


so as to investigate if the above results are uniform among all possible candidate component sizes, we had to split the dataset and perform further analysis.


Our prototype implementation does not currently support these additional mechanisms.

they can be incorporated in a straightforward manner by extending the MHP analysis to reason about them.


At any program point, one register from each pair is visible to the compiler.

by executing a special SetMask instruction the set of registers that are visible to the compiler can be changed.


The Multiple PVAS provided results showing that a processing request from Xeon Phi to Xeon took on the order of 12 to 14µsec for the frst time only, and 2 to 5µsec from the second time onward, and a processing request from Xeon to Xeon Phi took on the order of 8 to 9µsec for the frst time only, and 2 to 3µsec from the second time onward.

the Intel ofoad model gave results such that processing requests from Xeon to Xeon Phi took on the order of 840 to 910µsec.


Nevertheless, the resulting approach is not computationally e.ective and serves as a trial to show that deployment decision making is important and necessary to apply.

these approaches rely on a centralized optimizer that often has to crawl through the entire state-space of decision alternatives.


This also complies with agility: providing a simple and light enough traceability scheme which is achieved through an iterative and incremental approach in de.ning the scheme.

using DSMLs for traceability requires us to consider change and evolution issues in the context of MDE.


3.3.3 Contextual View The Flow View displays .ow information about the exceptions at the statement level with respect to throw and catch statements.

it does not show this .ow information in the presence of the statements context with respect to the programs hierarchical structure (e.g., to which class and method a statement belongs).


Designers might not be in the position of deciding on these issues they rest in the hands of courts and Data Protection Authorities (DPA), with the final judge being market acceptance.

designers should still consider these issues, at least to increase profitability and hedge liability.


The management protocols include fault detection as well as configuration change management.

in the field of distributed storage systems, each solution rolls their own management system.


That is, nontermination under a fair schedule is unexpected and is potentially an error.

there is no requirement on these programs to terminate under unfair schedules.


This approach, henceforth referred to as innermostloop-centric modulo scheduling, naturally extends the single loop scheduling method to the multi-dimensional domain.

the approach has two major shortcomings.


Since we use only one global delay, this is a correct abstraction.

we can imagine to have a more complex control that will compute different delays for different DAGMans, therefore needing to represent each running DAGMan explicitly as an actor.


The idle phase is the simplest since it is clear which copy should be used.

pointers to old copies of the object may still exist, and therefore, the barriers are actively checking that the application only uses the new copy.


Even with a modest rate of packet loss, the reported aggregate experiences a substantial relative error.

figure 8(b) illustrates the same experiment employing our acknowledgment scheme presented in Section 6.2.1.


It may seem rather unnatural to represent paths as sequences of edges rather than sequences of nodes, given that patterns will usually examine the target node of an edge rather than the edge itself.

using edges rather than nodes give us slightly more power in particular, it allows us to specify that a path goes down the then or else branches of an if statement.


This error tracing technique is adapted from ESC/Haskell [38], which achieves the same goal as thatin [23]butina much simpler way.

unlike [23] we have not yet formalised the correctness of its blame assignment.


With the information about the context of components, a designer or assembler can make the exception handling more appropriate.

software architecture describes the gross structure of a software system with a collection of components, connectors and constraints [3].


3.1 Modularity Modularity is important to separate concerns and help improve program maintainability by enforcing boundaries between components.

the use of a particular architecture does not provide modularity automatically; effort has to be placed in the design to make a program modular.


A VIRTUAL KERNEL DEVELOPMENT LABORATORY To support kernel-level programming projects for students to learn about operating systems, what we would like to do is provide each student with e.ectively root access on a dedicated machine which the student can use to test kernel code and crash and reboot at will.

we would like to do this without the expense and administrative di.culties of providing a dedicated physical machine for each student.


It would appear that the recomputed IDF s had a good e.ect on discriminating good documents from bad.

it is not clear that precision was improved, even though higher ranks were retrieved.


DISCUSSION In this paper we have been primarily focused on using seamful design for developers within the domain of positioning applications.

we believe that the methodology is useful in other domains as well.


For instance, if the true branch of a complex condition leads to an execution path which needs a large amount of time during the execution, ERTT is successful only when this complex condition is satis.ed.

the objective function which is solely based on the execution time does not direct the evolutionary search to satisfy this condition.


Also, SPUR does not only record traces for proper loops, but SPUR also starts tracing from trace anchors placed after all potential exit points from existing traces, and at entry points of potentially recursive methods.

sPUR records fewer loops than TraceMonkey for some benchmarks.


The UDC data record what automated refactorings get invoked.

they do not contain more detailed information about how an automated refactoring is performed, e.g.


Compiling with Clang 3.0 (which uses LLVM for the backend) did not signi.cantly improve matters.

we could also improve the Repa version by preallocating the source and result arrays and using the ForeignPtr support to swap and reuse the same buffers between iterations.


PCOM indeed can be used in both types of scenarios.

it regards each device as being equal and, thus, does not take special care of infrastructure devices whose additional resources could be used for con.guration.


Thus, a framework can have various versions and each one may be used to develop various versions of many applications.

an application version will always be dependent on only one version of a specific framework [1], [9].


Although small allocations dominate the call distribution, the larger less frequent allocations are responsible for the bulk of allocated memory simply because they are so large.

gcc, twolf, and vortex allocate most of their dynamic memory through a large number of mal-loc ( ) calls that allocate less than 2KB of data at a time.


In the case of three-way merging, EMF Compare constructs change logs relative to the base version and offers these changes to the user, signaling con.icts among the changes.

only con.icts are detected which may be recognized easily by inspecting individual change operations and their parameters.


Machines have only recently become fast enough make GC pauses short enough to not cause noticeable delays during complex lighting animations.

(straightforward linear animations runs just .ne on a 133-Mhz Pentium.)


From this relation, the Core site is required to be more trusted than either the User or the Resource sites.

no ordering exists between the User and Resource sites, since neither of these two is assumed to be more trusted than the other in a comparable manner.


The simplest edit language is a free monoid whose elements are just words over some set of primitive edits and whose multiplication is concatenation.

it may be useful to put more structure on edits, either (a) to allow more compact representations or (b) to capture the intuition that edits to different parts of a structure do not interfere with each other and can thus be applied in any order.


The members of the Eclipse project develop common assets (such as GUI components and code generation tools) that each of them requires, but that, on their own, do not create value for their customers.

developing such assets requires them to dedicate resources.


According to our preliminary tests, this product does not appear to support cell arrays except in very speci.c circumstances, nor does it support a general form of lambda expressions, and was therefore unable to handle quite a few of our benchmarks.

the key differences with our work is that we are designing and providing an extensible and open source toolkit for compiler and tool researchers.


If a developer searches for a term in the source code, the developer will want to see all places that the term appears.

when one considers the work of an individual developer on a large project, a mismatch begins to emerge.


Preventing the RTSJ Priority Inversion So far, we presented techniques for checking that real-time threads do not create or destroyheap references, create new regions, or allocate objects in VT regions.

there are two other subtle ways a thread can interact with the garbage collector.


On the one hand, if peer testing is introduced early in the course, it may provide lasting bene.ts for the remainder of the course.

if too many students have poor testing skills, then peer review may not be fruitful, so it may be useful to delay peer review until students have learned some basic concepts, terminology, and techniques as applied to some early, simpler programming assignments.


The following3columnsshowthe component partsofthe memory load: mutator allocation, mutator collection, and background collection.The memory loadvaries greatly across applications.However, with background threads the mutator threads always spend less than 1.5% of their time performing collector work, although theymay still spend signi.cant amounts of time on allocation.

the total memory load increases with background threads because the collector runs more frequently, using the spare cyclestokeep memory utilizationlow.


SPECjbb2005 is known to be highly scalable with minimal lock contention, as such it offered little opportunity for SOLERO to show its potential for higher scalability than the other lock implementations.

the single-thread advantage of SOLERO over the other lock implementations carried over proportionally to higher number of threads, yielding the highest throughput across the various numbers of threads.


Keywords Object-Oriented, Code Inspection, Delocalisation 1 INTRODUCTION Software inspection has established itself as an effective technique for finding defects [6].

the vast majority of reports in the literature relate to inspections carried out with procedural languages, the predominant paradigm used when inspections were originally proposed in the 1970's.


SVD reports bugs when such regions are interleaved by unserializable writes.

while SVD makes an inspiring start, it only looks at a limited subset of atomicity violation bugs: unserializable interleavings to atomic regions that start with reads on shared variables and expand based on read-write or control dependencies.


These categories are meant to summarize essential qualities of the patches as theyrelate to .

execution and are not necessarilyexhaustive.allof the changes we studiedfall Figure 2.


Therefore, CATS performs e.cient when the input data size is small but performs poor when the input data size is large.

because LAWS can increase more local memory accesses when input data size gets larger, it performs even better when the input data is large as shown in Fig.


This makes the pinball format relatively small (average pinball size of 39MB for SPEC2006 reference runs with 924 billion instructions on average).

the analysis required for captur   +    +    Figure 1: PinPlay: Integration with Pin ing non-deterministic events is expensive.


It is not useful for .lters to divide their atomic execution step into a cycle of smaller steps.

multiple execution steps are important for scatter/gather stages.


Process II architecture recovery and consistency).

the legacy architecture is specified using the more conventional object/component-based model.


In particular, they provide the means to specify well-de.ned interfaces and let customers and collaboration partners use an organization s resources through dedicated operations.

o.ered resources are not restricted to information and software-based services.


These analysesprovidewarningstothe programmer while still allowing the programmer to execute their program immediately (even programs with errors), thereby preserving the bene.ts of dynamic typing.

the programmer does not control which portions of a program are statically checked: these whole-program analyses have non-local interactions.


Similarly, if vector is frequently searched with a key for a match, e.g., using std::.nd if, then it can be replaced with map.

vector cannot always be replaced by set or map because they are oblivious to the data insertion order (i.e., order-oblivious); Since they internally sort data elements, iteration over them leads to the sorted sequence of the elements.


A trivial solution just runs the above protocol with s = 1 in parallel s times over.

this blows up the costs by a factor of s. Instead, it is possible to take this idea, but to keep all instances of the protocol operating at the same level i, thus reducing the communication from the coordinator.


On the other hand, if (b) holds, ni can be fore, r 04 can be recovered by the load instruction lwz r4 , mem2 04 is saved in F .

since where mem2 is the location where r recovered at P ' by extracting ni out of ..


Metrics such as loss rate, message delay are measured from probes.

when anomalous metrics are detected, the frequency of probing is increased and a group of probes are sent.


Second, in these studies, we discovered situations in which test cases were used for multiple requirements.

in practice, architectures are multi-tiered where the application has modules using different technologies, such as J2EE, Mainframe, and .NET.


Because lower associativity introduces more con.ict misses, the accuracy will decrease.

even for a 2-way set-associative L2 cache, on average, our model s prediction can still achieve 87.4% accuracy for dynamic weighting, and 94.5% for static weighting, leading us to believe that PRD shows much promise in future applications to cache optimization.


At 2 GB, the sweep phase accounts for 48 93% of the total garbage collection time.

the overhead of maintaining live intervals during marking is, in absolute terms, between 2 64% of the total mark-sweep GC time; in relative terms, it adds 18 74% cost to the mark phase.


From the general model expressed in 0 1 112131415161 Time (2), we determine the model structure by choosing values for n, m. In general, a better model is obtained as we choose higher value for n, m, since more history is reflected on the current measurement.

a higher order model requires a complex controller design and is vulnerable to over-fitting, representing that a model cannot be used in variations of contexts (e.g., hardware upgrades).


A GIS tool gets GIS data from the GIS service and displays the GIS data to support workers.

normally GIS data is pre-de.ned and does not include contemporary context information gathered at the disaster site.


This often leads to bad cross-project reuse.

architectural modelling is considered a pre-requisite for the systematic cross-project reuse and for the resulting increase in software developer productivity.