We cannot merely substitute pfor (ret )R1 in . '

to express local reachability of p. a formula EFl p for this property is easily obtained by restricting the formula EF p: EF l p = µX.


For example, consider the number of Boolean variables we introduce for maps: if M is a map from A to B, we introduce |A|× |B| variables.

the number of functions from A to B is |B||A| so by a suitable encoding scheme, we can make do with O(|A|log |B|) variables.


As the randomized decisions distort the estimated boundary points, many more of them are needed compared to the boundary estimation with a deterministic detector.

for example, in the case of a linear outer boundary, the number of necessary points still remains linear in n. Thus, the attacker calculates the shortest projection to this boundary and scales this direction to a position in R0.


Case E1 is a game that reports user s score to a remote server for ranking purposes.

the reporting component is made public and reports arbitrary scores speci.ed by a requestor, which creates an easy way for cheating the game s online scoreboard.


For clustered single-threaded architectures, the scheduler alsoneeds to insert communication instructions to move values from one register bank to another [2, 13, 29].

the fact thatdependent instructions are executed in different threads makes thegeneration and optimization of communication more challengingfor multi-threaded architectures.


The need for representing data in standardized format across a system of diverse resources has resulted in several standards, such as eXternal Data Representation (XDR) [34], Structured Data eXchange Format (SDXF) [35], and many more.

the target systems for these standards have been loosely-coupled systems distributed over a wide-area network.


A large increase in load that causes temperatures to rise quickly can be considered a thermal emergency.

none of these previous techniques can tackle such a signi.cant increase in load and temperature without serious performance degradation.


For example, Unixlike operating systems provide the times() system call that returns the time the CPU has actually spent in the calling process.

fraudulent machine owners can easily tamper with the operating system to make times() always return a time slightly smaller than the time elapsed since process creation, creating the illusion that the caller process exclusively owns the CPU.


Most of the recent studies on flash-aware index design focused mainly on the buffer management scheme whereby they can reduce the costly write operations to flash.

in this paper, we present a novel Btree storage scheme, a group round robin based B-tree index storage scheme, which applies a dynamic grouping and round robin techniques for erase-minimized storage of B-tree in flash memory under heavy-update workload.


Before we decided to develop an own water level detection solution, some commercial humidity sensors were tested.

main disadvantages of these sensors are that they (i) are expensive, (ii) measure the relative (absolute) humidity in the air, (iii) get destroyed if water .oods the outer pipe.


For example, we can carefully prearrange the bits into words and therefore exploit more parallelism within a word.

the cost of prearrangement may not be offset by word-level parallelism alone.


3.4 Notation In the last section we have described a set of variability mechanisms for State Machines, which allow for describing how to realize variability in process families.

in order to be able to create process family implementation artifacts based on the process family architecture and to support the derivation of application speci.c implementation artifacts, some additional information are required.


The similar performance of the policies at 70% load is due to the lack of competition for resources.

for the 90% load the good service game operator provides the best underallocation, followed by the balanced and the ef.cient operators.


The text document without embedded pictures is signi.cantly smaller (28% 44%).

the delta of the text documents are by around a factor of .ve larger then the deltas using Word 2003.


This mechanism works well when failure is uniformly distributed across all regions of the target area.

