Using the algorithmic techniques described in Section IV, we can reduce the number of trigonometric functions to seven.

this increases chain of computation requiring an additional log(Nmax)=10 bits of precision.


This seems similar to script categories.

advices add functionality or alter behavior of code, which is similar to a composition (thematic).


The message size in this range has little e.ect on IPC copies and in-GPU reductions; however, as the message size increases, the reduction time and IPC time increase more rapidly.

the costs of directory checking and issuing events are independent of message size.


srpt × fcfs and interactive srpt perform the same for about 65% of the runs, while srpt × fcfs does better than batch srpt for many more situations.

there are more situations where the batchactive scheduler is between two and four times better than the interactive scheduler.


The PDS is considered in the following subsection  2.3 Product Data Synthesis As subsection 2.2 demonstrated, the Product Data Synthesis plays an important role in MATra by preventing bad data from entering the Workspace via tool2matra.

it also maintains consistency once data is inside the Workspace, notably following updates to the PDS itself.


Figure 2: Net Bill detailed design in PDT These checks were based purely on static relationships between the design entities.

our work assessed the dynamic behaviour of designs.


Mathematically, dependencies between tasks in an application form a partial order, and any execution sequence must respect that ordering.

in the presence of the two types of constraints it may not be possible to maintain the proper order between all of the tasks within a single partition.


Traditional experimentation guidelines advocate the separation of hypothesis setting, data collection, and data analysis activities.

in the presence of costly units of analysis, these activities can be interleaved through sequential analysis to establish a feedback loop that can drive the experimental process [23].


The positive in.uence is that increasing the subsector size reduces the overhead (Figure 2b versus Figure 2a) and thus decreases the overhead read/write time.

one negative in.uence is that increasing the subsector size results in more data bits that a probe has to access, thus increasing the data read/write time.


Extractive and reactive approaches can be enacted by the application of program refactorings.

the traditional de.nition of program refactoring [16, 9] does not take into account intrinsic characteristics of SPL: feature models (Section 3) and con.guration knowledge [7] mapping instances of the feature model (FM) to classes and aspects in the Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


The JIT compiler can optimise analysis code and client code equally well, and naturally tightly interleaves the two.

c&A must provide a separate way to describe analysis code (so C&A requires some kind of IR after all).


We show two parameterizations based on unaided automatic analysis of observed batch queue history that match historical data relatively well.

there are limitations to this history-based approach, because job queues in practice experience bursts of load that are potentially impossible to predict well from historical data.


Since nodes send identical messages to all neighbors, a node must store only another multiple of H0 bounded by O(G), which requires O(log(µD)) bits.

nodes may receive different estimates from di.erent neighbors.


A conventional processor using only 6 read ports without avoiding anticipatory reads incurs a perfor- mance degradation of 12%, as shown in the leftmost bars.

bC and bypass hint incur average performance degradations of 4% and 2% respectively despite only hav- ing 6 read ports for an 8-issue processor.


3GPP and IP networks) identi.cation process is tightly connected with addressing scheme.

as mentioned before, M2M devices can use di.erent network technologies for communication (i.e.


The method lookup starts on the class .nding the de.nition of the method and then executing it for the message receiver.

if we would like to factor the FAMIXClass JEE behavior out we can de.ne a talent that models this.


2.1 Need for a Service Integration Platform The current approach, component-based development, has served automotive developers well, allowing reuse, the division of labor, and insulation from the internal details of implementations.

as the amount of functionality in and around vehicles has grown, componentbased development has begun to be strained.


As stated earlier, the number of GC calls are very similar across all policies (the HA policy invokes one more minor GC calls).

the .xed and default policies outperform the HA policy by as much as 20%.


EP is CPU bound and therefore has a large time penalty and little or no energy savings at reduced gears.

cG is memory bound, so the time penalty is almost nothing.


In that work, the authors proposed designing and placing the guards in the application at software-creation time.

as we described in Section 3, PVMs generate code for the host machine at run-time.


Experiments on Design Pattern Discovery Jing Dong, Yajing Zhao Department of Computer Science University of Texas at Dallas Richardson, TX 75083, USA {jdong, yxz045100}@utdallas.edu Abstract Design patterns have been applied in many large software systems to help developers coping with recurring design problems.

pattern-related information is generally lost in system source code.


In this case functional ability is equated with actual activity.

they often fail to consider a second dimension of decline -- user perceptionaf his or her capabilities.


use a different color), on the same printed paper.

in that case you have to explain the author that those are just your private notes.


3.2 Workload Our HTTP workload is based on the static portion of the widely used SPECweb99 [21] benchmarking suite.

we address two notable problems with the SPECweb99 load-generator.


On the one hand, they use discrete signals for communication and coordination between system components.

they interact with the environment by sensors and actuators using continuous signal flows [17].


In other studies, we may have other types of censoring as well.

both the log .les of source code management systems and the Wikipedia include a complete list of all contributions performed within the period of analysis, so we do not have to deal with other types of censoring here.


Building suffix trees with these methods requires more complex procedures.

they could be implemented if it is desired to reduce the processing time of suffix tree construction.


In fact, all the tests in [14] were stationary.

the promise of networked shooter localization is great as these demonstrated results show.


In essence the user is asking whether there is any harmful code on their machine.

in reality no scanner has been built that can ensure that there is no malware installed on a machine.