there is a corner case in which a disturbance (e.g.


Concrete guidance on how this should be done, is not provided, lnternet-speed development establishes certain practices or principles that should be in place.

it does not offer any concrete guidance on how one should actually carry out the ideas of e.g.


In this example, the (S2, R2) pair in basic block 8 can be removed since the R3 in block 1 rede.nes p .

since our optimization framework does not yet support multi-threaded redundancy elimination optimization, this communication is not removed.


Therefore, it is often used in various scenes such as self-analysis.

analyses of the answers often distorted by intentional answers of testees.


ConSpec [1] leaves concurrency to future work, while Mobile [28] supports only one form of synchronization implemented as a trusted library.

to our knowledge there has not been previous work that certi.es general synchronization properties of IRM s without implicitly trusting the synchronization strategy by baking it into the trusted policy speci.cation.


Variants that show such a behavior are straightforwardly discarded.

variant2 and Variant5 are the best ones since the gap between best/worst values is lower than 50%, which is very likely due to their common feature to embed 4cores processors that provide enough computational power to handle the worst case.


In general, this is not necessarily the case.

then the code generator could be extended to generate annotation plans which would, as an extension to the techniques presented in this paper, supply additional program-speci.c patterns, and would also allow the default inference algorithm to be modi.ed.


Most Software Con.guration Management systems o.er optimistic concurrency control.

optimistic concurrency control comes at the price of possible simultaneous and overlapping changes also known as con.icts [6, 2, 15].


To measure the e.ectiveness of the reduced test suite, between 12 and 30 faults were manually injected into each program, with an average reduction in e.ectiveness ranging from 4.44% to 9.20%.


[20] have reported results of a measurement from a popular P2P live streaming system via the server side.

there are vital di.erences between live streaming and VoD streaming.


It is true that the cost of producing the art assets will be higher as 3D models are very costly.

small endeavors may find enough material among the numerous free resources available online, while bigger projects with inhouse artists will still benefit from this instructorcentered approach [10].


At each iteration, the size of newly discovered frequent subgraphs is increased by one.

the pattern-growth approach [23, 3, 8, 16] extends a frequent graph by adding a new edge in every possible position.


If faster code generation is desired, we can also solve the shortest-path problem with a fast Burg-generated automaton [Pro95]: represent states as nonterminals, VM instructions as (unary) operators, and the state transitions as chain rules.4 For a simple set of cache states and a pretty complete set of VM instruction instances, the bene.t of using the optimal algorithm is small and usually will not amortize the additional time spent in the front-end, but for more complex stack-cache organizations and sets of VM instruction instances with many holes or additional alternatives, the run-time bene.t of the optimal algorithm is greater.

the main bene.t of the optimal approach is that it is easier to implement a shortest-path algorithm (where the only thing you have to specify are the costs) than to generate a good DFA in the more complex scenarios.5  4 Implementation This section describes the implementation of stack caching in Gforth.


Actors with carried state cannot be .ssed at all and Q = 1 for such actors.

stateless actors can be .ssed any number of times.


Usually, a large part of the system code is devoted to error detection and handling [8, 17].

since developers tend to focus on the normal activity of applications and only deal with the code responsible for error detection and handling at the implementation phase, this part of the code is usually the least understood, tested, and documented [8].


There may be tasks that cannot be automated, such as identifying the requirements for an application, designing the data model or the navigation .ow of a web application.

many tasks, such as mapping the navigation steps to scripts in a scripting language might be automated for many applications.


An encapsulated component can help to reduce the complexity of designs; hence, libraries are means to re-use algorithms and code.

if a library cannot be adapted to the specific needs of a situation it cannot serve the whole appropriately: it is impossible to form anything which has the character of nature by adding preformed parts (Alexander, 1979, p. 368).


Therefore, an ef.cient of.oading scheme should try to: (1) extract parallelism between MMT and main thread to hide dynamic memory management cost, (2) minimize the communication overhead between MMT and main thread.

we also note that the above two goals also affect contention at MMT and cache reference locality of the program, for example performing too much speculative dynamic memory management at MMT might make other critical requests wait at MMT and possibly pollute the cache.


The HEFT policy outperforms the other policies for both of the workloads.

the performance of the HEFT policy worsens when the task completion time information is inaccurate (HEFT-P).


[41] also identi.es dead code on a block level by checking the consistency between model-level and code-level feature constraints.

the work is based on the assumption that code is directly annotated by the corresponding feature condition and does not consider control dependencies.


One limitation of the CUDA model is the lack of ef.cient global synchronization mechanisms.

synchronization within a thread block can be enforced by using the syncthreads() runtimeprimitive, whichguarantees that all threadsin the same thread block have reached the same program point, and data modi.ed by threads in the same thread block are visible to all threads in the sameblock.synchronization across threadblocks canbe accomplished only by returning from a kernel call, after which all threadsexecuting thekernelfunctionareguaranteed tobe .nished, and global memory data modi.ed by threads in different thread blocks areguaranteed tobeglobally visible.


Familiarity of technology, stability of features through a development cycle, etc., may cause lesser e.ort to be expended for the same change as compared to the e.ort during the initial stages of the cycle.

in long-running projects, code decay can lead to increase in change e.ort over time [13].


The values obtained using the two measurement methods (Y-axes) were very similar for ID5 (a measure for Information Density).

for MQ and IVC the difference was lower.


Thus, the Boolean program can have on the order of 200,000 states (100,000 lines, with two states per line), which is well within the limits of symbolic model checking.

if this abstraction process were to yield too many false errors, SDV would be ine.ective.


The HLA interface speci.cation [10] de.nes a suite of services, called Time Management, to be offered by the RTI in support of synchronized execution among federates.

while it is relatively easy to implement the conservative synchronization approach using the HLA, the optimistic approach introduces a set of additional complications.


In effect we see that if users are 'scenic features' of the development process, then they are scenic features that can move from the background to the foreground, from backstage to front-stage, from just 'users' (who don t read manuals) to users with specific skills, experiences and known aptitudes ("he's not daft").

the topicality of a specific user, the problems they have and the kinds of things they worry about are fleeting and feed into developer s discussions of what is and is not working in the software rather than what this user does or does not require.


In software engineering, there are two obvious applications of paraconsistent logics: to reason about information drawn from multiple sources during requirements elicitation, and to reason about evolving speci.cations where changes may introduce inconsistencies.

there have been relatively few attempts to explore these applications.


the dynamic part is much more expensive since the information is speci.c the particular execution of a join point, and thus a join point object is created each time the join point executes.


More than 100% improvement in speed can be seen for mpeg.£~ compared to old_model.

the gain in speed, while going from 4 CPUs to 8 CPUs, is less compared to gain from 2 CPUs to 4 CPUs.


For the second group, language effect and type system effect go into the same direction.

we do not know the strength of each effect, i.e.


MONA (Mobile multimOdal Next generation Applications) [17] involves a presentation server for a wide range of mobile devices in wireless LAN and mobile phone networks that transforms a single MWUI specification into a graphical or multimodal UI and adapts it dynamically for diverse devices (e.g., mobile phones and PDAs).

they do not have any systematic approach for developing such applications based on models, particularly the user s task and a specification language.


Using a cast operator similar to C++ s dynamic_cast that either casts a generic address space to the speci.ed address space, if it indeed matches the actual address space, or returns NULL it is straightforward to de.ne a generic version of f oo: int foo(generic * int p) { if ((global int * gptr = dynamic_cast(p)) != NULL) { return foo_global(gptr); } else if ((local int * lptr = dynamic_cast(p)) != NULL) { return foo_local(lptr); } else { return -1; } } 5 For simplicity we have cheated a little by introducing the use of lambda abstraction not de.ned in MiniAS.

in practice evidence abstraction will only appear at function application and so an implementation would just add the additional argument to the associated function and thus there is no additional overhead or complexity.


Perera [19] shows how execution can be visualized in a more compact way by using slicing to elide irrelevant execution details according to a speci.ed computation.

we have complete control over probing and tracing but only through manual effort, and the addition of similar slicing in YinYang could help us diagnose problems more quickly.


As we do not know the location of the speakerin the RESONATE1 scenario, the speaker identi.cation accuracy drops.

it is still signi.cantly betterthan the non-matched scenario.


The code can be copied and pasted into a user project and used directly.

the quality of user interface code in the repositories varies widely and some of it should probably not be propagated.


If the owner cannot trust the site for sure, he or she will be very reluctant to provide all the source code.

abstracted source code, which can be neither executed nor compiled, is much safer for privacy or theft concerns.


Recall that MPI-3.0 already provides MPI_WIN_TEST as the nonblocking equivalent of MPI_WIN_WAIT.

the new MPI_WIN_IWAIT that we propose remains relevant: in fact, compared with MPI_WIN_TEST, the combination of MPI_WIN_IWAIT with the test family of nonblocking handling is more powerful because it allows the asynchronous and wait-free initiation of subsequent epochs.


Protocols have defined semantics and properties, usually being broad enough to cover a convenient spectrum of usage.

interface descriptions and content types often associate parts of their specifications with particular protocol(s) and may dictate specific protocol usage patterns, assigning in this way ad-hoc semantics to such interactions.


Observe that in order to understand the failure, it is important to know that the execution of 362 is decided by the faulty branch outcome at 342 .

how the value in 362 is computedis not important.


This reasoning technique is backed up by an analysis of how downcall problems can occur, which is also a contribution of the work.

it remains future work to carefully analyze programming languages to determine whether these are the only ways in which downcall problems can arise.


The developeralsoneedstomatchOS-speci.cAPI callstothose ofthetargetOS.InWindows,suchAPIsandstructures are public and documented.

fillingina templateis straightforward whenonlyfunctionsof types1,2,and4occurinthe traces.when hardwareI/OismixedwithOS-speci.c code(type3),more effort is required.


A PROLANG description of a protocol looks like a class declaration with (1) auxiliary .eld declarations, (2) method declarations, and (3) a protocol invariant speci.cation.

the meaning of a auxiliary .eld declarations, method declarations, and protocol invariant are quite different from the usual notions associated with a class.


In the context of software ecosystems and open source software development, characteristics of the software architecture (such as degree of modularization) have been attributed as important success factors [38].

soft-ware architectures also have a major impact on the socio-organizational dimensions of software development projects.


[19] introduce a framework that allows users to capture their individual needs using natural language text.

informal data such as natural language is generally hard to analyze using automated techniques because of its high degree of freedom.


This makes these conditionsharder to prove.

when these conditions are used,their strength allows us to narrow down the source of anyconstant-factor slowdown that may take place.


Nonetheless, pruning overcomes the major bottleneck that standard k-limited analyses run out of memory even for moderate k. By curbing the growth of the number of tuples, pruning makes it possible to run some analyses at all.

there are several caveats with pruning: First, we are using BDDs, which can actually handle large numbers of tuples so long as they are structured; pruning destroys some of this structure, yielding less predictable running times.


It isn t clear yet that these two Exchange servers will communicate with each other in order to provide that capability.

waiting until then would have severely taxed our local server storage capacities and may have resulted in server failure.


Active repli- cation permits such concurrency, but insists that all replicas perform the same tasks.

our asyn- chronous replication protocol allows different replicas to concurrently process different requests.


MorphJ[11]is a systemforcompile-timetransformation of class de.nitions.

a source class provides metadata for a user-de.nedgeneration of a new classde.nition.One of the advantages of MorphJ is that the transformations are staticallytyped.using a class as metadatais more restrictivethan other systems which allow arbitrary schema de.nitions.


Personal characters of a testee are decided by values which are classified into five grades.

the values of five elements are extracted from life logs in our proposed method.


Government, on the other hand, can have full access to the information stored at banks and the tax of.ce, which can be debatable for any real government.

we made such assumption to simplify the example and rather illustrate how functions who and certify can be used.


Centering the process around artifacts does not allow Alex and his team members to easily reconsider design decisions as a group, leading eventually to a drift between the design documents and the implementation.

henry works as part of group that uses an agile approach to software development.


A good example is Quincy, Microsoft s internal Dryad scheduler that achieves fair-share as well as high throughput [5].

even the sophisticated algorithms have limitations when considering long-running computations.


We will find that F1 is not of SC, but F2 and F3 are of SC.

we argue that F3 does not need to be verified because its consistency can be deduced from F2.


Because the data center in which the measurements were taken has considerable levels of 802.11 traf.c, 802.15.4 channels that overlap with 802.11 channels experienced higher noise levels.

15.4 channels 15, 20, 25, and 26 are relatively quiet.


The reported average overheads for Olden are 1.28, which is only slightly higher than our observed overheads.

they needed to change 1287 lines of code in total to achieve these results while our technique works out of the box.


5.1 Knowledge Sharing  Knowledge sharing was achieved through the application of agile practices such as: pair programming, co-location, daily status meetings, and minimal documentation.

the application of these practices does not always come easily and some discipline is required to reap the full benefits of these practices.


For example, a simple NFS installation may su.ce if the application has little I/O demand, or a low I/O concurrency (seen in parallel codes where one process aggregates and writes all output data, a rather common behavior in simulations).

applications that write large, shared .les usually bene.t from parallel .le systems, especially those heavily optimized for MPI-IO operations.


And though they strive to maintain high availability, these backend services can and do fail.

even regular updates, such as bug .xes and feature enhancements, can easily break dependent applications.


With 4KB page size, two page lookups are necessary because the distance between two pages in the LPT is 32 elements (128 bytes).

with an 8KB page size, the distance is reduced to 16 elements, thus two page frame indices can be brought into 128 bytes of a cache line at once.


The sumInput function can easily be made to run in linear time by simply switching from foldl to foldr.

in general solving such performance problems by avoiding the problematic pattern is not as simple: we must then make sure that that each left argument to bind cannot be the result of a bind.


A wide variety of research shows that good knowledge organization helps students remember and reuse the information that they have learned.

novice programmers often utilize a language syntaxoriented organization of programming knowledge.


Overall, the obfuscated binary executes more slowly than the original program.

note that slowdown factor would not be an important matter for some applications such as network-centric applications and CPU non-intensive applications .


The View component implements the main functionality in the user interface layer, such as capturing user interaction messages, drawing visual objects, arranging nodes horizontally or vertically and some basic functionalities like drag and drop, object selection or default view for unknown objects.

there is no user message handler in this component and the View delegates all messages to the upper layer.


Such operations will permit establishing new connections, accept- ing connection requests and removing connections.

they can also be interpreted as movement operations: entering a new ad- ministrative domain, accepting incoming nodes and exiting from an administrative domain, respectively.


[14] developed a general approach that instruments transformed branch conditions to source code and guides DSE to reach high BVC and LC for traditional applications.

those criteria have not been supported in testing database applications.


the system does not stay long in degraded mode there are not many operations lining up and therefore the loss of utility is outweighed by the gain of a short construction time TConstruct .

we expect the MERGE and GEU algorithms to achieve much better utility for longer repair times and thus also shorter reconciliation times.


While providing an run-time portion of the compiler is sensible for a JIT compiler, which has already been designed as an runtime system, most of these implementations are not JITs.

providing this run-time portion requires that the implementation is suitable for run-time use; it must have a small footprint, it cannot leak memory, it must be checked for security issues, and it must generate code which interfaces with the code which has already been generated.


We can reduce E ACT byreducing the number of activations (number of activations).

e STAT can be calculated as follows: E STAT = IDD3 * VDD * clock period *total cycles.


[a] When wrapping such a value in adynamic, a type codeis required for its ad-hoc polymorphic type.

we can make use of the existing type code mechanisms by requiring a type code for itsdictionary-passing typeinstead.


Effect of Non-standard Process Choice Our results from this analysis indicate that projects that adopted a non-standard development processes, by augmenting plan-driven processes with agile methods, performed significantly better than their counterparts (treatment = 1 is non-standard development process choice) in terms of improved productivity, and higher reuse levels.

we do see a minor increase in the defect density levels in the projects that chose the non-standard development processes.


Thereby, an AL solution would be very similar to a CL solution.

the mapping between classes and roles is not enforced by the programming language and thus left to the discipline of the programmer.


These standards often require the use of formal methods in order to ensure some safety and security properties needed of the systems in question.

developing and evaluating such critical systems is a dif.cult task that requires advanced technical knowledge and large amounts of time.


This can be achieved by adding before methods for each sensitive method, rather than scattering the logging code over the di.erent method bodies.

implementing the discounting and suggestions features from the e-commerce application in a similar way is not trivial.


In daily life, expressions regarding spatio-temporal context can be sensed as a quantitative value such as a temperature or a point of time.

it can frequently be qualitatively sensed as such expression as dark , bright , rapidly or slow .


Recently, irregular algorithms such as Barnes-Hut and kd-tree traversals have been implemented on GPUs, yielding signi.cant performance gains over CPU implementations.

the implementations often rely on exploiting application-speci.c semantics to get acceptable performance.


For instance, reference resolving in DrRacket demands that new constructs for binding identi.ers are de.ned in terms of prede.ned binding constructs of the Racket language.

our editor libraries approach is language-agnostic as our Java-independent case study for Latex shows.


Object diagrams on the other hand cover structural information as well as attributes.

they do not capture message passing, the most important aspect of scenario documentation.


First of all, sensory training is regarded as a robust way of slowing down the symptoms of cognitive deterioration and mild dementia.

the corporal activation influences in a positive way the physical status.


Partitioning by age works well for many programs because younger objects usually have short lifetimes and thus garbage collection of young objects is often able to free up many objects.

generational garbage collectors are typically much less e.cient for longer-lived objects, and thus prior work has proposed many enhancements to generational collection.


Depending on mechanism used by the container vendor and programming language this is realized by loading and unloading shared libraries and it requires sophisticated management of such artifacts at run-time.

a comprehensive support of this CCM feature is implemented in Qedo [11].


Before the class, 12% of the students stated that they already had programming knowledge, 43% some and 43% no programming knowledge at all  61% of the students did not own a smartphone  After the class, 7% of the students stated that they thought the development of a mobile application with TouchDevelop was easy, 48% thought it was somewhat di.cult, and 45% said it was di.cult.

86% of the students wanted to create more applications using TouchDevelop.


The latest version of Generic Haskell has added syntactic sugar to easily extend a type-directed 5.4 The expression problem function with new cases.

these new cases do not change the behavior of the original function, as advice does.


In the Polis system, for instance, the target architecture is a set of commercial processors [14].

all processors have the same characteristics.


A straightforward approach to structural testing could add instrumentation to a method s bytecode and leverage the JIT compiler to convert the instrumentation bytecode into machine code.

the instrumentation will remain in the generated machine code for the entire lifetime of the program unless an expensive full recompilation of a method is triggered to remove the instrumentation.


The lineage API adds complexity to Tachyon over replication based .le systems such as HDFS, S3.

only framework programmers need to understand Tachyon s lineage API.


This causes the execution of the model to vary across different computation platforms.

pTIDES willalways make the same decisions regarding which event to process, decoupling the decision from the choice of platform.


Ideally, neighbor relationships would be veri.ed every puzzle time s, to ensure all neighbors are consistently performing work.

the main purpose of periodic neighbor veri.cation is to ensure that at least a subset of a node s neighbors is still fully veri.able and can be used for system operations.


For instance, to distribute the outer loop of a nest (which can improve locality and vectorization [3]), one can operate on the .p and c parts of the schedule for the .rst dimension (a parametric shift).

altering the.i parts will lead to the most signi.cant changes in the loop controls.


It is remarkable that despite this brittleness, we still found a robust advantage of the group condition over the individual condition, speaking to the strength of the approach.

in many cases we would like to minimize the likelihood of any task failing due to a single low quality worker by combining multiple workers results.


It makes it easy to provide named services, which can be reached without knowing the process identifier of the serving process.

the current registry also has limitations: names can only be atoms (unstructured), processes can register under at most one name, and it offers no means of efficient search and iteration.


Unbalanced groups in terms of participant expertise in the given task could result.

based on the background information of participants, groups were evenly balanced in terms of expertise.


Based on a simulation testbed, they evaluate the performance bene.ts from the agent-based work.ow execution.

their used service selection mechanism based on the Contract-Net Protocol (CNP) does not support yet the negotiation of nonfunctional SLA constraints.


E code may also be executed in conjunction with scheduling strategies other than EDF.

for this purpose, appropriate schedulability tests have yet to be identi.ed.


when developing the Intel Labs Haskell Research Compiler [33].

the AMD64 architecture offers convenient instructions such as INSERTQ/EXTRQ that operate on parts of 64-bit words [3] and can be used in a machine-code generator using our representation.


other words, the conversion between the input C program and the SUIF2 representation is very expensive.

in the selection phase, the dominating sub-phase is the process of evaluating all candidate regions for the best region.


One might think that we could maintain an accurate count of the number of threads that have pinned a node and not subsequently released it by simply decrementing entry.count in release.

this approach does not work because by the time a thread invokes release for a particular node, that node is no longer current, so entry.count is being used for a di.erent node the one that is now current.


That precondition is su.cient to ensure itself as a postcondition.

this is not representative of the general case.


It takes too much effort if the same requirement must be stated newly for each software system artefact at each affected place.

we try to express crosscutting requirements independent of the modelling language, the programming language, or the platform in order to apply the same requirement expression to all these artefact types.


For unstructured languages, the calculation of controlled nodes can be achieved us- ing the algorithm of Ferrante, Ottenstein and Warren [20].

slicing unstructured programs[26; 5; 13; 2] is not so straightforward.


The mean performance is as expected: delays decrease with 1/p.

larger values of p exhibit higher variability in run-times: variability7 increases from 1.2 to 4 when p goes from 100 to 1000.


The method_execution pointcut corresponds to AspectJ s execution pointcut and identi.es a point in execution where a method-body is executed.

contrary to AspectJ it does not support wild-card patterns in the method signature1 .


The service speci.cation explicitly names lower-level services because this knowledge is required to build the service.

for example, BAMBOO requires two transports: one for sending protocol related messages(TCP by default) and one for probing(UDP by default).anyupper layers that useagiven service are unknown when specifying the service, hence those need not and cannotbeexplicitly named.We observe that the upcallevents sentto upper level services are in response to previous requests made by those services.


Our approach shares the design goals of high-level data-parallel languages, such as the aforementioned DPH [23], the purely func tional array programming languages SAC [14] and the earlier, in.u ential NESL [7] language for nested data parallelism.

we focus on structures with irregular data distribution, for which static decisions for managing parallelism are far more dif.cult.


The gqview trace does not show intensity for read or write operation.

the write locality of this trace is relatively strong as shown in Figure 7(e).


The main goal of SPL engineering is the strategic re-use of software artefacts.

re-use increases the probability of errors.


Fact (a) can be derived from the (inductively inferred) output type of insert.

fact (b) is speci.c to this particular call site y is not even in scope at other call sites, or at the point at which insert is de.ned.


[30] to automatically include details about a message-oriented middleware into a model.

this approach is limited to 1-to-1-connections and does not support modeling of systems following the publish-subscribe paradigm.


In our case, the adoption of a mobile application by third-party developers and external users is also emphasized as the main drivers for the application to become an ecosystem.

we do not discuss the architectural aspects and policies on how open the platform is.


There is no need to modify the compilationthresholds in either case.

when there are no primary compilations being performed, and there are idle processor cycles, it is feasible that performing additional compilations may improve performance, as isdiscussed in the next section.


The problem is that according to the elements taken into account, identical defects may greatly vary.

our approach is based on the exact position in the .le, and its evolution.


In such a way, the behavior could rather be specified by designers (not necessarily programmers), which can concentrate on the requirements and discuss the design extensively with different stakeholders.

we want to provide a mechanism to take profit of existing knowledge and experience in specifying behaviors.


The assumptions are then discharged by the rest of the CBS.

this framework focuses only on generating the assumptions.


In fact, an in.nite number of trajectory-bullet speed pairs satisfy the observations.

the sensorboards are also connected to COTS MICAz motes and they share their AoA and ToA measurements, as well as their own location and orientation, with each other using a multihop routing service [9].


As explained in section 4.4, the parsing stage does not match XML opening and closing tags and it does not properly analyze apostrophes for bold and italics.

the parsing stage does recognize the individual tags and the apostrophes.


2.1 Volunteer Classi.cation In the desktop grid computing environment, performance of volunteers is similar with each other.

performance is in.uenced by the dynamic nature and computing patterns of volunteers.


So their semantics are either simply themselves or gotten by validating against corresponding schemas.

for PSDs, we have to evaluate the inside expressions in order to determine their meanings.


It may be tempting to create projects that only touch on fringe aspects of a production operating system to avoid its complexity.

fringe projects do not provide the opportunity to learn about the core functionality of the kernel.


It can also include information about where to locate symbolic information, if available.

nirvana itself does not require source code or additional symbolic information for code discovery.


By partitioning di.erent objects into di.erent server groups, throughput scales with the addition of servers.

to partition, these systems either forego the ability to perform operations that span objects (e.g., [24, 13, 34, 38]) or make use of a special protocol/service for transactions that span objects (e.g., [3, 25]).


The extra checking can be attributed to Adaptive Timing defaulting to Always for methods with very fast assertions as was typically the case for the constant-time assertions exercised here.

the same cannot be said for lineartime assertions.


Further, if cpwere de.ned to call a function which needs 7, then it would also fail.

if the local access control list is A2, which entitles pto the privilege 7: A2=f ,p7!f7g,g then cpcould safely be applied in certain environments in particular, environments with 7enabled by a preceding letpriv.In an environment of mixed local and outsider code, this system will prevent outside code from accessing unauthorized local resources.


Today we know little about how software developers actually interpret and apply the principles and strategies that constitute the essence of ET.

it seems obvious that there are differences in the way ET is understood and applied in software industry.


Given the high cost of unpredictable indirect branches, these results strongly suggest that register VMs can be implemented more e.ciently than stack VMs using an interpreter.

davis et al s work did not include an implementation of the virtual register architecture, so no real running times could be presented.


In CSCW and HCI, this approach is widespread and is particularly visible in papers in which a section on implications for design is included.

as workplace ethnographies (with no ambition of informing design directly) are considered critical , approaches that employ ethnography to mediate directly between users and designers are considered problematic by many [5, 9, 15, 35-37].


The original idea for the name recomputation would have been replication .

that would be too confusing in Computer Science since replication is a well established word in databases.


Software processes to date deal with management issues, however, these are approached rather implicitly and therefore in a non-.exible manner, i.e., each process provides ad hoc solutions to an arbitrary combination of management problems.

what we are talking about here are projects that are so large that they show a critical mass of group dynamics [17] and cultural change management [25].


That is the execution of a transaction under BTP will not result in failure.

it will result in failure using WS-BA (BAWCC) standard.


When compared to system languages, scripting languages are usually easier for developing extensions and for enforcing protection.

they are also usually less useful and ef.cient.


The models only take into account cash outflows, assuming that minimizing total cash outflows is the main objective.

in profit-oriented environments, for example, where software manufacturers sell products to their customers, the expected cash inflows should also be taken into account.


It is straightforward to check that the invariant holds after every command.

this will lead to many false alarms as the code usually assumes atomicity.


In contrast, the difference between response times for the last task T7 is signi.cant (t value: -3.239; p value < 0.05), with the disciplined group being faster.

we have to take into account that the task for both groups was different.


Because of this, a transformation-based optimizer has to store many more generated plans in the MEMO structure, not just the best plan for each interesting property, as with the bottom-up approach.

it can obtain a complete plan much earlier, and thus has the ability to stop optimization at any given time.


As SLA violations are rather expensive, it is clear that a customer tries to avoid SLA violations by purchasing a device whose reliability guarantees the desired throughput functionality.

a customer also tries to save initial costs when buying the device.


Bypre-loadingtobe-used data into memory, the future disk accesses can be directly condensed into a sequence of I/O bursts.

caching as a fundamental system component in bu.er cache management has not been paid a speci.c attention.


the sequence can be repeated forever without reaching an inconsistent state).

it is a spurious counterexample, as it does not represent an execution allowed in P. The algorithm then uses this path to strengthen the agreement.


event handlers, protocol stack composition).

such structures typically do not explicitly capture the dependencies that might exist between the various parts of an algorithm, which limit their applicability to dynamic recon.guration.


Then the adaptation for changes is still difficult, error-prone and time-consuming.

designers can predict some changes and plan corresponding adaptations but they do not take the runtime adaptable mechanisms into account.


If the group noticed that the leader is missing before the parent did, then they can simply re-elect a new leader and notify their parent.

if the tree is attempting to forward an event to a subtree, then it may discover that a child is not responding to an event.


Therefore, the function AddInheritance cannot be used as a single class (role class in our model representation).

since CreateRole function can be implicitly derived from role class in the UML class diagram at the implementation stage, AddAscendant may not include the operation for creating a new role.


A top level splice cannot hide another top-level binding (or import) for x because Haskell does not permit two de.nitions of the same value at top level.

(a nested splice could hide the enclosing binding for x.)


It helps the input generator to generate random inputs independently from any code fragment.

considering certain code speci.c properties may help the input generator to generate inputs more effectively and help reduce invalid code executions in the following code clustering step.


Furthermore, since our estimator has strong built-in capability to combine the information from different levels, it can be shown that a 3-level, 96-bit-per-level design performs very closely to a 9-level 32-bit design, which can reduce the number of the sub-sketch types and hence even further reduce the cost by two-thirds.