This will make regioncuts less fragile for extract method 1 public void includeJump(){ 2 labelOfFor:  3 for(;;){ 4 while(true){ 5 nop; //label for beginning of the shadow 6 a(); 7 if(innerBreak()){  8 $i=0; 9 goto endLabel; 10 }else{ 11 $i=1; 12 goto endLabel; 13 } 14 b(); 15 endLabel: 16 nop; //label for end of the shadow 17 switch($i){ 18 case 0: goto label0; 19 case 1: goto label1; 20 }  21 } 22 label0:; 23 } 24 label1:; 25 }  Figure7.

a transformed version of the methodinFigure6 refactoring.regincuts willbe stillfragileforotherkinds of refactoring.Webelievethat usingthe assertion showninthe next sectionis morepragmaticfor reducing thefragility of regioncuts.


This merger yields a single Java file containing multiple classes that would typically not compile directly.

we retain enough information to separate this into multiple files when we need to compile it.


For instance, the main driver in the execution phase is performance, therefore, a compiled MT approach (where a transformation is compiled directly into native source code) is advantageous.

interpreted MT approaches (where transformations are available as models) have a clear advantage during the validation (e.g.


Ob jects are characterized by name, attributes, users (labeled agents) and media support.

apart from hierarchical domain modeling most values are not formalized or pre-de.ned (e. g., temporal relations, conditions and ordinary data types).


Since most of the developers were working on defect items associated with development work they had carried out earlier, expertise was high in a large number of cases, and consequently not much of a di.erentiator in general.

we discovered that for certain work items where expertise was rated low by our model, the high development e.ort required (relative to the size of work) was estimated much better, leading to the improved results.


A pair of fence operations after the Lock in Enter and before the Unlock in Exit prevent loads and stores from escaping the synchronized region.

we must still ensure that Exit operations can be reordered, but that they are not reordered with respect to Enter operations.


Reverse engineering of the state diagrams from the code is a di.cult task, that cannot be fully automated.

it is possible to partially automate it by means of abstract interpretation.


Fault tolerance was also provided mostly in hardware with multiple levels of redundancy.

as such systems evolved, they incorporated greater functionality.


Environmental challenges rain and humidity are mostly tolerated through sealedpackaging anddesiccantinserts.

some challenges were most unexpected.For example, we learned that one of the hazards for equipment leftontheislands oftheEasternShore ofVirginiais that exposed cables are subject to the teeth of small critters.


By permitting the aspect author to name parameters, we enable a more natural coding style for advice.5 Traditional aspect style would use a re.ective parameters array; JS already includes this via the arguments array-like object.

for technical reasons, any usage of the re.ective arguments object prevents the JS engine from applying certain useful optimizations.


This handles-based method of retrieving data had the advantages of keeping our API structs small and simple, avoiding any wasted memory by over-allocating string buffers, and allowing for ondemand-only string data retrieval.

a sacri.ce we had to make was the need for more stateful API calls, introducing caching requirements and the possibilities for data races.


However, the term language embedding is ambiguous because it only describes the result of integrating one language into another language.

such integration can not only be achieved with pure-embedding-like techniques but also using language extension in an extensible compiler, for example, where the embedding is described as a compiler plugin.


In this case, before delegation, the runtime rolls back the effect of the code already executed by ..

because A is required to be a leaf in the tree that constitutes the concurrent state, and also because of the syntactic restrictions in Core Otello, this code is solely a collection of heap updates it does not include any async or finish statements.


DYNAMIC EXAMPLES PART I The previous examples have shown how to implement simple interfaces in FranTk.

they have involved only a static set of widgets on screen.


For many outputs the answer may well be only on conclusion of execution, since once an output is ready the remaining program may have a sophisticated task to perform and determining that no contradiction will subsequently arise is essentially the same problem as verifying the program overall, which as we prove above is impossible in general.

we can argue that the requirement is too strong.


1.1 Load versus Delay Most of this prior research assumes an abstract setting which does not ascribe any costs or delays to quorum accesses or heterogeneous limits on the capabilities of di.erent elements.

in many network-based applications, one has to map the logical elements of the universe U on the physical nodes of a given network, which gives rise to many interesting issues.


For example, if we use CL to predict future system state after migrating a set of VMs, the metric accounts for the migration set that not only reduces sL, but that recognizes changes in µL as well.

there are someproblems thatmustbe takeninto consideration when using the CL as an imbalance metric.


The more relevant WS-BPEL 2.0 (Web services BPEL), is an XML based language that allows for specifying business processes in terms of web services [22].

wS-BPEL 2.0 does not provide any support for access control, and it is not possible to add user behavior to the business process once it is deployed.


Some benchmark have a relatively larger object lifetime, see for example javac, compress and mpegaudio, however the object lifetime is still  incorrect lifetime compressjavacjackdbmtrtjessmpegaudiohsqldbantlrjythonxalanfopps ties.

cachegrind is unable to vertically pro.le Java applications, nor is it capable of mapping cache miss rates to objects or object types.


Prospector ranks solutions by the length, preferring shorter solutions.

we .nd solutions that have minimal weights.


For managing the resulting variants, using concepts from Model-Driven Product Line Engineering (MDPLE) has proven successful [12].

the highly dynamic environment of electronic commerce imposes di.erent challenges.


The Ohmu language does include several procedural meta-object protocols: one for creating and manipulating abstract syntax trees, and another for manipulating classes and methods.

these are provided as low-level tools only, a mechanism of last resort for library authors who cannot accomplish what they need to do in any other way.


3.3 Exact and Inexact Quali.cations and Subtyping In the above section, @ was treated as an operator for absolute path types.

in our setting, we have found that it is more natural to consider that @ is rather a new kind of quali.cation in addition to .


DISCUSSION Asdiscussedin ourpreviouspaper[17], the conservative nature of string analysis mayinduceimprecision andthisimprecision may impact the empirical results of locating need-to-translate constant strings in web applications.

according to our empirical results reportedinthispaper, wehave notfoundfalsepositivesdue to the preceding weakness of string analysis for locating need-totranslate constant stringsin web applications.


Code editors usually present the programmer with line and column numbers, because code tends to be line-oriented.

behind the scenes programs usually work with offsets, especially if they need to do computations on these offsets.


It has been shown that 3D virtual reality tools are particularly bene.cial for children with ASDs [13].

due to the cultural and language speci.ty, existing tools are not necessarily useful in the South African context.


Obviously both development trunks are the most frequently affected.

orion has also found a considerable number of bugs in many stable releases that had been latent for many years.


In [22] D2HT describes a discovery framework built on top of DHT.

we have chosen to use UDDI on top of DHT.


Instance A is the expected output, B is the generated output like, for example, Ie = {R(a, N2),S(N2,b)} has distance 0 wrt Ie.

instances with different constants, and/or additional/missing tuples, are considered different and have distance greater than 0.


Network fuzzing is more complicated, not only due to the numerous available protocols but also, due to the 65536 available ports with which to communicate.

the specification for the encapsulation of industrial protocols on the TCP/IP network requires the utilization of TCP port number 0xAF12.


Along this line, ArchE is able to search for alternatives, show quality tradeoffs, and adapt its analyses and recommendations to the designer s preferences.

archE cannot make decisions for the designer, and is not concerned with the quality and amount of knowledge codified inside the reasoning frameworks.


The crucial issue for constructing the dimension hierarchy H is how to capture logical relationships between two neighbouring Ds in H. In this step we generalize the notion of referential integrity in an XML environment for this purpose.

we should not expect most XML documents to have an element (or attribute in more general case) that simulates a primary key as the case is in relational databases.


The main advantage of our proposal is that composers can rely on the features of the Antescofo language during live coding, e.g., for synchronization and error handling strategies.

it only works in interaction with Max/MSP.


It is future work to see if and how these two classes can be integrated.

coArbitrary can deal with general higher-order functions.


Moreover, in our algorithm, the intervals need to be determined dynamically, which is an additional overhead to the computation in each sub-interval.

on the .ip side, dynamically determining intervals is likely to give us larger sub-intervals in some places and therefore result in fewer intervals overall to consider.


Further performance improvements can be achieved by swapping additional implementations under the appropriate conditions.


The resulting languages and environments -although technically successful- did not receive much attention from industry.

researchers and practitioners have recently started experimenting with the usage of UML as a PML.


Furthermore, OVM, FOP and delta modeling each have a strong focus on the realization of variability in software artifacts.

as implementation in source code is not the primary concern in our use-case, we refrained from including these notations in the curriculum.


Since regular users usually do not use low-quality objects, traps will not receive many new feedbacks from honest users.

if the system marks a low-quality object as high-quality, this object will be used by many users and quickly receives a large number of negative feedbacks.


The .rst point is not particular to templates but a general feature of C++ inline functions.

inlining is crucial for .ne-grained parameterization as is commonly used in the STL and other libraries relying on generic programming techniques.


The .gure shows that, as expected, the median distance error decreases as m increases.


For example, consider the following fragment of reentrant code, and suppose it is executed concurrently by two threads T1 and T2: { FileInputStream X = new FileInputStream(); FileInputStream Y = new FileInputStream(); } There are several ways the instructions of T1 and T2 could be interleaved: T1: creates X T2: creates X T1: creates Y T2: creates Y - or T1: creates X T1: creates Y T2: creates X T2: creates Y ... etc.

t1 will always create X before Y, as will T2.


In practice, many works propose a simple way to implement a generalized form of modulo expansion (9).

this method does not guarantee a register allocation with MAXLIVE registers (1; 3), and in general it may lead to unnecessary spills breaking the bene.ts of software pipelining.


Resource schemas are only applied to structured information.

the resource schemas of unstructured information can be discovered through some schema discovery services, e.g., text mining or knowledge discovery.


As with other IRs, the matrix based description of static control parts (SCoPs) has to be extracted based on for-loops, conditions and array accesses.

unlike within lowlevel or detailed high-level IRs these constructs are present within INSPIRE at a proper level of abstraction, simplifying the conversion in both directions.


So the prev miss time for those sizes is set to T6 and the total energy consumption is incremented by the sum of idle energy consumed during the last idle period and the active energy, which is E(T6 - T5) + 10ms* ActivePower (calculated based on the underlying DPM).

if the partition for this disk has size of 4 or 5 blocks, there would have been a hit and no change is needed.


The reason for this spiking was not certain.

since it appears in the plots for both methods, it is not unreasonable to assume that it was at least partly an artifact of the test function, rather than a property of either method.


RRT prefer the corners and partially also the boundary of the input domain, since there are less neighboring previously executed test cases.

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


There has been some work utilizing MapReduce and Hadoop for scientific problems such as CloudBurst algorithm [6] in bioinformatics and MRGIS framework [7] in geoinformatics.

there are still two main difficulties that make it hard for domain scientists to benefit from this powerful programming model.


A limi- tation of this approach dealing with the problem is the need for source code availability in order to analyze comments.

the usefulness of dependcncies arises mainly when source code is not available and programmers want to evolve binary components of which they know only the interface information [13].


Moreover, no incoming transaction is lost while the server is recon.gured and all bu.ered requests are eventually serviced.

this pattern may increase latency during the recon.guration process depending on the complexity of the recon.guration.


Predicate abstraction [10] techniques based on counter-example driven re.nement (like SLAM [1], BLAST [15], or [2]) are also able to discover such disjunctive invariants like the ones required for the example program.

the success of these tools on a given problem is contingent on being able to .nd the right predicates.


Discussion No technique found the bugs in 19, 20 and 28.

these bugs can be exposed using a lower number of threads (as shown by the other versions of these benchmarks), so these results are arguably less useful.


However, an update-conscious algorithm should put the new variable d in a s location, as shown in Figure 7(c), resulting in only one update primitive in the script.

if there was no d in the new code and if we did not reclaim the word taken by a, we would waste the word in the data segment or more if the function is recursively invoked.


All the approaches above target basic blocks.


Turning on such a gateway to serve load with Flash (254MB) storage incurs a cost of 14.5W/10Mbps, or 1450 Joules per Gigabit, considerably higher than the corresponding metric for servers.

if we consider a gateway that is already on, its baseline consumption of 13.5W is already spent anyway.


Potential sources of failure, such as navigating to non-existent positions (either with a zipper or an invalid list of child indices), or rewrite rules that fail to apply, lead to runtime failures in the Maybe monad.

we could aim higher, and try to check validity of transformations already at compile-time.


For ef.ciency reasons, our baseline uses an optimized distance computation that is tailored to our inputs.

we did not alter the data structure or the actual traversal code; TreeSplicer was applied to the out of the box traversal algorithm.


Moving to USB 2.0 would boost the USB throughput to 480Mbps, which would make the MCU the bottleneck in streaming logs.

we have found 1Mbps to be suf.cient in all of our experiments as long as buffers are added in the MCU and FPGA to absorb short bursts of data to be logged.


DIAGNOSABILITY NOTIONS IN CON-CURRENT PROBABILISTIC SYSTEMS Theorem 1 gives the L-diagnosability two intuitive characterisations from the subjective views of the outside observers B and A.

when working with concurrent probabilistic systems, the 0-1 nature of L-diagnosability may classify some reasonable systems as non-diagnosable.


One major di.erence between vehicles within a vehicular ad hoc network and sensors in a wireless sensor network is that sensors cannot always be equipped with a GPS device as they consume too much power.

many vehicles have GPS devices already provided and in use and many more are expected to have a GPS device installed in the near future.


Merging both frames could also guarantee correct frame accesses in the transformed AST.


In [14, 15, 36] authors propose new locking mechanisms.

our work focuses on adapting the location of threads across the Sockets of a cache-coherent multicore multiprocessor machine to reduce the lock transfers between Sockets and thus critical LLC misses.


Setting a smaller threshold can result in an unblocked thread being erroneously considered as blocked by NeedlePoint, which can hurt repeatability.

larger thresholds cause slowdowns in the execution of the program.


The worst case response time was 2.29 s when running without background load.

when 64 kernel compilation processes were running, the worst case response time increased to 48.9 s. RSIO correctly identi.es the web browser as latency-sensitive when it is receiving web data from the Internet since the network channel to the web proxy is con.gured asaRSIOI/O channel.


All devices are involved in calculating a valid con.guration in a distributed way which balances con.guration load on them.

most realistic pervasive application scenarios are situated in heterogeneous environments where additional computation power of resource-rich stationary devices with external power supply is available.


MODEL CHECKING The logic L2 is undecidable, since [11] shows that a simpler logic is S1 1-hard.

we have developed a model checking technique that we discuss in this section.


We could have implemented ParseSource by invoking a separate GHC process to compile the code.

this would be slow, since the GHC process would have to re-read all the interfaces for external modules each time it is invoked.


In an aspect-oriented use case model, use cases are represented by transitions.

there are also other transitions (e.g., for the purposes of evaluating a complex precondition for a use case transition).


Consider the following example: def m()(implicit ctx: SourceContext) = ... def outer()(implicit outerCtx: SourceContext) = () => m() val fun = outer() fun() // invoke closure Here, the outer method returns a closure which invokes method m. Since m has an implicit SourceContext parameter, the compiler generates an object containing source information for the invocation of m inside the closure.

since the parameter has type SourceContext as opposed to its super type SourceLocation, the compiler will not only pass the SourceContext corresponding to the current invocation but also the outerCtx context as the parent of the current SourceContext.


While the mechanismallowseach threadtohaveanindividualMMU,bydefaultall threads have the same MMU, and sofar we have found that this works for the majority of applications.

our music synthesizer [2] required a different MMU for concurrent threads with a very high allocation rate.


The type system extended with this rule would accept the examples given above to illustrate the lack of implicit subsumption.

this rule as it stands would add a lot of complexity to the type inference algorithm.


Eventually, she gives up on this con.ict of clashing models ( broke that box and .nally I developed interest in testing ) and accepts her inclination towards this pro.le.

inclination towards testing may invite its own new cultural struggles particularly because of the strong cultural model of software testing as a second standard .eld in the community.


Thus, by appropriately adopting the retiming technique, an upper bound on the number of pipeline stages being generated could be imposed.

traditional clock minimization approaches [12] that employ retiming technique are not directly applicable to our problem instances.


Lent references permit type-safe ownership transfer.

they weaken encapsulation drastically because they may point to arbitrary ownership contexts and may be used to modify objects.


Improving Industrial Adoption of Software Engineering Research: A Comparison of Open and Closed Source Software Brian Robinson, Patrick Francis ABB Corporate Research Raleigh, NC, USA {brian.p.robinson, patrick.francis}@us.abb.com Abstract Advances in software engineering have led to the creation of many new software engineering techniques.

industrial adoption of these techniques is often quite low, as development organizations are skeptical of their value and applicability.


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

human examination of the formal speci.cation found a logical error pertaining to the synchronization of the new keys.


If they are reclaimed in garbage collection, the data contained in the valid pages need to be reallocated.

reallocating the data versions and index nodes triggers the updates of higher level nodes (e.g.


For example, an experimenter using reprozip has to use reprozip for all parts of the experiment, and not forget to use it for one part.

if an experimenter can give us a virtual machine in which a kludgy set of experiments is held together with string with no principled methodology, if we can recompute it now we can recompute it in 20 years.


[2001] give an overview of different heuristics.

these heuristics can t be directly applied for scheduling work.ows because of task dependencies.


3.3.2 Processing the terrain textures There are several data sources containing thousands of pictures related to the surface of the planet Mars.

most of them either show distorted pictures or do not cover the surface of the entire planet.


Addressing human factors, appears also in our conclusions, for instance in the need of a prioritized backlog to guide teams towards reuse.


Previously, "complexity" referred to a measure of a system's computations from an algorithmic perspective.

today, when factors such as human end users and diverse deployment environments are involved, a new kind of complexity emerges, one that is measured in terms of end users and workplace settings.


Like classes, symbolic instances enable de.ning behavior for multiple instances of a speci.c class.

symbolic instances extend the expressivity power of class:instance relationships.


Polling has the advantage of keeping the latest versions of all the clients, but can cause heavy server load by simultaneously connections to many clients and unnecessary network traffics.

push causes much less because push can upgrade the specific clients, but there is cumbersome monitoring to keep stopped clients on latest version.


One of the main advantages of CASE tools is their potential domain specificity.

because of their cost, domain specific environments are not widely or commercially available [5].


As only interface variables are givenstay constraintsinthe constraintgraph,anin-edgefromastay constraint for a given variable in a solution graph indicates that a variable is a contributing, rather than input, variable.

3.3 Solver preconditions We note that .nding an acyclic solution to an arbitrary multi-way data.ow constraint system is an NP -complete problem; complexity characteristics of variations of constraint satisfaction problems are describedin(TrombettoniandNeveu1997).theproblem is polynomial time if the method restriction holds, which requires that every CSM of a constraint use all of the constraint s variables as either an input or output of the method.


These conditions are rather restrictive for example, they exclude most of the examples in Section 2 and we will consider more relaxed conditions in Section 8.

they certainly ensure that the top-level equations are strongly normalising and, as we shall see in the following sub-sections, are enough to guarantee good properties for completion and solving.


In each case, these tools take advantage of a fundamental advantage of computer science and more broadly, computational science: the unique ability to share the raw outputs of their work as software and data.les.

despite this advantage, and alongside ongoing and signi.cant changes to the traditional models of academic dissemination and publication [13] [15], there remain cultural and technical barriers to both the sharing and reimplementation of algorithms [1].


S by asking the SAT solver to .nd a solution for the variables Z subject to the constraints ^ FT,I,Y (Z) .

obs(Z)=o o.S If the SAT solver .nds a satisfying assignment, then the corresponding execution is a counterexample because its observation is not equal to any observation in S. if the SAT instance is unsatis.able, the inclusion check passes.


Many trust functions have been proposed in the literature (e.g., [1, 3, 12, 13, 29, 30, 33]).

when building a decentralized system, it is non-trivial to pick the right trust function.


In terms of fault revealing power, the higher the number of killed mutants, the higher the test case power.

while some mutants are killable, some mutants cannot be killed.


It is because that rich functionality  Figure 5: Histogram for distribution of questionable permissions of application which implies the need of more permissions is the main feature to drive application popularity.

we also .nd the weak negative correlation between the number of questionable permissions and the popularity of application.


Dynamic load management through adaptive region to server remapping is an obvious solution to the load management problem.

any dynamic remapping algorithm must evaluate the potential trade-offs between the two con.icting goals of i) Balancing the server load in terms of numbers of players by splitting existing game world partitions across more servers and ii) Decreasing inter-server communication by maintaining the locality of adjacent regions or aggregating adjacent regions into large partitions to be assigned to fewer servers.


For simple functions like half, a single call to xgo is usually suf.cient.

for more complex programs, the ability of xgo to be run only on given portions of code is crucial.


Risk can be measured by probability to deliver on time, on budget, and with expected quality.

since predicted probability is a subjective characteristic, it may be considered a utility.


For example, if there was at the outset a serious question about whether something could be achieved at all, simply exhibiting an implementation is validation enough.

if the question is how to improve on current practice, the same implementation would probably be completely unsatisfactory as the sole evidence.


Thus these results do not show the full capability of Intel s compiler.

these coverage results can be somewhat correlated with the obtained speedup.


This is due to interleaving and decreasing of the number of LSB backup because LSB and MSB pages are written at the same time.

android, and its Linux kernel perform write operation with maximum size of 512KB due to IO scheduler policy.


Later, a remote replica transforms the operation s position index into a new index appropriate for the remote replica s state of the document through a complex algebra of transformation operations [7, 14].

oT requires that each replica ultimately receive all operations in the replicated system and thereby excludes ef.cient partial document editing.


Where: The most popular location for phone sharing was at school or in the workplace.

sharing occurred at a variety of locations, both private and public, as shown in Figure 5.


Any scheduler (including a real-time one) that is unaware of green energy would behave similarly.

greenSlot de Figure3: GreenSlot scheduling windowat times T1 (top), T2 (middle), and T3 (bottom).


If we hear someone bring up a misunderstanding about our ideas, we usually address it head on with the person who is expressing the concern.

a false impression in one person s mind is usually a sign that misconceptions are shared by others.


Faulty processes can deviate from the algorithm arbitrarily, i.e., we assume the existence of Byzantine faults [18].

no more than f 2 J can be faulty (in the tight case n =2f + 1).


In [15], the authors proposed a server selection algorithm that considers both the network delays and the virtual locations of clients.

this work uses the average delay between clients and servers as the main performance metric.


This collector will initially be a single-threaded compacting GC, and will be written in plain C, because of the wide availability of debugging tools.

we plan to eventually rewrite this in our extended JS dialect.


These three method de.nitions illustrate the syntactic form of unary methods in Ambience.

these methods are special in that they have anonymous arguments.


The simplest counterexample involves choosing the empty string as the data and a grammar (A, [A = E+Num]) as the target to extract in this example, there is no way to annotate the empty string to enable generation of the right side of the union.

we can extract (A, [A = E]) an approximation of the grammar we might have wanted.


E : e.rec =0 Otherwise, if some elements are recoverable and some are not, the recoverability cannot be previously stated.

it can de.nitely be determined, if the pattern is redoable: If one redoable element in WPXOR(E) exists, it guarantees the completion of the pattern.


Generally, we propose the following work .ow: the developer runs our static analysis on a program; if there remain a small numberofpotentialpoints offailure,thenthedevelopercanverify each of thesepoints manually andget acomplete analysis result.

if there remain many points, thenthedevelopercaninspectjustthetop or .ltered results and let runtime monitoring handle the remaining cases.


Case 1 and 4 are special cases that can also be expressed by returning a list of functions in case 2, either with just one element, or with a list containing identity functions only.

especially case 1  returning just one function is a very common case due to the fact that single dispatch is very common, and thus cases 1 and 4 are added for convienence.


With software design patterns it is always possible to implement them, and this helps students to understand the transformation from abstract pattern solution to concrete implementation better.

this is not always easily possible in other domains.


This collateral evolution is quite simple.

in the original patch it was applied both to calls to end_request and to calls to swimiop_send_request, which is completely unrelated.


The total number of executions expected from each participant was 36 (6 different strategies per model, 3 different situations).

some of them were unable to finish all instantiations within one hour.


By its nature the problem is NP-complete and we do not get an optimal solution in polynomial time.

heuristics are applied in order to obtain a satisfying solution.


When one wants to build a new pricing model which has many similar features to existing models, we can usually do these pretty quickly, since we can re-use code.

when we want to make a very quick, simple change to an existing model, the turnaround time is longer than using Excel directly.


PERFORMANCEEVALUATION The major motivation of this research is to demonstrate a means of achieving correctness in a scripting language reimplementation.

we are also able to increase the performance of our compiled code, compared to the interpreter in the PHP system.


We expected to see roughly a linear trend correlated to the increase in transactions which perform an update.

we noticed that performance degrades about 10% from a read/write ratio of 20 to a read/write ratio of zero.


Exception Directed Optimization (EDO) [38] also adds instrumentation directly to exception handling to pro.le exception paths from a throw statement to the catching handler.

the overhead of this instrumentation is likely to appear lightweight given the infrequent occurrence and relative expense of exception handling.


Second, there are tools for generating de-/serialization code, which parse the class structure and generate the functions accordingly [1, 4, 6, 11, 15, 17, 18].

these generators have restrictions on how arrays are implemented and do not support serialization of void/function pointers.


A time-abstracting simulation has been studied in [13], where an algorithm to check the relation is proposed.

timed properties are not preserved by this relation.


Completely by hand Transfer functions for simple abstract domains, such as null-pointer analysis and constant propagation, are easy to create by hand.

elaborate domains such as intervals and bitwise values are not easy to implement, especially if both ef.ciency and precision are required.


for the second case the direct transfer completed in 380 seconds, an improvement of 37.7% in o.oad times.


If no failure occurs, the execution time of the ith interval is identical to (ti + ci).

if a failure occurs before the end of the ith interval, the recovery time r is required.


For the cell network we generally experienced good communication throughput.

in our logs we see that some resending of packets have taken place, and thereby increasing the delay for delivering position updates to the server.


Model Driven Benchmark Generation for Web Services Some pioneering work has been done on generating benchmark and prototyping applications using models, as in [14, 15] for component-based distributed applications.

it has several limitations in terms of standards compatibility, leveraging existing code generation cartridges and load test modeling [27].


For example, [4, 5, 7, 9] use halftone images to hide secret data, [8, 11] embed secret data while cover images are compressed, and [3] applies the Singular Value Decomposition (SVD) technique to hide data.

the embedding capacity of the above methods is limited.


For example, on a system with 100 thread contexts each executing a >< -"":"/~ £ .........................  h~:~ pseudo JIT, allowing a single event per thousand would result in an effective system event load of 100 per thousand.

we    '.-~ =============================================== found that the performance impact on the pseudo-JIT was minor .


On first impression, activatable services seem like an attractive option.

the trade off with activatable services is that although memory usage is reduced a new Java Virtual Machine (JVM) needs to be started when an activatable service is called into use (i.e.


DISCUSSION AND FUTURE WORK JavaScript naturally supports the view of traits-as-state discussed in Section 2.3, since both ob ject state and behaviour are stored in assignable slots.

javaScript also supports the traits-as-behaviour view, thanks to the newly introduced properties abstraction:18 in this case, a slot access such as point.x is actually a method call without arguments, as in Self [24].


The .rst half of that statement is not actually true, but it is close enough for the second half to hold in all reasonable cases given experienced Standard Library implementers with common sense.

a type system cannot work for reasonable cases only, and compilers (enforcing a type system) are not noted for their common sense.


Compared with them, our proposal differs in that (1) there is less boilerplate code to write recursive interfaces because MyType automatically supports covariant change of 2 Actually, Bruce once pointed out this idea as a solution to extensible parameterized visitors [5].

he did not investigate it any further due to its expected complexity.


While the advice code de.nes the behavior of an aspect, the pointcut speci.es a set of joinpoints where this behavior is applied in the application.

the use of AOP in large-scaled software systems or components [2] can sometimes be problematic.


In another example, deterministic order may give the desired repeatability more readily than nondeterministic order for memoization-based approximate computing.

deterministic order can degrade performance (§3.2).


For instance, for the bug .xing example in Figure 1, we may simply replace the shared read to referenceColumnMap at line 11 to a local read to referenceColumnMap local which stores the same value read by the access to referenceColumnMap at line 4.

in practice, we have to address the following touch challenges: Path-sensitivity The privatization must be path-sensitive.


A critical distinction between Cuanta and PAVCB is that Cuanta requires a synthetic loader to control the cache usage for certain applications in order to predict the application performance under different interference.

pAVCB is completely self-contained and considers only hardware prefetching behavior.


In these .elds, many approaches arose and where evaluated using a broad range of real-world data.

all of them rely on a manual creation of gold-standards whereas we propose to have an automatic approach.


As a result, some form of deferred reference counting [20], in which references from stack frames are accounted for separately, is used in most high-performance implementations of reference counting [3, 19].

this means that when an object s reference count drops to zero, it can not be reclaimed immediately, since there might be a reference from the stack that is not accounted for.


Since prefetching does not o.er any bene.ts that are not present in prefetch-delayed, we do not present (a) Message cost (b) Tree rebuilding time Figure 6: Publisher speed of movement without routing computations (a) complex matching algorithm (b) standard protocol Figure 7: Publisher speed of movement with routing computations results for the prefetching protocol in this paper in order to simplify the exposition.

the proxy, delayed and prefetchdelayed protocols all graft onto existing trees.


It is natural to assume that one would need an additional language layer for manipulating mixin modules programatically.

this turns out to be unneeded, because we can encode the .-calculus using only mixin constructions.


If such a K is selected, the inferred a should be less than 5 msec by the adaptive selection itself.

according to our conservative K upper bound estimation, in order to break the a-being-mode assumption, a should at least be greater than 5 msec.


With the notable exceptions of Us [SU96] and PyContext [Löwi07], as far as we know multiple dispatch has not usually been combined with implicit arguments.

there is a tantalizing hint that the CLOS creators were going in that direction: it might be useful to use exogenous features for method selection.


This means that the number of instructions of ARM Thumb is greater than that of the normal ARM.

since the instruction length is 2 bytes, the overall code size of ARM Thumb is smaller than that of the normal ARM.


If the property contains a closure, then this closure is the result of e.p.

if the property contains an object reference, say (e ' , N ), then this read operation has discovered that the paths in M.p are also access paths for object e ' .


Instead of using JNI, one can also invoke native code from a virtual machine with a socket based integration approach [10], which is often the case in mobile Java devices.

using such an approach can imply a bigger performance overhead than that of pure JNI invocation, which in turn makes this approach unsuitable for Java applications having strict performance requirements.


Indeed, the concept of channel in the human world is more (for example, each verbal communication, in a space where people are able to hear, features this characteristic).

channels providing deferred interactions are those where the receiver is not inside the context when the message is ready to be delivered, but can be reached at a later time (mailboxes, written notes, posters, showcases are kinds of deferred channels).


Therefore, conducting interviews in two different ways (face-to-face and over Skype) has not affected the quality and reliability of the results of this study.

triangulation technique (a method that compares three or more types of independent perspectives on a given aspect of the research process (methodology, data, etc.)


We consider that once a process has started, it completes until the end if no fault occurs.

for a soft process Pi we have the option not to start it at all, and we say that we drop Pi, and thus its utility will be 0.


Ef.cient Control Flow Quanti.cation Christoph Bockisch* Sebastian Kanthak* Michael Haupt*, Matthew Arnold Mira Mezini* *Software Technology Group Darmstadt University of Technology, Germany Software Architecture Research Group Hasso Plattner Institute for Software Systems Engineering, Potsdam, Germany IBM T. J. Watson Research Center Yorktown Heights, NY, USA {bockisch,mezini}@informatik.tu-darmstadt.de kanthak@st.informatik.tu-darmstadt.de michael.haupt@hpi.uni-potsdam.de, marnold@us.ibm.com Abstract Aspect-oriented programming (AOP) is increasingly gaining in popularity.

the focus of aspect-oriented language research has been mostly on language design issues; ef.cient implementation techniques have been less popular.


Such formalizations can later be used to match structural patterns in the source code of a program to the structure of a design pattern.

many design patterns in general, and the DTO pattern in particular, have signi.cant behavioral aspects that static analysis cannot capture precisely.


In order to insert the new node N := get(cur); into the tree, the .rst thread will look in the prime block for 9>= the node s parent.

the second thread might not yet r * dcaps(k, r, i) I(r,h) B.


The new version of Alice 3 also enables such a transition.

the benefits of using a common set of examples to support the transition from a graphical to textual programming language is not described deeply in the literature.


It is therefore impossible to design a noti.cation strategy that is able to cope with all situations in an optimal way.

designing di.erent coordination variants for such nodes using only low-level programming constructs is very ine.cient and error-prone.


We .nd that for CG and IS, around 30% of the execution time is consumed by the isolated device domain (Dom0 in our case) and the Xen VMM for processing the network I/O operations.

for EP benchmark, 99% of the execution time is spent natively in the guest domain (DomU) due to a very low volume of communication.


The non-virtual size plays no role in the correctness of data access.

(C4) is used to show that the data of two disjoint cells of a structure array (or of two cells of distinct structure arrays) are disjoint, which guarantees that data access within an object does not affect other objects.


This is usually no problem if the usage as a base for decorators was already anticipated at writing time.

if a prede.ned library class should be decorated, this may be a problem.


Formal generalization is impossible without random sampling of a well-defined population.

there are arguments for generalization on the background of cases [4].


These positive experiences are backed up by internal test data and component defect levels that demonstrate that the quality and performance of the XAPI component is good.

despite the overall positive outcome, there have been some technical challenges that relate to the choice of OCaml.


The general rule communicated to all developers regarding risky changes is that a change is considered risky if additional attention like careful code reviewing and possibly more testing is deemed necessary.

a non-risky change is one where the change does not need any special treatment in terms of code review or testing.


Both polymorphic variants and yoko s disbanded data types provide anonymous subsets of constructors.

polymorphic variants, as a widelyapplicable feature, intentionally model subsets with less exact types.


Figure 1: Danfoss Automation Drive and application scenario[5] In order to handle the increasing number of variants in their products, and at the same time decrease time-to-market and development cost, Danfoss introduced SPL principles successfully [12].

with increasing expectations and improvements in software product line engineering, the need for improvements in software product line usage at Danfoss is given.


1)1, I resorted to writing down the state-based behavior textually, in a kind of structured dialect made up on the fly that talked about states and their structure and the transitions between them.

this dialect was hierarchical: inside a state there could be other states, and if you were in this state, and that event occurred, you would leave the current state and anything inside it and enter that other state, and so on.


Since the 1970ies a number of quality models have been proposed to achieve this [3, 10, 17, 19, 22].

as is argued in [8] these approaches have a number of shortcomings.


After that, it periodically broadcasts the content to its neighbors.

hamlet [7], is a cooperative caching scheme in which nodes estimate their neighbors replicas to decide which content to keep on their own cache and for how long.


The separate code editor and command-line compiler feedback are primitive and should be replaced with a proper language-aware editor with inline syntactic and semantic feedback that we are used to from modern IDEs.

the e-learning application calls for an embedded programming environment.


In our view21 theyare more closelyrelated to Java synchro nized and try { ... } finally { ...} blocks or, in the case of locks, synchronized blocks, than theyare to Java finalize methods.

.nalization in languages like Java is necessary in order to manage resources other than garbage-collected memorybased on garbage-collector-discovered reachability.


Polynomial functors on Set are instances of dependent polynomial functors for I = J = 1.


In consequence, they are easier to maintain because, in general, they are easier to read, their implementation logic is clearer and they are less likely to undergo changes [32] and faults [25] [22].

measuring cohesion is not straightforward.


Our infrastructure already utilizes such generic ontologies for non-functional properties to reason about potential adaptations within the components.

it is possible to modify these ontologies or add custom ones for more speci.c use cases.


When the .rst step of the sensor fusion .nds an approximate shooter position, the fusion completes in 2 sec.

when no such estimate exists, the extensive trajectory search causes the fusion to slow down.


Hence, when xs is empty the property amounts to proving that ys ++ zs is equal to itself, which is true by the re.exivity of the equality on lists.

if xs is of the form Cons x xs , by de.nition of append we need to prove that Cons x (xs ++ (ys ++ zs)) is equal to (Cons x (xs ++ ys)) ++ zs, or equivalently, to Cons x ((xs ++ ys) ++ zs), again by de.nition of append.


These methods are effective for single-threaded scenario.

the default scheduler employed in Linux 2.6.23, Completely Fair Scheduler (CFS) [8], can guarantee fair CPU time among all This research was supported by the National Science Foundation of China under grants No.60873221 and Jiangsu production-teachingresearch joint innovation project No.BY2009128.


This in turn would deliver us a valid forwards set for an event without the need to evaluate the predicate functions.

an important issue we need to consider is the coverage.


The pickle format, in turn, has factory methods for creating concrete PReader instances: val reader = pickleFormat.createReader(pickled) The obtained reader can then be passed to the unpickle method of a suitable Unpickler[T].Alternatively, a macro def on trait Pickle can be invoked directly for unpickling: trait Pickle { ... def unpickle[T] = macro ... } It is very common for an instance of SPickler[T] to also mix in Unpickler[T], thereby providing both pickling and unpickling capabilities.

3.1.1 Pickling and Subtyping So far, we have introduced the trait SPickler[T] to represent picklers that can pickle objects of type T. in the presence of subtyping and open class hierarchies providing correct implementations of SPickler[T] is quite challenging.


To maintain a high-level of abstraction, the advice types are implied in advice models, rather than explicitly defined as in AOP.

the above interpretation can help to detect incorrect advice types in the implementation of integration aspects.


its performance advantage over the other buffer algorithms was smaller than that in FAST.


In this example, D has three different subobjects of static type A, obtained through the base classes B1, B2 and C. This is called non-virtual inheritance by Stroustrup [5], replicated inheritance by Rossie and Friedman [16], or repeated inheritance by Wasserrab et al [19].

the programmer can elect to declare some base classes as virtual, as in the following example: AA struct A{ int a; }; struct B1 : virtual A {}; B1 B2 C struct B2 : virtual A {}; struct C:A {}; struct D : B1, B2, C {}; D In this case, B1 and B2 contribute only one subobject of static type A to class D: the paths B1::A and B2::A designate the same subobject.


A Formal Framework to Generate XPDL Specifications from UML Activity diagrams Nicolas Guelfi and Amel Mammar Software Engineering Competence Center Faculty of Sciences, Technology and Communication University of Luxembourg, L-1359 Luxembourg-Kirchberg, Luxembourg {nicolas.guelfi,amel.mammar}@uni.lu   ABSTRACT The XML Process Definition Language (XPDL) is a standardized language allowing process definitions interchange between a variety of tools ranging from workflow management systems to modeling and simulation tools.

uML activity diagrams offer a convenient notation to depict synthetic and intuitive views of systems that facilitate stakeholder communication.


The .rststep of ourmethod transformsagraphqueryintoaset of rules and aqueryinDatalog.Datalogis animportant rule-based languageforinference usingfactsindatabases.Much researchhas beendone onimplementation ofDatalog[1].Top-down computation startsfrom thequery,generates subqueries using thehypotheses of the rules whose conclusions match the query, and does so repeatedly until the subqueries match the given facts.

bottom-up computation matches existing facts with hypotheses of rules, generates newfactsfrom conclusions of rules whosehypotheses match existingfacts, anddoes so repeatedly untildesiredfacts or allfacts areinferred.Inparticular, thereis a methodforgenerating optimal algorithm and data structures specialized for the rules for bottomup computation, and calculating complexitiesforthegeneratedprograms[20].this method may inferfactsthat are not relevant to answering agivenquery, and hence may be unnecessarily expensive.


To improve shared cache performance, researchers from the computer architecture community propose smart replacement policies to improve upon LRU [12, 34, 10, 30, 29, 25].

other researchers have proposed intelligent coscheduling policies [37, 38, 32, 31, 21] that an operating system or hypervisor can use to minimize shared cache contention.


Configuration management (CM) systems have long been used to provide support for these kinds of situations [5].

advanced CM support is only available for managing source code.


Commonly used dynamic techniques such as application .rewalls [37] that rely on pattern-matching and monitor traf.c .owing in and out of the application are a poor solution for SQL injection [35].

sECURIFLY can detect attacks because it observes how data .ows through the application.


This approach is simplistic and hinders one from transferring an application to multiple devices simultaneously.

the simplicity resolves issues that stem from multiple instances of the same application at the same time and moreover succeeds challenges with merging different command stacks from different devices.


3.7 Multibit Errors The above code transformations are suf.cient to catch single-bit faults in all but a few rare corner cases.

it is less effective at detecting multibit faults.


Inspiration can be drawn from the success of Rhodium [16], a domain speci.c language for declaratively specifying data.ow analyses that are veri.ed by an automatic theorem prover without any need for human intervention.

analyses implemented in Rhodium work on a simpli.ed intermediate representation of programs, and it seems likely that in order to verify source-level analyses interactive theorem proving is a more appropriate choice.


In the general case, taking a snapshot of the processing stack of the selector or implementing a sophisticated state extraction method would be inevitable.

the selector state can be drastically reduced when a speci.c operator execution model constrains the scope of possible selections.


For all these three methods, S is similar to L in the sense that it is applied by combining grid function values at a set of neighboring grid points.

for the two latter methods, S is also di.erent from L in the sense that it is not data parallel, the computations at the di.erent grid points must be performed in a certain order.


For example, let rec quad x = let rec dbl y = y + y in dbl (dbl x) in quad 123 can be .attened like let rec dbl y = y + y ;; let rec quad x = dbl (dbl x) ;; quad 123  just by moving the function de.nition.

a similar manipulation would convert let rec make_adder x = let rec adder y = x + y in adder in (make_adder 3) 7 into let rec adder y = x + y ;; let rec make_adder x = adder ;; (make_adder 3) 7  which makes no sense at all.


It is difficult to graphically express this concept in Theme/UML due to its foundations in UML and the misalignment between the objectoriented concepts in UML and the dynamic, aspectbased module creation in e. An attempt can be made using sequence diagrams as they have the ability to represent object creation over time with lifelines.

behaviour described with sequence diagrams become difficult to visualise and understand as designs grow and aspectoriented extensions are added.


In this case, the SAND Internet Browser can still be utilized to view data from remote locations.

frequently accessed data can be downloaded to the local database on demand, and subsequently accessed locally.


The ActionScript bytecode resulting from this somewhat involved build process is more complicated because it simulates raw memory and CPU instructions on a type-safe virtual machine.


The same holds for the percentage of modi.ed rules (1.59% for the .rst group and 2.19% for the second one).

in the third group these numbers rise dramatically, reaching 11.05% of deleted declarations and 16.95% of modi.ed rules.


Many compiler optimizations, e.g., those in Fig 2, have been shown to be highly effective for computations similar to the gemm kernel in Fig 1.

the performance of the compiler-optimized code is often suboptimal when compared to those attained by manually optimized libraries, e.g., MKL [17], ACML [4], and ATLAS [29], which have been supplied by CPU vendors or HPC researchers, often with selected kernels directly implemented in assembly [8].


This middleware introduced a loosely-coupled, event-based style of component interaction, aligning well with the volatile nature of the network (con cern (ii)) and simplifying component recon.gurations (con cern (i)).

experience has shown that programming applications in terms of events rapidly tends to become very complex, especially when multiple unordered events need to be composed together to compute the application behaviour to invoke.


Algorithms are variously described using text, tables, .owcharts, functions or pseudocode.

ambiguity that can limit the e.ciency of communication is common.


Both are equally universal and more-or-less deliberately semantics-free.

still distinguishing Smalltalk from Plan 9 is the former s meta-system and inclusiveness towards objects large and small.


So ideally, the goal should be to partition the communication set such that all elements within each partition are required by all receivers of that partition.

the receivers are not known at compile-time and partitioning at runtime is expensive.


Finally, in our study, we considered only the CPP usage in C programs, while the CPP is used with other languages such as C++ as well.

all tasks and code examples have been chosen without making heavy use of underlying language mechanisms (i.e., standard imperative mechanisms).


For example, consider the locksets obtained in the code given at the beginning of this section if we drop all locks that will not reach a subsequent release: 1: void foo(int x) { // unlockset 2:if(x) {} 3: lock(l); { l } 4: ... {l} 5: if(x) {l} 6: unlock(l); { l } 7:} {} As with the original analysis, the lockset will contain l at lines 3, 4, and 5.

unlike the original analysis, l is eliminated on the false path of the check at line 5 since it reaches no subsequent release.


For example, Smolka and Grosu [5] take a Monte Carlo approach to model checking, as they randomly generate paths in an attempt to .nd violations, and in so doing they arrive at a measure of certainty about the property being violated or not.

as in the case of testing, the probability associated to the potential violation of the property is subject to a con.dence value, which in order to be su.ciently high, requires large amounts of paths to be generated.


Random testing catches up with the coverage of Swift-Hand given an additional period of time for some small apps; musicnote, explorer, and tippy.

random testing fails to close the coverage gap for complicated apps; mininote, mileage, anymemo, and sanity.


The state-ofthe-art of formal proofs of Vigilant s countermeasure is the work of Christo., Chetali, Goubin, and Vigilant [CCGV13].

for tractability reasons, the proof is conducted on reduced versions of the algorithms parameters.


Specifically, the state information would include the current disease state of every farm in the area managed, countdowns to state transitions, some state information about farms outside of the area managed (enough to know which can or cannot receive contacts), records of past contacts among farms (in case the simulated disease control authorities need to do tracing , or following the path of infection backwards from a detected infected farm), the current shape of the disease control zones, and more.

in the PAW algorithm, all of the mappers are active on every simulation day.


No attempt is made to ensure type-safety or security for sand-boxed code.

it has some, probably signi.cant, performance advantages[7].


For example, PDC2 left a comment in the source code about liking CodeGen while he was working, and another participant said that what he liked most is its ability to identify problematic areas:  [PDE2] If Explanation didn t give me warnings, I would not pay attention to the vulnerable code.

aSIDE is currently a demonstration prototype, working on only one type of secure programming issue, namely, lack of input validation/encoding.


This has been a successful practice for the past few decades before the introduction of MPSoCs due to the pivotal role of compilers.

the traditional compiler technology does not scale for MPSoCs.


(y) = {z|z ..F(F1(y1), ,Fn(yn)) and C(ye,f1(y1), , fn(yn)) is valid} As stated earlier, the above definitions taken from [5] and [12] provide just enough formalism for capturing the notion of solids and operations on them in the programming world of LSD.

a solid modeling kernel for maintaining solid models and operations in the solid world is also required.


For the Callable concept, on the otherhand, itis noproblem todeclare instances concept_map Callable1,unsigned int> and concept_map Callable1,float>.

other concept designs are also possible.


Consequently, the performance of DS is better than that of USFI because DS reduces energy by executing tasks without blocking in a lower frequency Lk, compared to USFI.

the energy of DS is slightly higher than that of USFI when the utilization is 0.5.


For example, if a virtual call site has the same dominant call target in all executions, the analysis may decide to inline the method unconditionally.

it is possible that the repository contains pro.le data that contradicts itself for di.erent runs of the program, such as a call site that is dominated by calls to method A in some executions, and method B in others.


Also, thanks to late binding, permanent failures of nodes participating to the execution of a process instance, but not involved in a computation at the moment of failure, do not a.ect the execution.

the system cannot currently recover from permanent failures of nodes actively involved in a processing step.


Our method has significant advantages over currently used methods which are based on a conservative estimate of duty cycle and can only provide sub-optimal performance.

this work is only the first step towards optimal solutions for energy neutral operation.


This approach does produce an adequate encoding, but it is rather inconvenient to use.

an implicit conversion can reduce the need to apply this conversion explicitly (line 61): trait LambdaUpcast extends Lambda { case class Upcast[U, T <: U](e: Exp[T]) extends Exp[U] implicit def upcast[U, T <: U](e: Exp[T]): Exp[U] = Upcast(e) } Scala type inference is too fragile and unpredictable for handling such implicit conversions (as shown in the companion code) or a robust variant.


Most errors can be prevented in an early phase before they impact bigger parts of the code.

due to the integration of security analysis, the software development process has to be slightly modi.ed.


The main problem of the system in Example 4 is that the rules are not constructor-based.

for functional logic programming, the class of considered systems can be further restricted since we are interested in the class of weakly orthogonal, constructor-based CTRSs.7 We want to show that a slightly modi.ed transformation preserves con.uence for this class.


Having an explicit formal semantics speci.cation for a DSML can enable us to automatically generate model execution tools, such as debuggers, simulators, veri.ers, and testing environments [2].


In §6.2 we present results showing our approach has similar levels of prediction accuracy to [37].

pCS is agnostic to the precise model used to predict app usage behavior.


eliciting requirements from continuous user input poses several technical challenges, in particular because a large amount of data has to be analyzed.


Both use constraint solvers to change object instances and cover more branches using the changed object instances.

as shown in Figure 1, without desirable object instances at the .rst phase, sometimes it is dif.cult to formulate all conditions and determine the constraints.


To extend a language, a programmer writes a preprocessor that translates the extended language into the base language.

each extension requires its own preprocessor and preprocessors can only be composed sequentially, that is, run one after another.


As most GC implementations, it competes with heap expansion, as at a given time a decision is made if one or the other is retained as a solution to a heap over.ow.

we have avoided tight coupling of our GC algorithm with symbol table expansion, partly because we wanted to be free to use Java libraries like HashMap or possibly other Map implementations for our symbol tables.


One goal of this workshop is to investigate how these Web 2.0 technologies can improve software development practices.

this is just scratching the surface of what can be done by incorporating Web 2.0 approaches and technologies into collaborative software development.


This can effect the systems ability to respond in a timely manner to calls which exceed their maximum execution duration.

this excess will be immediately reported on completion of the foreign function call, and the computational will abort.


The work in [6] that utilizes Twitter to construct a crowdsensing system capable of supporting multiple crowdsensing applications is a step in the right directly.

this system lacks the flexibility to meet the diverse service requirements of different participants engaged in multiple crowdsensing tasks.


The design questions aim towards coming up with an effective technique for developing enterprise UIs with simplification capabilities based on existing research work.

the knowledge question aims towards answering how this technique would perform in a practical scenario.


These factors are captured by the general understandability variable in our study.

redundant information as well as not enough information makes the diagrams imprecise (i.e., relevant information remains hidden).


However, for the purpose of FP counting, it does not matter how many times the same operation is performed: we could represent the addition of just one optional service to the subscription, obtaining exactly the same number of FPs.

when modelling a transaction it is often convenient to highlight iterations, since they are likely to be relevant for the following development phases.


automatically generated demonstration videos for UI interaction validation.

changes and new requirements can arise at any point in the project lifecycle, which leads to situations where unimplemented requirements (technical or non-technical) often coexist with implemented parts of the system.


In some sense, all of the original handlers in the Java implementation are already guaranteed to be exhaustively implemented, since the Java typechecker ensures that handle1 returns a boolean value on all feasible paths.

the Java style of event handling encourages shortcuts that make this checking insuf.cient.


An optimal and imperative solution is known since 1975.

the imperative nature of this data structure may be a drawback when it is used in a backtracking algorithm.


The LIP data structure has to be recalculated periodically, at least, partially.

it is usual that the dynamic nature of the problem changes slowly.


We assume that focusing on high-severity faults, instead of low and medium severity faults, will result in greater customer retention.

addressing each fault requires developer e.ort.


Therefore, if the answer to this test is positive the constraint is not redundant and we get a database state that violates the constraint.

the constraint is redundant if the answer to this test is negative.


The section on related work will discuss existing research for detecting and .xing speci.c types of inconsistencies.

the major practical challenge lies in providing an integrated environment capable of dealing with all these types in a holistic manner.


The bug occurs if the client sends a too large request to read, in which case the connection is closed and the state reset to 0.

the programmer forgot to return at this point in the error path.


Typically, there are plenty of issue slots and registers available for this, so this isn't often a problem.

this small slowdown could be removed by numbering all classes with a small integer constant.


The reason why this behavior is nevertheless implemented in the manual refactoring is because their traits are organized in different layers where traits override inappropriate behavior from subtraits.

our approach does not have any distinction between implementation-and interface-traits as they have.


The lxcloud project at CERN used a customized BitTorrent client to deploy almost 500 10GB VM images in 23 minutes, without on-demand download [38].

their base network of 1 Gbps was 10x faster than those used by [28, 7].


An update event which is sent will arrive at a receiving entity which can be in one of the three no session (Ri), session member (Rk) and session coordinator (Rm) possible states.

at the time the event is composed the sending entity is not aware of the state of a receiver.


Furthermore, if the type representation is left concrete, the type family can be extended in an ad-hoc polymorphic fashion.

de.ning an ad-hoc equality predicate for each user de.ned type constructor is tedious work.


Since the study was purely exploratory, we did not have specific hypotheses, theories, or conceptual frameworks in mind to which we tried to connect the responses given by the interviewees.

we tried to develop an understanding of how the adoption of OSS in the context of requirements management facilitates open innovation.


The performance overhead remains fairly consistent with Blackburn and Hosking [5], and is explained by the increase in retired instructions.

unlike the prior .ndings, hybrid does not dominate object and boundary.


Most of the above DVS algorithms in RTOS assume an embedded hard real-time environment, where the workload consists of only real-time applications and the WCETs of applications are achievable or deliverable.

our SRT-DVS algorithms target a typical open mobile environment with mix of multimedia and best-effort applications, where it is difficult to precisely estimate the WCETs of applications.


THE CATEGORICAL # MODEL For better understanding of this section, knowledge about basic category theory and graph theory concepts are required.

some intuition behind the introduced formal concepts will be provided whenever possible.


Their approach is similar to our stochastic allocation.

there are two di.erences: (1) their approach pro.les resource busy intervals in an isolated environment using on-o.


If nothing goes wrong, those steps correspond to the simplest possible work.ow in SmartSynth.

since it is dealing with end users and natural language, SmartSynth faces many uncertainties.


many people .nd objects to be deeply appealing in their simplicity and .exibility.


The abovementioned proof assistants employ higherorder logics and type systems in order to maximize expressiveness and generality, but also to facilitate modularity and reuse of veri.cation effort.

despite the expressiveness of these theorem provers, effective solutions to some veri.cation problems can often only be achieved by going outside of the provers base logics.


A unifying medium is clearly useful because it converts problem of size n2 mapping all languages to all other languages into one apparently of size 2n.

c is a poor uni.er: manual resource management, reliance on mutable storage and machine-and compiler-dictated object layout present a low-level medium for glue code, while the lack of run-time checks greatly complicates debugging.


Figure 7b con.rms our observation for the ext3 4K trace that MEMS-based storage devices exhibit shorter read/write time than .ash.

with the seek time added, the response time of MEMS-based storage devices becomes longer.


In contrast to the above scenarios, remodularizations in SubjectJ did not require making these kinds of decisions because only one strategy, split method, was ever used.

4.4.3 Automation of Transformations The more complex separation strategies used in the Java remodularizations usually involved manual transformations not well-supported by the available automated refactoring tools.the only strategy usedin SubjectJ remodularizations was the split method strategy, which is relatively well-supported by Eclipse.


The Deliverable interface is implemented by the application programmer in order to receive events matching the issued .lters.

unlike the API proposed in [5] the validity of the .lters and advertisements is not explicitly included in the corresponding advertise and subscribe API calls.


Limitations of the prototypes prevented us from investigating these questions through a long-term deployment that may have provided strong qualitative and quantitative evidence.

we were wary of using a privacy survey, abstract from social practice, for the reasons discussed above.


In [11], the authors advocate an approach of using VMs for grid computing.

the hardware environments for grid computing are usually loosely-coupled, wide-area systems.


If a user initially searches for the term prints and no results are returned, he is likely to broaden his query and search for print .

in Java code, the result will include a large number of false positives caused by the commonly used method System.out.println().


If queries are restricted to predicates on state-variables and data, this is the language for which we show equivalence of the two semantics.

the equivalence does not hold if the queries are predicates on the dataspace.


Similar to the preprocessor approach, FOPG can produce the exact desired code.

the core functionality is not oblivious of the features.


They have been proposed assuming that all components (blackboard, control, and knowledge sources) implicitly trust each other, andthereisno meansof any unwanted activity amongthem.

many distributed applications(such asthose mentioned earlier) require to take into consideration security, since data sources may handle sensitive or valuable data, such as personal or credit card information.


A syntactic, necessary criterion when a macro grammargeneratesa context-free language does notexist because this problem is undecidable.

the problem we are after is a simpler one.


All these e.orts target on improving a single Kmeans process, which can be integrated in Mux-Kmeans.

some researchers aim at choosing a set of representative initial centroids, expecting improving the  (a) Lastfm Dataset k:6, s:8 (b) Net.ix Dataset, k:6, s:8 (c) Bio train Dataset, k:6, s:8 Figure 6: Lastfm, Net.ix and Bio train Clustering Quality (a) k:6, s:8 (b) k:12, s:8 (c) k:18, s:8 (d) k:6, s:20 (e) k:12, s:20 (f ) k:18, s:20 Figure 7: Bio train Clustering Quality   (a) Lastfm Datset (b) Net.ix Dataset (c) Bio train Dataset Figure 8: Elapsed Time clustering result quality.


[19] use type as a predictor, based on perclass rather than per allocation site lifetimes.

they .nd type-based predictions be poor predictors.


[27] will .nd that statements S1, S2, S3, and S4 are all in race since they all may happen in parallel and writes to x.

array data.ow analysis will show that the read of x at S5 has two potential sources, S2 and S4.


JBoss AOP [2] and AspectJ 5 Developer s Notebook [1] use the @Oneway annotation in void methods to specify execution in separate threads.

additional thread functionality such as join, interrupt, sleep and definition of some parameters (e.g.


We extend the concept of Primary Site locking to a situation where the GCMD and a participating site could jointly own a DIF entry, thus making it necessary to acquire a lock from the second owner every time an update needs to be propagated.

given the simple needs of the IDN framework, locking is not extended to reads, i.e., it is possible that a user is viewing a DIF entry in a certain sense, and before he or she completes viewing, it gets updated at a different site and a propagation of the update is in progress.


On an open-ended survey, some of the stronger partners also suggested that such pairs are more productive when the stronger of the pairs is the driver.

this type of pairing relationship is not advisable because the weaker student feels disjoint and unimportant [13].


Due to different activities on different VMs, the execution time of VMM code is not evenly distributed across the CPUs hosting these VMs.

for the fault injection results presented so far,injections were uniformly distributed across CPUs.


K-L, C-B and BA performs well in relatively small datasets.

with the increase of complexity and scale, they can not ensure their accuracy.


Commercial leak detectors such as[16,28]enable visualization ofheap objects of different types,but do notprovide the ability topinpoint the cause of a memory leak.

existing research detectors use growing types [20,23](i.e.,types whosenumber ofinstancescontinuestogrow) or object staleness[8,18]toidentify suspiciousdata structuresthat may contributeto a memory leak.ingeneral, amemory leak caused by redundant references is due to a complex interplay of memory growth and staleness and possibly other factors.


To motivate the need for virtual properties, it is important to bear in mind that a significant amount of Semantic Web metadata originates from relational databases whose schemas were designed with the objectives of consistency and optimized access in mind.

a user may also care about properties that are derivable from or are redundant with properties already given by the schema or ontology, such as Contacts residing at the destination.


CONCLUSION Using jmle to execute the electronic purse speci.cations resulted in signi.cant improvements to both the speci.cations and the jmle tool itself, and produced a comprehensive unit test suite that can be used to test both the speci.cations and the implementation.

this e.ort did require a larger time investment than would be typical for applying a lightweight tool (that does not require signi.cant human interaction while executing).


This is a general problem with certificate-based authentication that we do not claim to have solved.

as a side note, we observe that we can leverage users' mobile devices to make physical certificate exchange practical.


This rule states that the heap must consist exactly of the code pointer pto be overwritten.

specializing Cto A- *C, we can use the rule for cases where there is additional heap A. G |(p.B) *Afc: C (- *I) G |p.Bfc: A- *C (MOVCODE) G |p.Bd fmovc fp; c: A- *C d(- *E) G |(p.B) *Afmovc fp; c: C we have to be careful how we specialize C. Suppose we allowed any type here, including A.C. Then we could pick p.Bfor Aand infer: G |(p.B) .


As long as the unstructured input was parsed correctly, the above will work .ne.

since we cannot parse all useful inputs, we have some rules in place for dealing with unparsed or partially parsed inputs.


For instance, in Eclipse Project Plans elements are intended to be completed within the planned release.

in several cases such completion has been postponed.


In the hardware based design, the main source of performance impact lies in the self-test mechanism.

since access to the cache line under test is performed by the hardware during idle cache cycles, the runtime overhead is negligible.


Based on the formulation of the t-test, it means that the null-hypothesis can be rejected if Xtl - Xtr >t.,a qS2 S2 tl tr + VV where V is the number of samples PMi (x1,...,xm) in the experiment E. Since the denominator is a positive number, the whole fraction is non-positive.

the right hand side t.,a is a non-negative number since we assumed that a = 0.5.


The distribution of an intensive constraint to a set of components consists in duplicating the constraint and distributing it to the components.

for extensive constraints, the constraint must be divided among the components requiring this constraint.


5.4.2 Optimizing Logging and Rollback Generally, we want to reduce the work done for each atomic write, even if it means more expensive rollbacks, because we expect rollbacks to be rare.

there are some cases where doing a little extra work when we log a write can save lots of time on a rollback.


CallbackHandler handler = new ABCAppCallbackHandler();LoginContext lc = new LoginContext(realmName, handler);lc.login; The sequence of statements is generally applicable; it should be the same for all applications initiating the login process.

the actual CallbackHandler object is specific to the ABC application.


Prototypes have been developed which show that innovative gameplay can indeed be implemented on a set of embedded and networked devices that are mobile or distributed in the environment.

the real challenges faced by these games, common to other sensor network applications, have to the best of our knowledge not been exhaustively examined.


For example, the peaks at 15, 30, and 45 present three L2 hits where two misses were overlapped, one miss was overlapped or no miss was overlapped with the other misses in the cluster, respectively.

the peak at 300 represents three L3 hits with little overlap.


These two works show that the term sustainability is strongly dependent on the taken perspective, and even the second de.nition cannot be operationalised.

this is necessary if SE researchers want to contribute.


For signal processing applications without modes the synchronous data .ow (SDF) model [12] is often used.

sDF models cannot model applications containing modes.


These types, along with the appropriate hooks inside the classes representing AST nodes and resources, allow for easy extension of these hierarchies with new methods.

only these two particular class hierarchies can be extended with new methods, and such extension is only possible because of advance planning by the Eclipse developers.


Frame rate captures ScreenPass s impact on device responsiveness.

because the FrameChecker runs in parallel with an app, ScreenPass could still drain the battery without affecting responsiveness.


Thread-speci.c heap techniques can be combined with our scheme to provide further performance isolation.

performance isolation constitutes only a part of our work.


On very small instances of DP-matching problems, the CPU might outrun the GPU, mostly because of memory bandwidth limitations.

if computation on such very small instances is to be performed on a basis of one string matched against a set of strings, there s a way of packing the data on the GPU to make the total computation more e.cient.


They promote a policy similar to our trade-off between scaling and delaying for suspension in Section 4.

they do not provide a look-ahead policy for deciding whether to delay early or late, such as our novel feedback delay policy detailed in Section 5.


It can rather control the activities to fix vulnerabilities by itself.

payne [26] also notes that the impact of the availability of source code on security might also depend on the open source model used.


More generally, mark-split performs well when the size of the live data set is relatively small compared to the size of the heap.

notice that another very good case is when the live objects form a small number of big contiguous chunks as in Figure 5.


Units have been used in other systems, such as Knit [17], a component model for the Flux OSKit [5].

units were originally designed to link components together, rather than instantiate their state in an object-oriented sense.


We compare the possible continuations of C2 to the restarted trace of C1 with additional origins.

from this point on, all .elds of o .W< and o .


Conventional behaves similarly for Multi-node and our realworkloads,as depictedinFigure14,againfortheAverageweekandaccurate run time estimates.

figure 15 shows that Green-VarPrices spreads the load across the week, achieving a green energy increase and a cost savings of 45% and 25%, respectively.


In this case, we lost developers interactions for these tasks, and the information loss may a.ect the defect prediction performance.

this issue will be automatically addressed when all .les are edited using the Mylyn plug-in.


This second stage has a very little communication overhead, since it requests all nodes to send only one additional message.

this tiny communication overhead helps reduce the overall costs in the subsequent stage as is discussed below.


A.2 Short presentation on Software ProductLine Engineering (SPLE) transition process and the existing strategies Transition to SPLE has been studied and various strategies are proposed.

the application of these transition decision processes is currently manual.


propose a rule-based development approach for multi-device scenarios, which empowers the application s runtime environment to react autonomously on context changes [3].

resulting applications are not .exible enough to address varying user requirements, for example, to integrate the personal smart phone situationally as remote presentation controller in an informal team meeting.


This is done by checking if concerns are addressed in one or many components, interfaces, and architectural operations.

the metrics are simply based on counting, e.g., how many components address the same concern, and no definition of goodness is given.


Struts follows only MVC design pattern based web application development.

spring is a combination of multiple design patterns including MVC, Aspect Oriented Programming (AOP), Java Database Connectivity (JDBC) Integration Framework and EJB Integration Framework.


Martincic [10], Yang [19], and Li [9] are the only approaches except ours to support classi.cation based on feature vectors from multiple sensor nodes.

the feature vectors used by Martincic [10] are limited to a single dimension per node, and Li [9] relies entirely on the base station for classi.cation.


The results show that a weighted GA is best suited in most cases, achieving the same results as a Pareto GA more e.ciently.

the studies also reveal that a hybrid approach between the two algorithms may o.er the best overall results.


RESEARCH IN MOTIVATION FOR SOFTWARE ENGINEERING The two systematic literature reviews on motivation in software engineering [1][2]both produced long lists of factors that reportedly influence (either positively or negatively) the motivation of Software Engineers to be more (or less) productive, together with several outcomes of more and less motivated Software Engineers.

the conceptual bases of the primary studies retrieved in these two systematic reviews is very diverse, which make their integration and synthesis somewhat challenging.


Rendering a scene in a virtual environment (VE) requires a combination of various 3D objects (e.g., mesh models and textures), currently often obtained from a full installation via a DVD or a network download.

downloading and installing the entire content to local storage might take a long time.


Again, very specific knowledge of compiler technology is required, and very often either the machine code needs to be examined, or the assembler created to understand the result of the compilation.

when it comes to the development of highperformance Ada applications, developers have very few tools that speak to which statements are inherently taking less time to complete than others.


Speci.cally, it found almost all relations in the 1-relation tasks and nearly 86% relations in those having four.

the rule-based algorithm faces problems when the tasks contain more relations.


Moreover, regarding the restricted resources of embedded environment, special test environment is required.

for TPI, practical and realistic improvement suggestion for embedded software is not made.


In such a dynamic and time-critical scenario where resources are limited, composite applications should exhibit QoS properties such as minimum response time and battery consumption.

the QoS of an o.ered service is in.uenced by a variety of factors such as topology changes, user s mobility, obstacles, resource availability (e.g.


In this framework, we initially saw that level selection is the most dominant layer.

a closer look indicated that the results were obfuscated by some poor level selection rules that produce overly large results (in conjunction with our other possible selections).


2005, Monteiro and Fernandes 2005, Hanne mann 2006].

since the AO refactorings are not formally proposed, developers must test their applications to check if the transformations preserve behavior.


As we mentioned in Sections 4.1 and 4.2, this system is notguaranteedto.nd all races,asthecaches maymisssome data sharing events.

we agree with the assertion of other researchers thatitisbetter tohave a racedetector that is usable but slightly inaccurate than one that is unusable [37].


RELAY uses a combination of Steensgaard [45] and Andersen [3] .ow-insensitive and contextinsensitive pointer analysis, which are used in many static tools because they scale well to large programs.

because these analyses are very conservative, RELAY overestimates the range of addresses that a memory instruction can access and underestimates the set of locks held at a program point, both of which cause it to report a number of false data races.


In AspectJ, since the AOP model is dynamic, JPs are de.ned as points in the execution of a program.

in static AOP models, JPs can be seen as static regions of the program.


This list is held in memory and the unnecessary items (the samples which have already reached the farthest ear and are unreachable in the program) are eventually and automatically deallocated.

the compass is explicitly polled (this is the functionality o.ered by the hardware) by a separate thread and communicated through the predicate read compass/1 which returns the latest read value.


The preceding result demonstrates that the proportional allocation mechanism is a generalization of the competitive equilibrium allocation, to ensure the market clears even out of equilibrium.

if users anticipate that the market will be cleared using the proportional allocation mechanism, they may not report their true optimal upload rates yi(p)or desired proportions pij (p);they may have an incentive to try to game the system.


The primary focus of all these efforts is to reduce the scheduling delay of I/O-intensive VMs and thereby to either reduce the latency or increase the throughput of I/O processing.

they cannot reduce the overhead introduced by device virtualization.


Assuming that the physical CPU is correct by de.nition, the ideal CPU emulator mimics exactly the behaviour of the physical CPU it is emulating.

the behaviour of an approximate emulator deviates, in certain situations, from the behaviour that one would have on the physical CPU.


The importance of this cost varies with the method used for membership management.

this cost does not consider the freshness of information maintained by the peers.


Our design of advising closures re.ects that distinction: by triggering advice through all aliases to a closure, we ensure that all objects of a given prototype share advice applied to the prototype.

if a new object overrides a method from its prototype, it is a different kind of object, and advice does not implicitly attach to it.


Their solution can also be used on existing applications whereas our approach would require existing applications to rewrite their SQL statement generation code using classes from the SQL DOM.

performing static checking leaves the developer powerless to defend against SQL injection attacks.


The estimates of costs areerived from the amount of people and effort involved in the project.

xP does not explicitlyd efine how to estimate other costs related to the project and does not mention how this can be done.The expected result PM5 refers to the establishment and maintenance of budget and project schedule,including milestones and/or control points.


This is analogous to theclass table CT of the MJ type system that keeps track of all classtypes.

since we are inferring label types here, we mustbuild up the label table while typing the classes, as discussed inSection 3.2.4.