as shown by previous evaluation results, larger values of k in the sub-sketch, such as 5 or 6, can generally bring around 25% of additional improvement of estimation accuracy, at the cost of thousands times higher cost in the storage and the lookups in tables A and B.


Size of argument and return value of if mets pges srcal Size of metadata, flash page, and remote call instruction ),( jic ffA Call rate from if to jf )( iu fA Update rate of a function if )( iu fe Energy usage when updating a function if )( irc fe )( ilc fe Energy usage of remote and local call a function if ),( jirc ffE Expected energy usage of remote-call from if to jf ),( jiulc ffE Expected energy usage of dynamic update and localcall from if to jf ),( ji fD f Difference between rcE and ulcE When using the remote call, caller transmits arguments and remote calling instruction to the callee via communication channel.

when using the local call, the function is just executed in the same system, and thus, there is less overhead on communicating between caller and callee functions.


The need is just to establish an identity for it, whatever it may be, and that can be accomplished always in the same way by a def in the schema.

how are the domain schema and domain code different from UML?


A distributed algorithm for a single-source two-tier network is presented in [2], whichadapts the tree structure in upper-tier in response to the change in lower-tier.

the solution cannot be directly extended to a multi-source network with mixers we considerhere.


To satisfy portability across different machines, a language which has full code level portability and runtime optimization technologies such as JIT compiler would be suitable; needless to say, Java qualifies as such a language.

a Java Virtual Machine (JVM) implementation assumes *Research Fellow of the Japan Society for the Promotion of Sci- ence tAlso with Japan Science and Technology Corporation Permission to make digital or hard copies of all or part of this work tbr personal or classroom use is granted without fee provided thai copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.


This is true regardless of whether the test is HIL or simulation-based.

it may be easier to address slow execution speeds in simulation-based testing, if the subsystems can be simulated in parallel.


As for cache support, SM typically tags each cache line with a Read and Write bit which, roughly speaking, are set when the speculative thread reads or writes the line, respectively.

cherry tags cache lines with the Volatile bit, which is set when the thread writes the line.


It has been developed from an optimized version of the NAS-serial.

comparing it with all the other versions is relevant to evaluate the impact of the sequential code optimizations compared to the parallelization optimizations.


Also, UltraScan does not have the notion of projects for individual users, only experiments in terms of the Airavata data model.

ultraScan can be considered a multitenanted umbrella gateway, with each of the 72 installations acting as a tenant.


When any kind of grouping symbols is possible, there may be a need for an inner choice metasymbol.

it can be present in a syntactic notation and not be equal to a de.nition separator metasymbol that we mentioned above.


In the context of k-exclusion, when k> 1, requiring that an algorithm satis.es FCFS does not make sense, since it con.icts with the starvation freedom property: If a process p completes the doorway and crashes before a non-faulty process q enters the doorway, then a k-exclusion algorithm that satis.es FCFS must prevent q from ever entering the CS, thereby violating starvation freedom.

we can weaken the FCFS property so that it does not con.ict with starvation freedom and still provides some modicum of fairness.


The new pivot key is also added in the list of pivot keys for this root key.


Each such description is con.ned to a particular language, providing no useful characterization of the common properties of CDLs.

the formalism presented here is as spare as possible, capturing only those features common to all CDLs, while allowing a particular CDL to be de.ned by specifying the parameters and results of a single function expressed as the instruction set of the DVM.


We .rst note that the Maygh coordinator tracks the content stored in each user s browser while the user is online, which could lead to privacy concerns.

we note that the Maygh coordinator is run by the web site operator, who, today, is already able to log access requests and track downloaded content.


There are many more extensions that would improve the user experience by being more context-oriented.

a naive implementation would just use many conditional branches which can lead to duplicate code and unreadable code especially when multiple, unrelated context-sensitive variables have to be taken into account.


eFlow focuses on both the services within a business process and the work.ow.

the platform focuses more on achieving the dynamism of service binding rather than Tailorability.


The problem of computing makespan reduces, as in the static case, to a longest path computation on the graphwith orderingedges.

we now have to compute the longest path in a graph where each node execution time is an arbitrary random distribution expressed by a (individual or joint) probability distribution table.


This sub-graph is the body of a loop which is de.ned by the sub-graph induced by the states {s1,s2,s3,s4} Note that this loop can only be entered by passing control-state s1 and i = j is the loop condition.

for irreducible controlstate graphs, it is not possible to identify such structures.


Finally, receivers in HDFS-based transfer mechanism with 10 replicas start .nishing slower than those with 3 replicas due to higher replication overhead.

in the long run, receivers using 10 replicas .nish faster because of less reading contention.


Similarly, the technologies that can be used to implement effectors may greatly vary, depending on their reach as well as the nature of their target: they are often the most target-dependent elements in our approach, and are likely to be handcrafted.

a significant amount of standardization of the interface between the process engine and the effectors it coordinates can be achieved, and can help decoupling the control and the actuation layers across technology and application contexts.


This setting allows most applications to have reasonable GC overheads.

three benchmarks indicate that such a setting makes the heap extremely tight during their executions (i.e.


This suggests that: Users should be offered a drag-and-drop mapping facility and a lexical mapping facility.

it also raises interesting questions about the potential for confusion when the 2 facilities are offered in conjunction with each other.


Thus, it is preferable to perform the state transfers inside the new hypervisor.

before H ypN can execute some parts of its state must be prepared, e.g., the stack must already be transferred when the new version starts executing.


Overall, we decided to express the log interval within the gene associated with a simulation object by bounding it to 40.

not all the possibilities within the admissible interval [1,40] are really expressed by the gene.


[1] identify XSSVs by analyzing server side scripts.

these approaches do not detect DOM-based attacks.


However, these systems focus on processing live streams from cameras, which potentially requires a huge amount of system resources in the large scale.

our system performs analysis of sensor data based on user queries and caches the query results for later use, resulting in e.cient use of system resources.


Previous efforts [5] [7] have validated the possibility of running HPC applications on cloud platforms.

to the best of our knowledge, previous efforts fail to resolve the above issues in several ways.


A layer in COP can modularize such crosscutting behavior.

if the context affects only one single variation of behavior, or if such variations are specialization of the same behavior, we may also consider other implementation mechanisms such as if statements and method dispatching in object-oriented programming.


Research revealed that the tile assembly model, and thus crystal growth, is Turing universal [23], implying that crystals can compute all the functions that a traditional computer program can compute.

it remains unclear just how complex tile assemblies would have to be in order to solve complex computational problems.


Due to a large number of sample points, matrix multiplication took much longer about 10 days to collect all the CPU and GPU data.

we took overly re.ned samples for matrix multiplication (a total of 109 samples) for this study, while a much more sparse set of samples would have likely su.ced.


This technique determines the optimal number of checkpoints considering each process in isolation, as a function of the checkpointing overhead (which depends on the time needed to create a checkpoint).

calculating the number of checkpoints for each individual process will not produce a solution which is globally optimal for the whole application.


It also computes EscapeP aramsOnExit(M ) to be the set of parameters that may escape as a result of some execution of M. We correctly determine that Y escapes after the call to M in B returns, and that X does not escape after the call to M in A returns.

we conservatively determine that Y escapes after the call to M in A returns.


CONCLUSIONS AND CONSEQUENCES Communication between software developers is vital for them to organise theirdevelopment activities.

communication is not consistentlyfrequent; sometimesdeveloperstalk more amongst each other and at others, seldom.


In addition, SmartSockets can use the UPnP protocol to con.gure a NAT to do port forwarding, i.e., automatically forward all incoming connections on a certain external port to a speci.ed internal address.

as explained before, this protocol is mainly used in consumer devices.


Due to the difficulty of secure deletion on flash, we concentrate on applying TrueErase to flash storage in this paper.

we also provide a high-level design of a hard drive solution to show the generalizability of TrueErase.


These macros are enabled by recompiling MySQL with debug options.

doing fault injection this way is laborious, because the macros need to be manually placed in each location where a fault is to be injected, and the speci.cs of the injected fault need to be hardcoded.


Currently, if two individuals deviate from the target path at the same branch, they are given the same .tness function.

an higher score should be given to the one that is more near to satisfy the missed branch condition.


Client 2 s increasing rate does push up both client 1 and client 2 s response time.

client 1 s response time eventually stabilizes, while client 2 s response time grows without bound.


The total number of computations in both cases is the same.

if some of these edges are non-essential, the insertions on these edges are not necessary.


This method works fine on the Windows platform.

we discovered that the SWT_AWT feature was not supported on the Mac OS X platform.


To be reachable everywhere and anytime,the chiefpurchase o.cer uses two proprietary applications running on his notebook in order to view proposed items and con.rm their purchase.

installing and maintaining anindividual specialized mobileprocess management systemforeachpurchasing agentis very unpro.table.


First, we observe that all three lines exhibit an upward trend; trained on more data, theylead to betterkeystroke savings.Asecond observation is that the context-sensitive variants, both the one based on a .xed-length buffer with previous character context (the dashed line) and the one based on the previous word context (the dotted line), appear to be exhibiting a log-linear growth; with every doubling of the training data, they yield a constant improvement in keystroke savings.

the curve representing the contextinsensitivebaseline system appearsto taperoff,falling increasingly behind the the context-sensitive variants.


These vectors were placed into an R * -tree, which was used to retrieve similar proteins, pruning the search space for the VAST alignment algorithm, greatly reducing the time needed to conduct a pair-wise alignment of small datasets.

pair-wise alignment is not feasible on databases with more than a few thousand members.


If after this intra-node migration there is still an imbalance, processes will be moved from distant nodes.

in machines with more than two memory access levels, there are di.erent distances among nodes.


From the time standpoint, the link-time complication of these global optimizations might not be justi.ed since simple global linking (S) is functionally equivalent.


In particular, we used the same techniques for handling interfaces, circular type dependency, and constructors.

we developed our own techniques for handling ValueType and Enumeration, which were not present in Java.


In general, a FBDE system needs to support all types of user selections that serve as feature arguments.

due to the fact that the actual algorithms we have developed for one-dimensional and two-dimensional selections are rather different from each other, in this paper we focus on 1-D selections only.


Some only optimize single-day or single-household power supply [14, 21], while others do not consider the interactions among renewable energy usage, multi-timescale grid power purchasing and energy storage from the prospective of a datacenter operator [14,19,20,27,29,30,33].

we seek to design an e.cient online control strategy for longterm cost minimizing operation of the DPSS under dynamic power demand and uncertain renewable energy supply in a synergetic manner, without requiring a priori knowledge or stationary distribution of system statistics.


This is because CDMA is assumed to be applied to the data link connection and the interferences received with desired signal are eliminated during its process of despreading.

unrealizable process gain must be assumed to eliminate every interference which may become enormous caused by near-far problem[5] in mobile networks.


From the nature of abstraction we identify that, the patient is involved in one-to-one data relation with the healthcare professional, doctor and the system.

the doctors and healthcare professionals monitor multiple patients so they indeed have a manyto-many data relation.


B. Speci.cation of the Device Driver Resources The device driver can be partially synthesized from the constructions of DevC language already presented.

the language should provide speci.c constructions to describe the operations the device driver should perform.


propose in [17] a novel scheduling heuristic, called Least Space-Time First (LSTF), that takes into account both the precedence and the timing constraints among the tasks.

their algorithm cannot be used as is in a heterogeneous system.


Essential to that approach is the distinction between strong and weak operations that apparently resemble pessimistic and optimistic ones.

the dissimilarity between hybrid consistency and our model lies in the effect of operations on the system state.


For example, in Erlang [5], functions may be executed as lightweight processes which communicate with each other using message passing.

while Erlang allows pattern matching to be applied to a given messaging queue to determine which messages are processed and in what order, the Erlang scheduler itself is not programmable by the application, i.e., an application cannot con.gure the Erlang scheduler to prioritize the message queue with the highest entropy.


sun.ow Becauseitisanimagerendering tool,much ofitsfunctionalityisbased on matrix and vector computations, such as transpose and scale.

each such method in class Matrix and Vector startswithcloninga newMatrix orVectorobject and assigns the result of the computation to the new object.


The overhead of compilation with the new technique is amortized by the run time reduction due to SIMDization.

achieving the maximum potential speed up requires substantial number of loop iterations (in the order of 107 loop iterations).


Thus, one of the main objective associated with CI is to obtain a better understanding of the circumstances under which an algorithm is superior to others given a problem and a quality measure.

the discovery of an appropriate algorithm is not su.cient.


In order to deal with type mismatches, we employed non-exhaustive caseexpressions.Clearly,itwouldbebettertouse a monad instead.

a monadic carrier type ma would yield an algebra f (ma) .


ReLink- can achieve better precision than the other two methods.

the recall of ReLink- is lower because of the tradeoff between recall and precision.


Crowds of too many users can overwhelm an area, making it visually confusing and reducing graphical performance.

while a player may only wish to interact with a handful at a time, he expects to be able to meet up with any of the users occupying the same virtual world.


Partial results propagate level-by-level up the tree in distinct epochs, with each node awaiting messages from all its children before sending a new partial result to its parent.

aggregating along a tree is very susceptible to node and transmission failures, which are common in sensor networks [19, 28, 29].


These studies often rely on metrics that quantify the level of coupling and other properties as indicators of pivotal quality attributes, such as design stability and robustness.

there has been no convergence or agreement on which coupling metrics are the most effective indicators of fault-proneness.


Alternatively, one can design a kernel that allows processes to download their ideal policies directly into the OS [4, 42].

in practice it is not possible to cleanly separate policies from mechanisms.


These two conditions can be merged into the the following equality, capturing both mutual exclusion and totality: pi, j+ ei, j+ si, j = 1 (6) To simplify the system, we immediately get rid of the si, j variables, thanks to (6).We also relax (6) to get: pi, j+ ei, j = 1 Mutually exclusive decision variables capture the consistency of the model for a single pair of elements.

one needs to insert additional constraints to capture transitivity.


We .nd that asynchronous I/O is used rarely and only by iLife The measurements show that signi.cantly more threads are devoted applications.

in those cases where asynchronous I/O is to reading than to writing, with a fair number of threads responsiperformed, it is used quite heavily.


As such, almost all database usage in games design has been within the development of MMOs.

the advantages of databases are not limited to persistence.


An alphabet S is de.ned as the set of distinct invariant maps, i.e., alphabet entries.With distinct invariant maps are intended invariant maps that di.er at least for one of their invariant occurrences.

two invariant maps containing the same invariant occurrences, but di.erent timestamps, must be considered as the same alphabet entry.


ACTIVESTORY TOUCH Touch-based devices and interactions are gaining increasing momentum in the consumer space, with touchscreen smartphones, tablets, and surfaces.

prototyping and tool support for prototyping touch-based interfaces have not evolved at the same pace.


Therefore, automated operations are delegated to the corresponding technology adapter.

for manual operations a noti.cation is sent to the users.


The techniques for optimizing query execution are similar to Steno, in that they propose generating lower-level code, which can be compiled or executed directly.

all of these techniques target SQL, which is less general than LINQ (it lacks a SelectMany operator), and does not at least, in the database systems described above integrate with user-de.ned code in a general-purpose language.


Note that we could have adopted Well s de.nition of typing by considering binary sequences as part of the type so that (G, (t, b)) is a typing of s if G fs:t b holds.

this de.nition would lead to a rather strong de.nition of principal typing for Java-like languages that, in fact, would not be satis.ed by any system adopting the usual notion of bytecode (see the Conclusion).


Therefore, the combined use of UML class and sequence diagrams does not signi.cantly a.ect the time the participants spent to comprehend source code.

the descriptive statistics indicate that the participants on average spent more time when using Mo (mean = 30.06) with respect to NO Mo (mean = 23).


This means that larger problems can be solved by adding strategies.

the found solutions may be suboptimal, because all minimal-time traces may have been pruned away.


First, typecase makes restrictions on all labels that appear in its argument so that it can express catamorphisms over the structure of the type language.

not every type-directed function is a catamorphism.


Model-based approaches such as Mat lab 9, Charon [3], UMLh [8], HyRoom [31], Masachio[16], Mechatronic UML [28], HyVisual [12], or SysML 10 propose a model to code development process with veri.cation tech niques to design modular embedded systems.

none of these approaches support dynamic adaptation of a run ning system without .rst designing the adaptation at a busi ness level.


Although the query times may be acceptable in many applications, we do see cases of long wait times in the table and a number of timeouts in the case of false queries.

it should be noted that we have not put any effort in optimizing our querying strategy.


The layered video scheme we use in our implementation is SPEG, which o.ers spatial scalability(SNR adaptation)in addition to the usual temporal scalability (frame dropping) [2].

our storage scheme is designed to be generic, and will support otherlayeredformats such asH.264/SVC[4] as well.


First, because the kernel text is immutable, it suf.ces for the veri.er to compare the hash value of the kernel code segment to the known good hash value for the corresponding kernel version.

the different hosts may have different LKMs installed, and so the hash value of the LKM code can vary.


For example, a VM-level history forces the replay system to replay the entire virtual machine exactly as before, and this makes it dif.cult to perform tasks such as attaching a debugger or running in-system analysis tools (e.g., Valgrind).

a process-level history requires the replay system to replay only the process, and this allows a user of replay to attach a debugger or use other tools, as long as those tools do not perturb the execution history of that process.


4.4.1 Feature Set 1 SLR-Tool is free to use and can be downloaded from its developer s website.

the website remains (to-date) in poor condition and it seems that the tool has not been updated for some time.


We cannot underestimate their tendency to compartmentalize.

attempts to cover material in the new foundation that is traditionally left to upper years can still be viewed as poaching by other faculty.


Additionally, separating the o.set and rate can su.er from poor numerical accuracy especially among clocks with nearly identical rates.

anotherapproachtoclockadjustmentintroducesasecond degree of freedom by including an integration term in the corrected clock model.thisintroducesaphaselag that grows as synchronization information is passed from nodetonode.Iftheinformation .owtravelsinasu.ciently large loop, the resulting closed loop system will have no phase margin remaining and become unstable.


With the costofUSD0.48perlargeinstanceper hour as ofSeptember,2011, the estimatedcost of this experiment was around USD 16,500.

we underestimated the cost of building, testing and .xing the experiment environment itself, which resultedin atotal cost of aroundUSD30,000.


we tried our best to minimize such subjectivity by usingdoubleveri.cation.


Finally, it is worth noting that a 4-tier architecture alone does support, to some extent, service change or replacement in speci.c tiers and hosts, without a.ecting the rest of the server side.

this support is de.nitely insu.cient to guarantee end users the high availability goals discussed in the Introduction.


Once an Activity is destroyed, it can never be displayed to the user again and thus represents unused memory that should be reclaimed by the garbage collector.

if an application developer maintains a pointer to an Activity after it is destroyed, the garbage collector will be unable to reclaim it.


records), pointers, arrays, dynamic creation of objects, and recursive function.

support for all these constructs is currently argument of future extensions of the tools.


Recently therehasbeenincreasinginterest in real-timeeditorssuch asGoogleDocs[1],SubEthaEdit [2] or synchronouspairprogramming[14] for supporting parallel work.

multi-synchronous authoring tools continuetobelargely used sincethey offersupportforprivate work while workinginparallel.


The concept has also motivated implementations that have gone beyond the traditional shell interface (see section 6 for related work).

despite its popularity, there is no prior art that has attempted to expand the syntax and semantics of Unix pipes for parallel coordination in the shell.


In [28, 19], resource management frameworks were proposed to dynamstorage resources.

iLA addresses the management issue from a di.erent perspective.


In this presentation, we assume that the transition relation of each thread is deterministic and consequently thread scheduling is the only source of nondeterminism.

our method is easily generalized to accommodate a nondeterministic but .nitely-branching thread transition relation.


Therefore, the FAST scheme shows good space utilization.

it incurs a large merge or garbage collection cost due to the high level of block associativity.


Second, the amount of BPRAM available in a system is limited by BPRAM densities and the number of free DIMM slots in a machine.

since DRAM and PCM have similar capacities at the same technology node [1, 9], we expect to have 32 GB PCM DIMMs at the 45 nm node, which is comparable to the size of .rst-generation SSDs.


For example, rather than asking what will this program print with static scoping and dynamic scoping we were able to ask write a program that distinguishes between static scoping and dynamic scoping , which is a much more challenging prospect.

in order for students to be successful in answering these harder exercises, the PL-Detective has to be a good source of information: students should be able to extract the information they need e.ectively and e.ciently.


None of these systems support language uni.cation since the meaning of a previously de.ned macro cannot be changed.

some macro systems come with more advanced support for unifying independent language extensions.


When invoked, our prediction module compares the accuracy of the two prediction methods for the last hour and chooses the more accurate method to instantiate Cloud 1 Factors other than cloud cover, such as temperature, can affect the amount of solar energy produced.

section 5 shows that ignoring these factors still leads to suf.cient accuracy for our purposes.


There is, of course, cost involved for continuing execution.

the cost is quite small compared with the benefit we get in migration time saving.


Cukic and Ma [8] mention that researchers and companies are sensitive when it comes to sharing software development data despite the advances in data anonymization techniques.

it is worth to note that the most advanced techniques in data anonymization did not focus on preserving the predictive patterns existing in original data e.ectively, which might have prevented their adoption in software engineering research.


If the latter are scarce, we can infer that refactorings and changes to the projects functionality are usually interleaved at a .ne granularity.

if mid-to-low-level refactorings are common, then we cannot draw this inference from Weißgerber and Diehl s data alone.


The GAIA methodology for agent-based software design [16] proposes interaction rules to specify communication among roles, the ROADMAP methodology [10] speci.es in a so called social model the relations among roles, and in AALAADIN [7] interaction is de.ned only between the roles of a group: The communication model within a group can be more easily described by an abstracted interaction scheme between roles like the bidder and the manager roles rather than between individual, actual agents .

most approaches to the semantics of agent communication languages do not take into account the fact that communication always takes place among agents in a role.


SUBSUMPTION OPTIMIZATION We have shown that s-topdown beats v-topdown, and s-bottomup beats v-bottomup.

there are cases when the subsumptive methods are not e.ective because subqueries that subsume others appear later during evaluation, and the complexity may have been reduced if they had appeared earlier.


They prove that replicating objects in proportion to the square-root of their query rates yields the minimum expected search size for locatable items.

the replication strategies assume full cooperation from peers, in the sense that a peer voluntarily commits some of its capacity to the system and follows the prescribed protocol for replicating objects.


Performance Analysis of Dynamic Work.ow Scheduling in Multicluster Grids Ozan Sonmez Nezih Yigitbasi Saeid Abrishami Delft University of Technology Delft University of Technology Ferdowsi University Delft, The Netherlands Delft, The Netherlands Mashhad, Iran o.o.sonmez@tudelft.nl m.n.yigitbasi@tudelft.nl s-abrishami@ferdowsi.um.ac.ir  Alexandru Iosup Dick Epema Delft University of Technology Delft University of Technology Delft, The Netherlands Delft, The Netherlands a.iosup@tudelft.nl d.h.j.epema@tudelft.nl ABSTRACT Scientists increasingly rely on the execution of work.ows in grids to obtain results from complex mixtures of applications.

the inherently dynamic nature of grid work.ow scheduling, stemming from the unavailability of scheduling information and from resource contention among the (multiple) work.ows and the non-work.ow system load, may lead to poor or unpredictable performance.


The operations taken into account are both committed and uncommitted.

asin[16], allgenerated operations are transmitted immediately to the other users and noprivacyissues are considered.


In thepresenceofchurn, theperformance of the tree-based approach signi.cantly decreases dependent on the mean session time of the peers in the system.

the underlying mesh topology of the gossip-based approach exhibits a better stability and is capableofhandlingtheincreasingdynamic inthesystem,still providing valid and fresh results.


This is possible because our data space tiling is a logical concept; that is, we do not physically divide a given array into tiles or change the storage order of its elements in memory.

in our context, it is more meaningful to work with a single Mmatrix for all nests in a process code.


Although semaphore values can be easily obtained and restored through well known interfaces, saving and restoring the state of the wait queue involves the manipulation of kernel internals.

by taking advantage of existing semantics which direct the kernel to release a process from a wait queue upon receipt of a signal, WebPod is able to empty the wait queues by suspending all processes, and therefore avoid having to save the state of the queue.


Generic O/R mapping frameworks cover a variety of aspects reaching from basic CRUD1 functionality to more elaborate features like transaction pro 1Create, Read, Update, Delete cessing.

most available systems require extensive meta-description of the object model in order to be able to perform the aforementioned tasks.


We accept the criticism of such metrics.

it is important to consider the results gathered from all metrics rather than just one metric in particular.


The users are likely to come uniformly from all directions; hence, uc is disclosed as the query source.

hilbASR achieves the required anonymity degree K at all times.


Moreover,their de.nition is remarkably similar to the view on architectural knowledge currently prevalent in the software architecture community.

somehow this work seems unrelated to the stir that started in the early 2000s and brought more attention to architectural knowledge, especially in terms of designdecisions.


There could be legacy business solutions that are already built like this and should be provided with an easy introduc-tion into a context-aware pervasive networking environ-ment.

it may be difficult, if not impossi-ble, to implement multimodal user interfaces with the Web techniques or downloadable code.


Amazon) offer web service interfaces in both the RESTful style and the SOAP/WSDL style with a surprisingly higher take-up for the RESTful style [7].

many of the successful RESTful web applications are limited to data exposure/manipulation [1, 2].


At the same time, module owners decide by themselves in 89.4% of cases, because no peer developer commented on the patch before them.

our data set shows that on average peer developers tend to review developed patches before module owners.


Following the approach taken by the recent veri.ed L4 microkernel, seL4 [14], Verve keeps interrupts disabled throughout the execution of any single Nucleus function.

(interrupts may be enabled during the TAL kernel s execution, with no loss of safety.)


If there is an 5 a tighter bound of the workload in L can be obtained adding a limitation to L in the minimum of(4).

this limitation is not needed, since the considered workload in L = Dk is already limitedby alower value(Dk -Ck +1) in the theorem.


Contextual considerations are further categorized as objectives, projections of future value, and options.

this additional categorization is for clarity and does not have a material impact on the probabilistic nature of the considerations as defined in the decision framework.


Another approach would be a global MapReduce cluster deployed over all wide-area resources to process the data over a large pool of global resources.

in a loosely-coupled system, runtime costs could be large in the MapReduce shuf.e and reduce phases where potentially large amounts of intermediate data could be moved around the wide-area system.


It traverses the object graph starting from the base object according to the access paths and registers a read or write permission (according to the path s classi.cation) for each object property along the path.

the path-based semantics pairs each object reference with an access path and computes the permission at a read/write access based on the path through which the object has been reached.


For example, the ADDITEM method exists in both the repository and in some other developers workspaces, but has not been checked out in the local workspace.

the PLACEORDER method exists in the repository, this local workspace, and all other workspaces as denoted by the line connecting all three dots.


A smaller time di.erence results in a smaller range, so the above formula underestimates the true range.

it can still be used with a proper deceleration correction function.


Collaborative intrusion detection networks (CIDNs) provide a platform for IDSs to take advantage of the collective knowledge from collaborators to improve the overall detection capability and accuracy.

most existing CIDNs rely on the sharing of intrusion data with others, which raises privacy concerns.


Remember that the baseline for the whole dataset is that 30% of positive reviews are singletons.

it can be seen in Figure 3 that the distor tion score for this hotel is close to zero suggesting that this is a false positive.


Xi points out that this constraint relation may be undecidable, but discourages undecidable instances of it.

because DML is phase-sensitive, the index language L is not the computation language, and is not computationally relevant.


Therefore, it required small number of elements in the con.guration knowledge speci.cation.

the OLIS and E-Shop are larger and more complex product lines when compared with the Buyer agent.


In principle, developers could mock any component(notjust environments)thatthe component under testinteractswith.Potentially whenadependent component istoocomplextoexplorewithDSE,developers could mock this component.

mocking comes with cost: ittakes effort to write faithful parameterized models to prevent infeasiblepaths(which could cause false warnings among test failures).


More sophisticated algorithms using statistical prediction methods could improve upon its performance.

.nding the globally optimal recon.guration strategy a priori is actually impossible, as this would require advance knowledge of future failures.


In fact, reference architectures have presented a considerable, valuable body of knowledge about how to structure systems of a domain and, therefore, they can be considered as important elements to be reused.

despite the fact that SPL (including MPL) has extensively concerned with productivity improvement for the software development, the use of such body of knowledge contained in reference architectures to support the development of SPL and MPL has not been investigated yet.


SiblingRivalry: Online Autotuning Through Local Competitions Jason Ansel Maciej Pacula Yee Lok Wong Cy Chan Marek Olszewski Una-May O Reilly Saman Amarasinghe Computer Science and Arti.cial Intelligence Laboratory Massachusetts Institute of Technology {jansel,mpacula,ylwong,cychan,mareko,unamay,saman}@csail.mit.edu  ABSTRACT Modern high performance libraries, such as ATLAS and FFTW, and programming languages, such as PetaBricks, have shown that autotuning computer programs can lead to signi.cant speedups.

autotuning can be burdensome to the deployment of a program, since the tuning process can take a long time and should be rerun whenever the program, microarchitecture, execution environment, or tool chain changes.


Existing tools typically involve computationally expensive, sophisticated algorithms, like statistical bug isolation [4], or running a clone detection tool followed by a number of error detection and pruning algorithms, which still results in many false positives [2, 3].

we believe that our consistent renaming tool (CReN) complements existing error detection tools, which are still needed to find potential errors in legacy code.


Nevertheless, all such approaches result in arti.cial overapproximations.

our above algorithm solves the problem by ensuring that we take into account all relevant behavior for every method when computing its pre-and postcondition.


That overhead might be worth it if FIT helps you communicate with users and customers.

if the FIT specifications are not read by anyone outside the development team, then the overhead is just not worth it [9].


The class file so created is readable by a stan- dard Java compiler and by a standard Java virtual machine.

only a modified compiler is able to read the proto- col LTS back from the class file.


As stated above, we assumed a stateless session model.

even in a stateless session model, intermediate transient state is created in the course of a single transaction request.


In fact, it can be used not only in workflow systems, but also in most of software systems with extremely complicated requirements.

there are still several challenges to be tackled in our work.


This reasoning implies that executing multiple applications in a single copy of the JVM puts them at a risk of being abruptly terminated because another application triggers an action that would cause the whole JVM to go down.


Thus |Ui,v |= for 1 =v =k v-1 and |Ui,v |=0 for k +1 =v =s.

in PTN, ` ´ we have exactly |Ui,v |= k-1 for 1 =v =k.


There have been lots of research on extracting human communication patterns and these research efforts largely focus on communications through phone calls, emails [3], or online social networks [13].

face-to-face human conversations, which capture tremendous amount of information on human interaction patterns, have received less attention.


Besides, the three constants, Kp, Ki, and Kd, of the inner PID controller are manually tuned at design-time.

the three constants vary from one control system to another and from one platform to another.


Parallel processing of such queries on hundreds or thousands of nodes is obligatory to obtain a reasonable processing time [6].

building parallel programs on parallel and distributed systems is complicated because programmers must treat several issues such as load balancing between processing nodes, fault tolerance, network performance, etc.


Figure 8 demonstrates that MAPR is intractable for Linux, trigger ing a kill-switch at 16,000 subparsers for 98% of all compilation units.

the token follow-set alone makes FMLR feasible for the entire x86 Linux kernel.


Note that in the rest of this paper, we limit the discussion of data skew to the context of Hadoop s MapReduce and Pig [3].

data skew can happen in other cloud data processing platforms like BigTable [5], HBase [2], and PNUTS [7], where some nodes in the cluster may end up with larger active working sets than others.


At the beginning of a round, the set of peers, all transmission bounds, and the encodings of all .le sharing states are known to all active peers.

it is not known which peers will participate in the upcoming rounds and how the transmission bounds will change.


We might think that metrics based software are the right tools.

the current state of the art is not suf.cient and they are relevant only to measure abstract and global properties like reusability or maintainability.


The hierarchical relationship between metric and SLO types allows a maximum degree of extensibility and reuse.

lamana et al [11] took a different approach in modeling SLA with the introduction of SLAng.


These interfaces describe the instance view of an adaptable component.

we also provide a type view of an adaptable component.


The open-source approach seems to have several advantages: the core is very cheap (normally free), the user can have source code access and there is a group of developers that provide know-how, maintain and improve the core.

it may also have several disadvantages such as instability (the development group changes or disappears), incomplete development, poor or no support of existing IP-reuse infrastructures and standards, poor documentation and verification methodology.


A combination of specialization plus compilation to C, or compilation to C plus compile-time information, is enough to make the program deliver acceptable sound.

the CPU usage in the Gumstix is still too high and any other activity on the same board causes audible interferences.


The two blocks must be executed by different threads.

the two synchronized blocks may be identical and therefore the model may contain a condition of X follows X.


Note that in the presentation panel, the information shown in the first table is actually joined from two different XML iterations, Name from one iteration and Subject from another with a common Language.

the content of the deadline table is unioned from two different iterations representing start deadlines and completion deadlines, respectively, with identical structures.


in which case all values are related (DR-Label1), or two protected terms are actually related recursively (DR-Label2).

similarly, we de.ne related values for F. instead of labels and bounds for DCC, two F values are related at type t under relation substitution .


managed cache and adjusting the pattern of accesses to the o.-chip device memory [1,5 7,14 18].

there hasbeen lesswork on optimizations that target another fundamental aspect of GPU performance, namely its Single Instruction Multiple Data (SIMD) execution model.


Above analysis tells us that to improve HBFD s PFR, we must reduce the failure detection time of HBFD when i is increasing.

it is impossible for HBFD, because the failure detection time of HBFD has a linear relation with i (i. TD .i+.).


Educational games exploit state of the art computing and networking technologies to provide an educational value inside an entertainment framework.

it is not easy to combine real education and entertainment.


Although they tinkered less, females tinkering was very effective: it was significantly tied to understanding and to successfully testing and debugging, regardless of treatment.

when tinkering in the more complex environment, females tinkering was predictive of lower self-efficacy.


Editor developed during the assignments We also looked at JHotDraw [4], another editor which is used to demonstrate the use of design patterns.

we considered JHotDraw as too complex for our needs.


(1..n .i ) Figure 5: Pre-matching and Pre-substitution For example, S-ANY shows that pre-subsumption can always return the empty substitution.

if the program type checks, there will always be some best substitution that contains the most information, and that is what our algorithm uses.


O Boyle Members of HiPEAC School of Informatics University of Edinburgh christophe.dubach@ed.ac.uk,{tjones1,mob}@inf.ed.ac.uk  ABSTRACT Embedded processor performance is dependent on both the underlying architecture and the compiler optimisations applied.

designing both simultaneously is extremely di.cult to achieve due to the time constraints designers must work under.


Their analysis of information seeking behaviour of software developers relates to our work in which software professionals also exhibit information seeking behaviour.

software maintenance information is searched in source .les and on the Internet, whereas in our work software professionals search for knowledge in architecture documents.


We must provide a single-copy serializable view of the database: the group of replicas must together act as a single copy, assuming no more than some threshold number of replicas, f, are faulty.

we also require that the performance of our approach must not be substantially worse than that of a single database.


The system is close to our current prototype.

the focus is di.erent since Pebble focuses on the usability of a system.


First we used static symmetric delays where only two randomly chosen bots are delayed while the other two experience no delay and recorded the 0 100 200 300 400 Delay [ms] Figure 9: Fairness with dynamic delays Our results show that the bots experience delay differences similar to human players in that the bots with lower delay have a clear advantage over bots with larger delay.

the difference seems to be smaller than what was previously observed for human players.


the hypothesis Ha 0 was rejected and the type names decreased the development times.


The private cloud can be separated physically by using open flow closed networks.

a community cloud is a way to keep clouds independent from one another while getting flexibility and security at the same time.


This approach is again very simple and efficient.

this simple approach is not sufficient to resolve two separate fields of the same struc- ture.


Fortunately, hardware advances in virtualization [11,40,41] (e.g., virtualizing I/O in hardware), have reduced these overheads substantially.

overheads for virtualizing memory are not universally low.


This should enable the implementation of each class to be simpler and more e.cient.


Note that in the above scheme, the .nal editable signature of a message is just one group element of G (e.g., 160 bits if we use the parameters in [5]).

the intermediate signatures should include the editing keys for the next editor, which could lead to O(f) communication complexity.


The result is that the second thread will return to the user a success message for the DROP request.

the .rst thread will return an entry,forthe now non-existenttable,indicatingthatit exists butsome of the entries will contain the valueNULL.


In the former strategy, deoptimization is implemented by dynamically replacing the specialized code in the runtime stack with the generic unspecialized code.

in managed VMs runtime modi.cation of generated functions is not allowed.


If more than one token satis.es this property, one such token is selected heuristically (tokens that serve frequently as separators such as tab, comma, and vertical bar are prioritized).

the programmer is free to specify the separator in question explicitly using square braces as in the Kleene star annotations.


(base +1)% N; index of the healing list in the danger group.

if block pba is in the healing list of the danger group, the freeze procedure (see Algorithm 2) is invoked to prevent this block from being excessively erased or healed in the near future (Lines 7 8).


Our results support that this ratio should be on the order of 0.1% or more for PDF to make a signi.cant di.erence in execution time.

even for applications with smaller ratios, PDF can be valuable.


This is not surprising given that the idea of GADTs can be traced back to work on intensional type analysis.

the GADT-based translation scheme has a slight disadvantage when it comes to translating programs with sub-/superclasses.


7, the response time was longer than that of a keyboard input.

the difference of the response times between the original Xen and D-MORE was negligible.


It also identifies the need for considering future products during the analysis of the domain of the product line.

no clear guidelines are given how this can be achieved.


A solution (cf.Figure 1) might use chain of lookups amongst the federation of lookup services, where a lookup service itself could be a full-.edged Jini service registered with another lookup service.

the overhead of traversing down the chain with lookups will cause considerable overhead, as each step in the traversal will require a series of full Jini service lookup and acquisition.


While implicit concepts are not (strictly speaking) necessary, this feature has been found to reduce the number of trivial concept maps signi.cantly.

explicit concepts are crucial for concepts that differ only semantically, as illustrated in Section 3.4.1.


These approaches use .tness [16], a metric computed toward reaching a target state, as a guidance for producing new sequences.

the generation is still a random process and shares the same characteristics as random approaches discussed next.


Another interesting point is that simulation data and measurement data have a lot in common, and a tool useful for one can be also useful for the other.

measurements like simulation results are often output in particular formats, and an input converter is very frequently needed.


Linear types make it possible to enforce liveness properties, which may be useful, for instance, to ensure that manual memory management does not leak.

we anticipate that safely combining linearity with exceptions requires a type-and-effect system to track when raising an exception would implicitly discard linear values.


Constraints are usually generated in a bottom up fashion making such algorithms very suitable for incrementalization when written as an AG.

in such algorithms most time is usually spent in solving the constraints, not constructing the constraints.


But HBFD can not maintain even the weak accuracy property because HBFD can make the false detection to every process due to message loss NTFD-E (send K msgs) NTFD (send K msgs) HBFD Comp Strong [(1- (PL)K)N]N [(1-fH - ((1fH)PL)K)N]N 100% Weak {[1- (PL)K]N}n (0<n<=N) {[1-fH -((1fH)PL)K]N}n (0<n<=N) 100% Accu Strong 100% 100% [(1-PL)Pr(D<t)]NKN Weak 100% 100% 1-{1 -[(1-PL)Pr(D< t)]NK}N For the weak accuracy property of N HBFDs, [(1-PL)Pr(D< or delay.

nTFD/-E can maintain the strong accuracy because if a failure notification message for a process is received, the process must have failed.


Further Work We have focused primarily on basic switches in this paper, giving brief mention to recurring switches.

as demonstrated by Yampa [Nilsson et al.


At .rst glance, this may seem to contradict the conservative nature of our approach, which we argued capable of being applied to a framework as is .

the framework design did not change at all.


At this moment, it is expected that the transfer finish time will be consistent at E(T1).

since server bandwidths may fluctuate during segment deliveries, actual completion time may be dissimilar (solid line, in Figure 2).


In this case, we would want to use a hash function with an extremely low probability of collisions, check for collisions by storing arguments and checking equality, and possibly check our memoization results against computed results.

we may want to build a trading strategy based on forecasts.


fk (t) ij {i,j}.E If we focus on decisions in the time interval t, and drop the time indices in the problem expressions, we can see that the optimization problem (7) is in the form of the classic minimum-cost multicommodity .ow problem.

none of the algorithms solving the minimum-cost multicommodity .ow problem can be applied to solve this problem.


This approachcanleadtothe execution oftasks ofa speci.cpriority although one or moretasks of ahigherpriority are still running.

this will not change the system behaviour in any harmful way.


The supplier companies still can implement the particular control laws and provide that functionality as object code.

the Original Equipment Manufacturers (OEMs) can integrate the components from various different suppliers based on the TDL component model -they do not have to know about the implementation of the functionality.


In subsequent sections we shall illustrate how these problems also impact service developers who must deploy services in heterogeneous environments.

from an application developer s perspective it is, in our opinion, clear that a unified mechanism for locating, interacting with and representing services is required.


This makes it possible to process a large class of queries without a join.

a denormalized schema uses more database space because the same value (literal or URI) is stored repeatedly.


The restriction of specifications to static interface elements has also to be noticed for recently introduced tools, such as MOBI-D [15].

the authors recognize the importance of modeling end user tasks and provide some representation facilities, as initially stated in [17].


This is a last chance to ensure that we are building the right product, but errors caught at this stage will be more expensive to correct than if they are caught during requirements analysis.

given that validation is to make sure that the unstated requirements are satisfied as well (as the stated ones) [7], this is an opportunity to check for well posedness, at least informally, even if the customer has not stated this requirement.


For the sake of generality we allow that the second argument of fF ork and fDecision is a set of edges.

according to the SPACE semantics [12], fork and decision nodes can have only a single incoming edge (see the rule IN3 in [12]).