In mathematical terms, we want to minimize:2 Q XX wj |.i -li,j|, j=1 i=1,2,4,8,16,32 where Qis the total number of nests in the application, and wj is the weight attached to nest j (i.e., informally, its relative importance across all the nests in the application).

we are not allowed to exceed the available memory capacity.


Although in a single-threaded application, these two orders are expected to be the same, in a multi-threaded application, the unpredictable interferences across threads make these two orders usually di.erent.

we want to point out that, assuming these orders equal may be a reasonable approximation.


Earlier efforts include the XML-based standards such as WSDL [6], which is designed to provide description of the service interface used by each service.

keyword-based approach taken by WSDL is of no help for the automatic retrieval of the services on the basis of the capabilities.


This is very suitable in our case, since we normally have several differing contents and labels.

in the worst case (all contents and labels are equal), computing the largest common subgraph is an NP-complete problem.


A Novel File-Level Continuous Data Protection Mechanism Oriented Service Application Jiangjiang Wu, Jiangchun Ren, Yong Cheng, Songzhu Mei, Zhiying Wang National University of Defense Technology, Computer School, 410073 Changsha, China jiang_wu_820@sina.com, {jcren, ycheng, sz.mei, zywang}@nudt.edu.cn ABSTRACT Continuous Data Protection (CDP) technology is a good schema for ensuring the continuity and survival capability of the service applications.

the existing continuous data protection technology is difficult to meet the requirements, which means more fine-grained, closely associated with the upper applications and efficient failure recovery capabilities.


Examples of such models are traditional waterfall or spiral approaches as well as V-Modell XT.

so called lightweight or agile models exist.


At .rst glance, this might sound closely related to our presented work, especially since we use a DSL that describes a similar genre as an illustrating example.

there are several fundamental di.erences that we would like to point out.


For example, the former have little expertise in, and little patience for building low-level mobile services or database systems.

the latter cannot foresee or care for all the possible ways a participant might be required to interact with the system for data input, or how collected data could be visualized.


In SSE, a particular challenge is the absence of a single platform model defining a call stack and storage model: It is not possible to look inside a service implementation to verify postconditions and invariants.

sSE can use the principles of built-in testing allowing for services to contain their own test specification and enabling their run-time verification [18].


This can result in significant performance improvements due to reduced network round-trips and internal database optimizations during query execution.

often, the optimal or intuitive way to write a given sequence of operations in a transaction from the point of view of the application developer does not coincide with the optimal statement batching ordering for that transaction.


A general waytoexplorethebroadcast/multicastrateunderdelayboundsisto packdelay-bounded Steiner trees.

suchproblemis NPhard[14].Moreover,the number ofdelay-boundedSteinertreesto considerisingeneral exponentialinthe network size.


Since the GPU is shared it causes the execution time of these two benchmarks to increase almost linearly with the number of VMs.

bS, SD and RS have CPU bound execution time.


As such, it relies on static analysis for soundness: if the analysis is too conservative and rejects a correct program, it would have to be modi.ed before it can be run at all.

conservative analysis in our system can only lead to missed optimization opportunities.


Single Precision: It is possible for Precimonious to determine that all variables in a program can be single precision.

it is important to be aware that for certain mathematical functions, simply changing the precision of all variables might not be the best alternative to achieve better performance.


On the one hand, dealing with hand-written assembly code in a source-level or intermediate-code-level analysis is messy and awkward because of the need to inject architecture-speci.c knowledge into the analysis such as aliasing between registers (e.g., in the Intel x86 architecture, the register %al is an alias for the low byte of the register %eax) and idiosyncrasies of various machine instructions.

if the analysis is implemented at the assembly code or machine code level, much of the semantic information present at the source level is lost in particular, information about types and 2In general, identifying the possible targets of indirect function calls is equivalent to pointer alias analysis, which is a hard problem both theoretically and in practice.


Not all loops in seL4 have been analysed successfully yet  due to the lack of pointer analysis support in our tools, we presently are unable to compute the bounds of loops which store and load critical values to and from memory.

almost all of these accesses are to and from the stack, which in the absence of pointer aliasing (guaranteed by seL4 s invariants), can be computed and tracked of.ine.


this cultural change is not meant to clone the culture of the development organization.


Similarly to Revelle s work [24], this study also required two developers to project concerns into source code using a tool.

the authors relied on 16 predefined concerns and on the source code of 4 systems.


For example, we could imagine stateful components or alternative postconditions.

the next step should be to evaluate the approach with a solid repository of components to get more detailed results for the approach.


In contrast to the examples presented in the introduction, there are no technical obstacles to this quanti.cation since the typing environment is closed we may simplify Cwanted as much as we wish.

in the case of annotated bindings (rule ABIND) we solve the constraint, providing as given constraint the Q from the type annotation and equating the type of the annotation (t ) to the type that we have inferred for the expression (.).


Implementation Typically, static and dynamic slicing algorithms focus on .nding statements belonging to a slice.

in many cases statements are executed multiple times in a single program run and not all executions are relevant for the slice.


The MoG method has been shown to be of good accuracy [2].

a complex sta tistical model can be a double-edged sword.


See the recent survey [12] for an extensive list.

each result is dedicated to a small subset of these primitives, typically for a few primitives at a time.


Note that the new bu.ers included in the end point structures seem to be unconnected.

as they are de.ned to be unidirectional, they are implicitly connected by the function pair.


FuseJ [21], which aims at achieving a natural uni.cation between aspects and components, takes a similar approach.

fuseJ does notyet take into account the cflow.


The containment trees from both metamodels are different.

the containment relationship between a Table and a Column is equivalent to the relationship between a Class and an Attribute.


Real options have been used for valuing the stability of middleware [4], and for analyzing the economic value of applying certain architectural patterns [23].

all these techniques are not yet integrated into an architecture evolution process.


For fewer than 64 active threads, machine utilization is less than 100% and contention is low.

as soon as utilization passes 100% priority inversions quickly dominate, wasting up to 85% of CPU time.


This work looks very similar to the solution we provide in the sense that it aims to gather the scattered code in aspects.

our solution especially aims to answer to the norms from the Web Service Architecture, which are described in the policies.


Table 5: Results Summary Hypothesis Pair are more compatible if students with  CS1 SE OO H-1 different personality type are grouped together Yes No H-2 similar actual skill level are grouped together No No Yes H-3 similar perceived technical competence are grouped together Yes Yes Yes H-4 similar self-esteem are grouped together No The most significant result is that students prefer to pair with someone they perceive to be of similar technical competence.

educators cannot predict this perception nor can pairs be formed based on this fact.


The graph exposes the linear time behavior of ArrayRecord , its Achilles heel.

we do not expect real life applications to fall in this case.


After completing the faulty user request and encountering the start address of the next request, the execution leaves suppression mode and enters recovery mode, where every load includes the fail safety check.

since the Valgrind infrastructure, which is built for the ease of writing com plex tools, imposes higher overheads, we also implemented a performance optimized version in dynamoRIO [Bruening et al.


They also .ltered out formatting changes and changes in comments and spaces, which could cause the earlier technique to identify false positives.

like the earlier technique, the approach of Kim and colleagues is also textbased.


Others, such as Google Maps (maps.google.com), supply extensive (callback-based) libraries.

with just a little effort, these callbackbased APIs can be turned into event stream transformers that .t naturally into Flapjax applications.


To do this, we extended the representation of classes so that each class has two method dictionary pointers that by default both point to the ordinary method dictionary.

if the programmer tells the class to integrate the default encapsulation policy, the second pointer points to the integrated method dictionary, which is a method dictionary that maps all the selectors (including superclass selectors) that are declared as callable by the default policy to the corresponding method.


The e.ects of the bottleneck introduced by the dynamic rate are apparent, as the static case outperforms the dynamic case.

neither case sees dramatic improvements when parallelized, and indeed the static case sees a drop in performance after 16 cores.


Introduction Programs written in traditional programming languages are typically deterministic, that is, at every step they specify exactly which action to take next.

there are many problems that do not lend themselves easily to such a deterministic implementation.


Z=0; however, it can be the case for graphs with high connectivity and small diameter.


Our subset XSLT0 emulates downward selection and node tests of XPath.

xPath expressions can also select or test on upward nodes [1, 17, 18].


We often treat connectors as mere references from one object to the next.

often higher-level connectors are really implemented by some objects in the program: examples include bu.ers or streams.


This process explores three different models: dataflow model representing the flow of control; hierarchical model of workflows representing the order and levels of activities; and a model representing the flow of data among the workflows.

to represent the experiment s flows through these models may demand greater effort in maintenance and may lead to inconsistencies among the models.


Considering those statements globally would require combinatorial conditions to be provided and, consequently, increased code complexity.

tailored adaptable programs are the result of an adaptation process which produces a customized application for the target execution environment.


This is because it has always been in addition to the hardware branch prediction, and in this situation, branch hinting can only improve upon the performance of hardware branch prediction, and the scope of improvement was minimal.


The class B problem size was 1 C++ requires many declarations to be placed in headers in order to be accessible to other compilation units, which causes declarations to require more code in C++ than in Titanium.

we do not believe that this has a signi.cant impact on productivity.


3.2 Macrosfor DeploymentTimeValues ThecurrentOVFdescriptorspeci.cation supportsmechanismstocustomizeserviceswithparameters thatareknown previous to deployment.

in a cloud environment it is required to de.ne certain features of the service that depend on magnitudes that are only known at deployment time.


Many researchers have presented multi-layered memory hierarchies as a means to design energy and performance ef.cient systems.

most of the previous work do not explore trade-offs systematically.


The most popular video, which we call the gold stream, was released on April 5 and quickly attracted a large number of requests.

the demand for this video declined very quickly, with only occasional views 5 days after it was released.


The e.ectiveness of the approach depends on a number of application-speci.c conditions, as discussed in the previous sections.

we performed a number of tests in a live setting to provide some useful insight on the general       Program Training Set Test Set Anomalous Attacks False Failed Benign Requests Positives Requests phPay 2,530 371 21 10 11 1 myBloggie 3,247 488 28 20 8 0 punBB 1,292 422 16 10 6 1 Table 3: Live experiment results.


The resulting bene.ts of applying both algorithms to the same execution at the same time are as follows: Lockset alone cannot distinguish between real races and false alarms.

djit+ detects only those apparent races that actually occurred.


Our embedding technique is clearly detectable: algorithms such as one-bit checking can distinguish annotated datasets from unannotated datasets.

we alter only the least signi.cant bits of datapoints those within the noise of the sensor measurements.


If no entry guard is compromised, then no circuits from that user will ever be linked to him.

if a user expects to be targeted by a network adversary that can control nodes, he can expect his entry guards ultimately to be attacked and possibly compromised.


[19] both have a concept of abstract state.

neither of these approaches allow objects of different concrete classes to be considered equals.


Examples of relatively simple extensions include some new constructs for iterations and Java-like labeled-breaks/continues [8].

non-trivial extensions include exception handlers [16] and nested functions, and their implementations typically need additional declarations of temporary variables; thus type information is also required.


Unfortunately, the cost of retroactively adding testing to the existing (and large) legacy code bases may be prohibitive.

certain critical areas of the legacy code can be covered with testing and testing practices can easily be used with new development or refactoring activities.


As with a standard type checker, the veri.er is responsible for detecting and rejecting type errors in programs.

the veri.er must also detect and reject programs which cannot be realised by the runtime.


Also,everykeyword fromtheJava contextisakeywordin aspect context.

"after" | ... |"proceed" -> Keyword[[AspectCtx] Keyword[[JavaCtx]] -> Keyword[[AspectCtx] proceed is nowa reservedkeywordin aspect declarations,soitisnolongerallowedasthe nameofamethodinvocation, which now rejects the special proceed call for invoking the original operation in an around advice.To reintroduce the proceed call, we need to allow it explicitly as a method speci.er in the aspect context (note that an advice context would be useful here, though that would not be compatible with abc, which is the whole point of this exercise).


2.1.1 Trustworthiness As hypervisors be gradually used in mission-critical applications, their trustworthiness becomes vitally important.

there have been various issues with current hypervisor layers.


Type safety, for example, is not of the same paramount importance, because Python is already safe an error in the guarded cast implementation may cause unexpected behavior, but it will not lead to a segmentation fault any more than it would have if the program was run without types.

by developing our system in this manner we cannot constrain the behavior of Python programs except through our casts.


We want to use this framework to provide an event-based analysis of performance.

doing so requires that the system understand how events are handled in the application so that resources could be allocated to events.


Moreover, static replication and superinstructions also work for non-relocatable code.

at least for Gforth the code for the frequently-executed VM instructions is relocatable on the 386 and Alpha architecture.


Once a speci.cation has been de.ned for a class, it can be readily reused in the speci.cations of many other classes.

the supporting functions developed for testing a particular function or module are less readily reusable for testing other functions or modules.


If there are suciently many real-world instances available, then the empirical evaluation may also play the role of the experimental evaluation.

in many situations experimental evaluation can only be fully controlled using instance generators.


We note that both light detector and cellular detector can effectively classify the indoor environment from the semi-outdoor/outdoor environment.

the magnetism detector can enhance the detection capability of IODetector in classifying the semi-outdoor and outdoor environment.


CONCLUSIONS AND FUTURE WORKS We all know that the existing literature about conceptual methods addressing the design of Web applications is (over)abundant.

we also know that a remarkable gap between theory and practice still exists [[1]],[[3]].


The activation of Ti,k occurs after an offset Fi(Tr) after the completion time of Tr,k and can experience a maximum delay of Ji(Tr).


The downside of our experimental approach, of course, is that a signi.cant number of (automated) tests are required both for .nding alternate schedules, and for isolating the failure-inducing difference.

our approach is fully automatic and, furthermore, orthogonal to analytical approaches to detect trouble spots in threaded programs.


In the same vein as Rio, the Conquest .le system [24] used battery-backed DRAM to store small .les and metadata as a way of transitioning from disk to persistent RAM.

bPFS is designed to store both small and large .les in BPRAM, and it uses the properties of BPRAM to achieve strong consistency and safety guarantees.


The experiment described above was conceived so that the random test data generation was initialized with the same values used for the real GA search, in other words, the same mutation and crossover operators were applied but .tness values were disregarded.

it can be argued that creep mutation can in.uence results, though no crash was observed.


In a world where the only base kind is *, this makes sense, since * itself is open.

with the ability to promote closed datatypes to 7 http://hackage.haskell.org/trac/ghc/wiki/TypeNats in F .


This anomaly is hard to .nd because there is no single error message indicating the problem.

we discover it because we analyze abnormal execution paths.


Mapping SPMD onto SIMD is straightforward for straightline code since each operation is just translated into its vector equivalent.

complications arise if program instances exhibit diverging control where some program instances want to execute one path of a branch while the rest follow the other.


For example, the typing of an application a1 a2 requires a1 to have an arrow type twhose domain is also the type of a2.

we are eventually only interested in the type resulting from the application, i.e.


D The lemma above suggests that subsets of C(P) may be good candidates for a weak missing hypothesis.


One could possibly create a .le for each program unit , but that may not be the best option.

grouping different program units may not always make a semantic sense.


we can write essentially the same code using the runtime concept idiom: // with runtime concept idiom wrapper forward random elem(wrapper forward f, wrapper forward l) { wrapper forward::di.erence type dist = distance(f, l); return advance(f, rand() % dist); }// ... int elem = *random elem(v.begin(), v.end()); // v is a vector of int here the binding between the iterator type and the function is handled at runtime and we can compile a use of random elem with only the declarations of random elem available: // with runtime concept idiom: wrapper forward random elem(wrapper forward f, wrapper forward l); // ... int elem = random elem(v.begin(), v.end()); // v is a vector of int By using runtime concepts, function implementations (e.g.


These tools allow also the validation of the system control performance by performing a hybrid simulation (continuous and discrete time).

when designing the control laws(modeling, synthesis and simulation), control engineers make, in most cases, the assumption that the time between the sampling of the inputs and the actuation of the outputs is zero and that inputs sampling is strictly periodic withoutvariationsof periods.


The most common view of IoT refers to the connection of things from the physical world.

the core of technology is in information interconnection and convergence [1, 11].


The simple (and common) case is when the results of the operation during the commitment phase are the same as the results obtained from the guesstimated state.

the programmer needs to handle the case when the two results are indeed different.


Security has, in fact, become synonymous with user unfriendly.

this isn t the case when security is properly understood and well implemented.


By observing that the .eld is only ever assigned a value (2.5) to which it has been compared as being greater than or equal to (2.2), the statistical maximum pattern has been explicated.

another formalism is still needed to phrase such an observation so that the pattern detection process can also be automated.


Both aim at improving the quality of the services delivered in an economically justifiable manner, while minimizing service level disruption.

their specific underlying objectives do differ.


Although far from a comprehensive study, this sim- ple list demonstrates that it is easy to write data forwarders that can live within the VRP budget.

we have measured more complicated forwarders such as TCP proxies and full IP to require at least 800 and 660 cy- cles per packet, respectively.


If the target platform is available this is not a problem.

if the performance of an application shall be evaluated during early development stages the necessary hardware might not be available.


This allows the underlying TCP connection to reach and maintain the maximum needed window size.

protocols such as FTP [27] separate data and control, resulting in multiple TCP slow starts when multiple .les must be transmitted.


EJB: Finally, for EJB, we use the same strategy as for the previous cases.

in this case the generated classes and interfaces have no extra annotations.


Hottest: Homing data on the core that accesses it is more space ef.cient in the cache and provides faster access.

as an application executes, data structures may migrate between threads.


In this particular case, that would not be critical.

suppose the algorithm kept the original map intact and returned a modi.ed copy of the map as a result.


This means that an object whose remote references remain in other places must notbe collected asgarbageevenif thereis no local referencein its home place.Forexample,in caseof theexamplein Figure3, object o seems to be unnecessary after o.value is used in Line 14, and could be collected.

it is possible that do long calculation (Line 9) stores its argument g somewhere for future use.


Like most software, OLAP-style tools are validated through testing.

oLAP systems need large data sets with special characteristics evaluating view selection heuristics at scale, for example, requires a variety of large data sets with summarizable dimensions that have di.erent (graph) structures and statistical properties.


For instance, because of the 1:1 mapping between the LindaRMI slice, which implements the primitives in the RMI case, and RMIProcess (and the same for the thread-based implementation of the primitives and of the process de.nition), one might be tempted to fold them into one feature.

this would not be correct, since the implication is only one-sided: it is possible, and it makes sense to de.ne a language where processes are executed in a thread or distributed using RMI and do not include the Linda primitives in this language (for instance, one might use other libraries to perform message passing).


directly used to parallelize sequential programs [22].

since it has the capability of tracking dependences and detecting dependence violations between two transactions, we conducted an experiment to see the performance of using software based TM (STM) in the speculative parallelzation work.


For example, in .gure 2 if D had been excluded from propagating a query-hit of F, it would detect the discrepancy when receiving the corresponding rating.

g, H, and J will not be alarmed since the rating reaches them but its TTL expires.


This latter view is sometimes adopted in more traditional applications, where trust evaluation is taken in the restricted context of that application.

in the broader context of mobile and ubiquitous computing, it is important to keep in mind that trustworthiness must be framed by the user s goals.


To allow building software that executes with the appropriate quality, model-based evaluation methods at design time [3, 9] have been proposed as a viable solution.

design-time analysis cannot always provide accurate results because the information of the environment where the application will be deployed may not be completely known when applications are initially architected; and even worse, such execution environment may change continuously during application lifetime.


By no direct costs we mean users do not pay for the download and the use of the tools.

users may have to devote resources when prototyping their application using the tools.


To leverage the existing COTS products capacities to the full extent, the GIS services manager does not intercept the connections between the COST components and the database.

the manager facilitates data accesses for the other applications such as the SWMM analyzer and LIDAR data rendering applications mentioned in Section 3.


HDDs comprised of mechanical equipments are widely used storage devices in general.

sSDs comprised semiconductors are new storage devices and are expected to replace HDDs.


For bugs 7 and 8, the number of source lines are comparatively larger as a few expression trees inside large functions accounted for a much larger number of source lines.


These developers also expect the existence of a checklist in an integrated way to automatically detect and explain each problem.

this is still difficult to find in practice.


For instance, the SQL translation mechanism makes the well- defined assumption that strict encapsulation is enforced and only getter and setter methods will be used to provide public access to an object's state.

programmers might choose to ignore this assumption or simply might forget to include appropriate getter/setter methods.


Nothing more is done until subsequent invocation of the resolve method.

in our virtualised RVM, in addition to the above, a BCEL ClassParser is constructed that fully parses the class .le, creating a corresponding JavaClass.


Awareness of a subject s surroundings and state helps applications to adapt their functionality depending on context changes and without (or with fewer) direct user interaction.

the introduction of context-awareness in applications raises a series of new challenging requirements such as discovery and selection of context sources, interaction with these sources, and manipulation and interpretation of contextual information, amongst others.


At this point behavior must diverge from call-by-value because the body of the abstraction is still unknown and call-by-need does not have [(.x.t).]

contexts for arbitrary t. call-by-need does have contexts of the form [(.x..) .y.y].


6.5.1 Software Cost Control Software cost control is today of course closely related to the traditional cost per piece and production-centric cost models in the car industry.

we observed an exponential growth of software costs in cars in recent years.


Thus, in the strict version of the calculus, it is threaded but never accessed.

we introduce it upfront for uniformity with reduction rules of the lazy version.


Once a research novelty, live VM migration is fast becoming an invaluable management tool in public and private clouds [5, 2, 15].


Consequently, the comparatively small sizes of our programs might introduce a bias towards an over-or underestimation of structural properties (e.g., the weighted interface size).

as we compare projects of comparable size in our experiment, the OP measurement for each project would be similarly affected; effectively voiding the negative effects for the comparative analysis.


In cooperative style, context switching only occurs at yield points, thus the saved context only consists of the variables that are read after the yield point.

the context in preemptive style consists of the thread s complete stack and all CPU registers.


Gavrilets considered idealized fitness landscapes with just two fitness values: viable, and inviable.

practical fitness landscapes have a range of fitnesses, complicating the picture beyond Gavrilets original analysis.


One easy solution to this could be to limit the depth level as Paraschenko proposes for his x.nd utility, an XPath extension of the UNIX find command [5].

this severely limits the applicability of the XPath shell for selecting .les in a complete .le system, and thus this solution is not satisfying.


They could not relate suchGUIbaseddeploymentprocesswith installingotherhomeappliances.

most of the users found the tangible tool familiar and user friendly.


Middleware 2004 Companion CUROCO: a distributed architecture for the dynamic generation, composition and use of context in highly dynamic and heterogeneous environments* [extended version] Gorka Guardiola Muzquiz Laboratorio de Sistemas, Universidad Rey Juan Carlos Madrid, Spain paurea@lsub.org ABSTRACT The use of context is necessary for a rich interaction with the users and adaptation of the system to their needs.

how to integrate context with the applications and the system is yet an unsolved problem.


In the worst-case scenario with no supporting reAgent servers, the reAgent still functioned on a relatively equal footing with a normal, traditional trader (represented by the stationary re-Agent).

the mobile reAgent was able to use its ability to move when closer reAgent hosts were available, allowing it to improve its performance along with its location.


This problem is reduced by using the multiple comparison procedure, which corrects for the family wise error rate.

this weakens the statistical power of the analysis, increasing the risk of type II errors, hence causing a hypothesis not to be rejected when it should be.


We assume this is because the number of packets containing shot data represents a small percentage of all transmitted packets and so does not a.ect a player s ability to aim with precision.

precision shooting is very 11 The coe.cient of determination (R2) represents the frac tion of variability in y that can be explained by the variabil ity in x.


Each piece ofcode can be tested immediately after written.

the use ofsuch immediate testing approach does not guarantee the program tobe bug-free or complete.


[3] worked on item (1) and reported experiments of inductive logic programming that generated over 40 thousand jobs.

this work was concentrated on providing an user level tool to control and monitor that speci.c application execution, including automatic resubmission of failed tasks.


For this reason, hypervisors heavily favor full isolation over sharing.

when each virtual machine is running the same kernel and similar operating system distributions, the degree of isolation o.ered by hypervisors comes at the cost of e.ciency relative to running all applications on a single kernel.


Since this image does not associate encapsulation policies with any instances (so wrapper objects are used), these values are a good indication of the performance penalty that is caused by our virtual machine modi.cations.

the numbers in the third column show the slowdown that we encountered when we ran the benchmarks in an image that applies an encapsulation policy to virtually all the objects involved in the benchmarks.


An advantage is that they are more realistic than those created through syntactic changes.

it is very time-consuming because it requires an in-depth understanding about the system functionality, security requirements, and source code.


Therefore, it could negatively affect an overall precision of prediction and effort required for the examination of false candidates.

fine-grained evolutionary rule and prediction rule have much more additional (with regards to any way and some way) information to base their decision before suggesting a recommendation.


Additionally, some approaches like aspects can be included in both groups, depending on how they are used, or combine approaches from both groups.

there are techniques that do not .t into either group, e.g., those based solely on tool support [6], based on model-driven development [51], or on generative programming [10].


At the most, we could get a huge UML class diagram.

the component structure of the system, the numerous actual interface implementations, and the functional relations were all absent.


Integration and adaptation become important for constructing a cloud management system, because a redevelopment solution based on existing systems is usually more practicable than developing the management system from scratch.

the workload of redevelopment is also very high.


The benchmark programs never raise a TLB exception.

the specializer and the interpretive translator generate compensation code in the path of the TLB exception.


About type annotations In principle HMF does not need anyspecial rules for type annotations since we can type an annotation (e :: s) as an application to a typed identity function: (.

(x :: s).x) e. in practice it is important to handle annotations with free variables and to propagate type annotation information to reduce the annotationburden.


It uses the live variable dictionary to display all in-scope variables with their values.

this behavior may be too verbose, since all live variables will be printed at each step, whether or not they are relevant to the operation at that join point.


TBG reduces the average error on targets on the structured Abilene and Sprint networks by about 40% and 70%, respectively, and the 90th percentile of error by a factor of four.

our study reveals that techniques based solely on network measurements have inherent limitations.


This architecture allows for an independent development of the VE.

the development of plugins sometimes leads to new requirements for the plugin architecture, e. g., by adding new extension points or noti.cations.


Without automation, the process is slow, expensive and errorprone.

techniques to automate test data generation must cater for a bewildering variety of functional and non-functional test adequacy criteria and must either implicitly or explicitly solve problems involving state propagation and constraint satisfaction.


With replication [19, 21, 29], any copies of a single object are kept in sync: writes are executed on all copies, while reads can proceed without any indirection.

access to a .eld that is volatile or through an atomic primitive is problematic.


Fourth, severalcombinators to expressiteration areincluded in the iTask library.

because the iTask system is a library embedded in Clean, the work.ow engineer can de.ne new combinators and even de.ne recursive work.ows if desired.


SECURE NETWORK PROVENANCE The de.nition of the provenance graph G in the previous section assumes that, at least conceptually, the entire execution e of the primary system is known.

in a distributed system without trusted components, no single node can have this information, especially when nodes are faulty and can tell lies.


For the larger programs, such as the Java Compiler, a reduction of 75% is signi.cant (i.e., T11-T16).

7000-8000 lines of code spread across 66 .les is still a great deal to analyze when 1 methD(){ 2 C c = null; 3 c = new C(...); .


This approach is faster because Dyalog-APL does not have to read type library flies repeatedly during creation and reczeation of .ADO in an interaction with a Server.

in p~ctice (~nd in our concept, too) it is considerably better/safer/more maintainable to use 'AutoBrowse' --1.


A one-way communication only occurs in the case of a change of position interval.

when the PDA is outdoor the interactions between the LocationAgent and GPS occur internally, and do not use the wireless interface.


The most interesting ones, for our purpose, are those dealing with actions and events, interaction and goals.

at this moment, they only use the patterns as a means of communicating the design and thus do not discuss or consider any implementation issues.


Two failures may be placed in different clusters because they have different causes or because they differ with respect to the non-defective code they traverse.

a successful execution may be placed in the same cluster with a failure because the two executions are similar with respect to the non-defective code they traverse.


As shown in Figure 2, the power consumption due to VM migration at the source host increases as the data transmission rate is increased.

the migration latency becomes shorter when the data transmission rate is higher.


This means a lot more overhead for the master.

this strategy performs well with tasks having unequal running times.


They also abstract from concrete memory addresses and thus allow for comparing and altering pointer values appropriately.

memory graphs also indicate another problem: The set of variables itself may differ in the two states to be compared.


Our CHS technique can be combined with most of existing branch predictors including gshare predictor [14], perceptron predictor [13], OGEHL predictor [18] and TAGE predictor [19], [20].

it is especially effective with smaller, simpler predictors, allowing those predictors to be competitive with more expensive and complex variants.


If the customer is happy, then there is no incentive to change and if the customers remain, the product thrives.

advancement of the product is dependent entirely on the single product team.


These approaches are computationally complex as they are based on application code analysis, either using pairwise comparisons [16, 13, 27, 42] or comparing applications to a subset of their closest neighbors [14, 41].

playDrone indexes application resource signatures with Elasticsearch to e.ciently match applications with common features.


We want to integrate both approaches to improve the search.

using search with integrated LTL run-time checking is not as simple as searching for deadlocks.


PB I can achieve almost zero best-case overhead, when the sampling rate drops to zero.

cBI could have as large as 20% best-case overhead, depending on the control-.ow structure of a program [21].


The maximum number of modules that can move in one round is k¼nJ.

at most two out of every four modules can decrease their vl during that round, as can be shown by an exhaustive listing of all possible moves of three modules over one substrate.


get if x > (0 :: Int) then put (pred x) else throw () The decr decrements a counter held in state.

if the decrement would result in a negative value, then the state is left unchanged and an exception is thrown.


Data Transfer.The SshFileCopier actor allows the work.ow to copy .les from a remote host to the work.ow execution (local) machine, or vice-versa.

this is needed only in the display of remote images for the user.


Note that the above formalization and theorem do apply to programs containing loops or recursion, as long as all program executions terminate.

in the presence of a single loop whose number of iterations depends on some unbounded input, the number of feasible program path becomes in.nite, and exercizing all those paths (Theorem 1) will take forever.


4.2 Pull Up Members: CheckingPreconditions We will reuse the type constraints of Figure 3 to detect when pulling up a (set of) method(s) would a.ect typecorrectness or program behavior.

there is a subtle di.erence in the way we use these constraints.


Again, their models are complicated and require manual tuning.

our regressor models are automatically constructed and have the potential to outperform handtuned models.


In general, as shown in the .gure, reducing the page frame size brings slowdown on both PAS and LPT generation due to increased number of PAS entries.

having too large a page frame size (8KB) may also have a negative effect as it may increase internal fragmentation, the ratio of unused data in a page frame.


The format of the specification language for declaration of rules and constraints is borrowed from RTSynchronizer [4, 5].

the scope of the language is to be extended to support role-based, quantifiable, and adaptive dependability specifications.


[35] Insecure Domain Secure Domain Isolation Microkernel Hardware Figure 3.

isolation kernel model it is extremely inconvenient to program any serious application without any operating system support.


Thus, only the remaining 125 paths are extended in iteration 4.

allSeqs explores 1,216 paths in iteration 3, all of which are extended in iteration 4.


The method level coarse grained atomic changes simplify the exploration process.

the programmer may have to consider several related affected tests together with their affecting changes.


Recently, the need of CBD is growing also in other domains related to dependable and embedded systems, namely, in the control engineering domain.

the widely used commercial component technologies are unable to provide solutions to the requirements of embedded systems as they require too much resources and they do not provide methods and tools for developing predictable and analyzable embedded systems.


To obtain the average probability that the animal was in a given voxel v at some arbitrary time during the time interval [tm, tm+1), given that the voxel v is within the allowed range in the zdimension, we calculate t xj +hx yi + hy z +h m+1 k z 1 Pm (v = V ) = f u t "t dzdydxdt .

xYZ (x, y, z | ( ), ( )) ## # # W m tm xj !h yi !hy zk !h x z if the voxel v is not in the allowed range in the zdimension, then Pv V( = ) = 0. m Next, we sum over all valid observed move steps by n!1 1 ( = ) = W P v V I m ( = ) ( ) .


Objects in Larson are merely allocated and deallocated, being accessed only once, immediately after their allocation.

the elimination of object headers enhances the spatial locality, especially at the page-level.


We use this approach in the quasi-threaded version of the interpreter.

this increases the cost of extending VM * at runtime if necessary.


They reported the following: 5 x A Parent Class has knowledge of its child  10 x Name Collision  1 x Incorrectly Defined Interface  14 x Missing Package Dependency  2 x Operation Signature Collision  12 x No activity to path or state  38 x Dangling Association  1 x Missing Start State  2 x Missing Stop State  6 x Dangling Class  5 x Illegal Abstract Inheritance  The first listed error might at first seem surprising.

when one considers the mixed skill level of modelers, it is not uncommon.


There are increasing e.orts for work.ows and systems to work with the MapReduce programming model and the Hadoop environment including our work on a higherlevel programming model for MapReduce within the Kepler Scienti.c Work.ow System.

to date, provenance of MapReduce-based work.ows and its e.ects on work.ow execution performance have not been studied in depth.


The most di.cult task when using our tool is identi fying interesting lexical chains, especially since a large number of chains can be found.

we learned that by examining the members of the chains, more in teresting chains are easily distinguished from uninter esting ones.


On the other hand, in Half-Life [2], game players make use of the reference state information from the server to correct the states of their local copies of the dynamic objects.

there is no control mechanism to guarantee that the actions performed at a player would be synchronized with those at other players.


Repetition of the scenarios with same testers would not have provided further insightful results about the experiment due to absence of any run-time factors (e.g., network latency, etc.).

such repetition would have introduced a bias due to the familiarity of the specialist tester with HealthWatcher due to the previous iterations.


For example, the three components in the national park example may support many addition events and operations.

for this particular composition scenario, only the ones mentioned in Listing 1 need to be declared.


Hence, if existing web services should be enabled to e.ciently transmit data using Flex-SwA, additional software development e.orts have to be made.

the requirement of e.cient data transmission between web services can be viewed as a cross-cutting concern and solved using aspect-oriented programming.


make the point that if contract conjunction & was commutative, then idempotence would be a simple consequence.

our lazy contracts demonstrate that commutativity of conjunction is not necessary for idempotence; we can have the latter without the former.


MOTIVATING EXAMPLE The extraction of coarse-grained task-level parallelism is a very e.cient technique to parallelize large independent blocks of an application such as function calls which can be executed concurrently.

those approaches lack the possibility to extractparallelismfromloops, especially from those with loop-carried dependencies.


the tiled matmul code with prefetch instructions inserted assuming contiguous streaming access patterns -B[k][j] is identi.ed as suitable for prefetching and prefetch instructions are inserted in the innermost loop as shown.

as a result of tiling, the access pattern is no longer contiguous -only J elements of array B are accessed contiguously, followed by another J elements from the next row of B.


3.3 Runtime Adaptation of Molded Debuggers In Section 3.2 we saw how to decide what debugger to open.

even if we start with the right molded debugger, during a debugging session we might reach a point where a di.erent molded debugger might be more suitable.


The resources of the hardware can directly be focused on the VM and each guest operating system can share services equally [3].

a disadvantage to this approach is the resources (i.e.


First, the target of the study was a system where exception handling is generic (not applicationspeci.c).

exception handling is an applicationspeci.c error recovery technique [1].


Thus, we have connected all indirect defs in a store constraint.

the rewrite rules in the next sub-section application of the .ow-insensitive rewrite rules lead to the addition of these spurious edges (as shown in the .gure).


Fifth, CDCF does not perform the address translation that we discussed in Section 6.1, which could render MSU s .rewall policy ine.ective for IBM s packets.

the addresstranslationprocedure couldbe easily added toCDCF.


Sometimes the alive mutant is equivalent to the correct program.

in general, this veri.cation is non-decidable.


MOTIVATION Design patterns are not widely used by software designers, due to lack of well-de.ned, systematic approaches for using them in the design process.

software systems developed using design patterns yield higher quality (like extendibility, reusability, .exibility, etc.)


Each of these activities is identified by a user wearing a special set of gloves that can read RFID tags on objects of interest.

this additional hardware can prove to be inhibiting and unnatural.


As from a preliminary planning concerning the strategies to be adopted with the impaired user focused on the PD practices, the therapists have the potential to aid in the choice and necessary adjustments.

only through practice and direct contact with the impaired user can the success of the choice and adjustments be verified.


p[position() = -i] (r5i) Figure 1: Syntactic sugars (N5) elegant way.

for instance q ::= true |false |(q) |not q |q and q |q or q |p .p we propose an extension of quali.er syntax so that minimal positional information can be expressed (i is the lexical representation for strictly positive integers), and also information on linearized content (s is the lexical representation for strings).


For example, MA can contain trigger that do not match any line of code of the system under test.

the code can implement additional behaviour that is not contained in MA or in MD because it is not relevant.


This architectural style enables high scalability toward ever-increasing data volume.

the service oriented architecture (SOA) emphasizes master data management (MDM) to enhance enterprise applications.


The reason is that with adaptive partitioning, the code is divided into only two or four regions for the BugBench applications, which under-performs a large 64K-entry table.

in gcc, the code was partitioned into sixty-four regions, which has fewer replacements and false-positives than a 64K table.


For instance, from a runtime performance perspective, using a Java snippet in a BPEL process to invoke an EJB is faster than wrapping the EJB in a Web service and then invoking it via an activity that calls the EJB Web service.

it is desirable to implement processes in a fashion that is compliant with the BPEL specification.


The drawbacks of the Inheritance and Visitor patterns are discussed in [5] and the author has claimed that TreeCC can be a better alternative to both of these patterns.

the essence of TreeCC is still aspect-oriented visitors with strongly typed properties.


[28], and finally Deprez and Lakhotia [9], all developed techniques that operate on execution traces to collect information about features.

none have proposed to create fine-grained components for reuse purpose.


As pointed out in chapter 3, one way of gathering information would be to include specific logic for this in the test processes.

such an approach would never yield complete results.


The second difference relates to the generation of next candidates.

in the proposed algorithm, next candidates are retrieved from a given set of program structures using a current sequence as a key.the apriori algorithm generates next candidates by combining all possible elements.


This may lead to improvements in power consumption.

our assumptions are based on a simple power model and disregarded the switching cost (both in power and time).


We did not have access to raw data necessary to compute the percentage of developers using the tagging feature, as in the original study.

unlike the former study, we were able to analyze the distribution of tags per type of work item or ticket.


Most of these techniques have been validated for soft real-time systems in the multimediaapplications domain.

our approach mostly focuses on hard real-time systems in the vehicular domain.


One might argue that, given ever increasing array sizes and loop iteration counts in array-intensive embedded applications, this data structure can be very large.

this is not the case, mainly because It iterates over the data blocks (i.e., not on individ ual array elements), and given that data blocks can be large, the number of different vectors taken on by It (which are determined by the block iterator bounds) is not very large.


This application scenario does not yet provide rigorously measurable numbers of increased reliability for a given performance level or increased general performance during runtime test execution.

it serves to validate the conceptual approach and to uncover flaws in the design and implementation of the run-time infrastructure.


As .gure 2 shows, the de.nition of thehigher-order function map_vec follows the same structurefor each of thefourfunctiondatatypes: 1 template  2 vector 3 map_vec(FUNCTION_DATATYPE f, vector x) { ... 5 } In allfour cases,thereisafunctiondatatypethatisparameterized over two types, and even the templateparameterlists are equal.

2 the generic solution provides a different datatype for every function(or function template).


For example, even though an application uses a binary tree, DDT may report it is a linked-list if all the left child pointers of the tree have NULL values due to a particular data insertion pattern.

our experimental analysis demonstrated no false identi.cations for this reason, and if a binary tree were behaving as a linked-list, this pathological behavior would be very useful for a developer to know about.


One important reason for basing the classi.cation on DBNs is the fact that DBNs can classify even when features are missing.

other types of classi.ers, like neural networks and decision trees, must be retrained whenever the feature set is changed.


Traditionally, a lot of effort was required for each of these ingredients.

there are now many tools that support the various aspects of DSL development.


If allocations such as pj are .xed throughout a program s execution, then this optimization problem only needs to be evaluated one time, when the processes begin execution.

this quickly becomes a complex problem with malleable processes where both the speedup function Sp and process allocations can e.ectively change over time.


As we can see from Figure 2 (CDF(v)=0.5), the end points are raised for values 0 and 1 due to the effects of clipping.

since clipping is signi.cant only as k approaches 1, wedo not expectitto adversely affect our results.


Our maincontributionis an approach for structuring optimizers based on equality saturation.

to make our approach effective, we have also designed the E-PEG representation.


We first tried to modify NFTL to implement our time-shift capability.

it is very difficult to support the lightweight time-shift capability in the NFTL framework, mainly due to its block mapping nature.


[9] are traditionally not from an software development paradigm environment.

when applying concepts from an agreed standard, in this case the Unified Modeling Language (UML) and object-orientation, care must be taken to adhere to the original intention thereof, even if it is applied in a different domain.


Indeed, a .rst obstacle to this proposal is the fact that co-change clusters do not cover the whole population of classes in a system.

we believe that they can be used as an alternative modular view during program comprehension tasks.


The connotations used in our example denote the intention of statements.

not all intentions align with distinct statements.


Since the runtime is only able to optimize for Closure objects created from lambda functions, creating a Closure object from a function or a functor object will behave as std::function and will not be optimized.

if several lambda functions are composed together though Closure objects, the runtime will fuse their IR and inline the calls.


There are two more potential sources of parallelism in f.First, in the original transformation involving f1 and f2, we did not distinguish between the resources x and y.

we need to gain access to y only if we take the .rst branch of the conditional.


VIA provides the programmer with a number of alternative mechanisms and a tight control on their man- agement.

selecting the optimal trade-off among them is a task requiring expert knowledge, which should be encapsulated into a medium-level software layer.


This mechanism enforced in GEAopt can greatly reduce error spikes and thus produces better performances than GEA.

as it can be seen from from Figure 4, the issue of having a great variability in the errors produced still exists.


MCRL, and prior simulation work in the Prelude language, generated a continuation and appropriate messages to perform a lightweight migration, but only at user-annotated procedure calls.

olden performed a relatively heavyweight thread migration (registers and top stack frame) at every remote memory access.


In fact, for the 4c1b1l64r con.guration, newOF obtains better results.

noRPS performs better in some loops that have a bigger impact on IPC and so performance is higher for NoRPS.


Many middleware dealt with one or more of these functional aspects and proposed middleware for composing, adapting, replacing, and/or transforming services.

these middleware are user centric as they obey to user or application needs and requests.


Due to our imprecise alias analysis, lock acquisitions can only weakly update this integer .eld, which means that two threads can 4 It is possible to run Boom on the integer benchmarks by .rst extracting Boolean programs with SatAbs.

satAbs is designed for sequential programs rather than concurrent ones, and the Boolean programs extracted by the version of SatAbs that was available at the time we ran our experiments produced poor results: the combined SatAbs+Boom procedure took 2 days and did not prove any assertions correct.


The root already has a child node for f. Adding the .eld f a third time, would just result in the same dependences as c has because of the aliasing situation.

k-limiting would cut o. the trees and miss the shaded nodes, hence dependences and slices would be incomplete.


Requirements R1 and R2 provide the base live model query viewer functionality.

requirements R3 and R4 are needed to present the features to the query developer in an understandable and easy-to-use way.


{A, B, C, D, E}, visits regions A, D, C, E, C, B in this order has level of unsafety 2 for the rule .1 never enter region C, with w(.1) = 1 and it has level of unsafety 3 for the rule .2 region D can only be visited after visiting region E. , where w(.2) = 3.

the level of unsafety of a trace visiting regions A, D, B is 0 for the former rule and remains 3 for the latter one.


The Boehm-Weisergarbage collector allows some tradeoffbetween space and time consumption by modifying the GC free space divisor variable, which changes the collection rate.Settingthisvariableto10(itsdefaultvalueis3) reduces heap overhead to an average of 48%, at the expense of increasing the runtime overhead to 14%.

these .gures cover a wide range of outcomes: grobner s space overhead drops to 77% and its runtime overhead increases to 175%, while parser s heap overhead and runtime are essentially unchanged.


INTRODUCTION In one of the main phrases attributed to Sun [3], we have found that the Java code can be written once and run anywhere.

this phrase is not totally correct because the Java platform implementations vary, among other factors, in accordance with the power of the hardware that will execute the applications.


However, we cannot implement this in a type-safe way using MJ or CTR.

consider the following attempt in MJ: class AddGetter extends X { [f] for ( F f : X.fields ) F get#f () { return super.f; } } AddGetter de.nes a method get#f() for each .eld f in type variable X. get#f denotes an identi.er that begins with the string get , followed by the identi.er matched by f.1 AddGetter is not modularly type safe we cannot guarantee that no matter what X is instantiated with, AddGetter is always well-typed!


The initial value for the internal state must also be set.

this information is not present in the OCL speci.cation, so it will be obtained from the SUT (which must be initialized before starting the test): initial_state()-> #ts { active = scheduler:get_active(), ready = scheduler:get_ready(), waiting = scheduler:get_waiting()}.


C2 messages are predominantly sent and received asynchronously [26].

in the course of developing the MVC, we have also implemented synchronous message passing for the purpose of supporting a wider range of OTS components.


Model validation by testing The complexity of a system-level model means that the modeling has to start as soon as the requirements for the current time-box have been established.

the validation of the model, aside from code review and sampling, cannot start until the system is ready for system testing.


When we recompile the libraries with SPS, we improve over simulated annealing.

to preserve a fair comparison between scheduler heuristics and annealed results, we exclude scheduling the libraries in these experiments.


22t mtrt is originally dual-threaded ray tracer.

since we currently cannot manage multiple-threaded programs, we changed it to be singlethreaded.


This has attracted more fundamental research into design decisions [20, 21].

the ability to capture design decisions and their relationship with NFRs in architecture descriptions and views is still lacking.


For some reason, list comprehensions seem to be more popular in lazy languages; for example they are found in Miranda and Haskell, but not in SML or Scheme.

they are present in Erlang and more recently have been added to Python, and there are plans to add them to Javascript as array comprehensions.


n This de.nition says that if two traces are indistinguishable at level L, then the resulting state should be equivalent at level L. In standard databases, traces only contain user queries.

in active databases, traces do not only contain the user queries but also the triggered events and actions.


It is clear that the COCOMO dataset has similar problems to the Desharnais dataset, so the same method of analysis is required.

the COCOMO dataset has additional problems because the values for the cost driver adjustment factors do not map exactly to the cost drivers adjustment factors used in the COCOMO model.


We could prevent multiple sources simultaneously choosing the same forwarder by coordinating allocation of forwarders to sources.

there are three disadvantages to this approach.


Such locality optimization may be achieved either with NUMA-aware data placement or with NUMA-aware thread placement to maximize the local data access.

doing this can potentially create contention on the cache hierarchy and memory controllers, which in turn limits application s scalability [2].


Thus, these are also the main possible limitations of this study.

some measures were taken to try to minimize these limitations.


As can be seen, when the component curves are similar (for ORFs 18srRnaa and 18srRnac), their corresponding 3d curve (Figure 3b shows similar changes as in the original signal.

when two dis-similar signals are composed (18srRnaa and 18srRnab) as in Figure 3d or pro.les 18srRnab and 18sr-Rnac as shown in Figure 3e, the sharp bends and twists are apparent in the 3d curve.


The previous example rule is what is called an exact match.

consumers may be interested in identifying cloud SLAs that approximately match their requirements (e.g., availability measures that are close to, but do not exactly meet what is needed).


The majority of the systems is written in C# and analyzing 5 systems in total is not a high number.

all 5 systems have been developed by different development organizations and the C#-systems are technically different (2 web, 1 rich client) and provide substantially different functionalities.


Hence, the Web enables a wider range of users to access previously inaccessible resources using various adaptive devices.

since the Web today fails to meet its potential for flexible data representation, it also raises new barriers that severely limit the accessibility of these resources.


Our queue algorithm is similar to the algorithms of Valois [20] and of Michael and Scott [13].


INTRODUCTION The number of cores per die on multicore processors increases with each processor generation.

many applications fail to scale with the increased hardware parallelism.


Their findings indicate that there is no value for the studied measures in which the fault-proneness changes from being steady to rapidly increasing.

these results are only valid for the measures used by the authors, and other models may potentially lead to different results.


Clean object I/O depends on updates to the world value for inter-object communication and to create and destroy objects dynamically at runtime.

yampa eschews all notions of a global, mutable external world .


While this example is concerned with behavioral properties, we will consider veri.cation from a structural viewpoint in the rest of this paper.

we will continue to focus on verifying each execution of a transformation instead of .nding general correctness proofs.


Also, pro.lingworks betterifitisexecuted before memoization, so the pro.ler component should be in between assertDump and memo.

assertDump requires access to the monadic layer with the memo table.


In this way, the proper exception handlers could be activated in all the relevant devices according to different user preferences.

the MoCA middleware does not support such scopes for context-aware error handling, which hinders the modularity of the system on the presence of exceptional contexts.


This modular approach makes the algorithm easier to design, understand and verify.

dealing with arbitrary mobility patterns while trying to maximize the time that links remain up, is still non-trivial.


Figure 3: Transparent Region The nested control structure design provides a solution to Problem 2 since connections that span the nesting hierarchy can now be displayed and edited.

this creates an accessibility problem when there are operations within a parent control that are obscured by large child control structures within the parent as shown in Figure 2.


This is because there is relatively little allocation, so the GC does not have much work to do.

with larger inputs (or equivalently, smaller heap sizes 1), there are sig ni.cant differences in performance between the various GC algo rithms.


Since our objective is to maximize the total system utility, it is preferable to set the duty cycle to Dmin for time slots where the utility per unit energy is the least.

we would also like the time slots with the highest Ps to operate at Dmax because of better efficiency of using energy directly from the energy source.


by using a GQM approach [14]) by first listing the violations that one would be most interested in, and secondly defining the data and measures that have to be collected to detect these violations.

the collection activities should have the goal of minimizing (or better, avoiding) any kind of interference with the studied process.


In Hbg, the capturerecapture estimations seem to be more accurate than both the subjective estimations.

no statistical difference can be observed (p=0.81).


If each confesses and accuse the other, both will go to prison for 10 years.

if one confesses and accuses the other, and the other does not confess, the one who has collaborated with the police will go free, while the other will go to prison for 20 years on the maximum charge.


As the initial location of all nodes is known, the system can potentially track the cells covered by nodes keeping track of the commanded motion of the MAV nodes.

mAV nodes have low-quality inertial sensors and imperfect actuators.


Instanceof technique has the best performance for the .at hierarchy.

for the deep one, its performance strongly decrease when the number of visit increases; indeed, it seems its implementation relies on some caching techniques.


Note that a schedule with too few orderings can lead to failing tests that are false positives.

a schedule with too many orderings may lead to false negatives whereby a bug is missed because the schedule is over-constraining the test execution.


Concerns that the results are not generalizable to projects where the implementation and speci.cation languages differ may therefore be raised.

the interfaces of the system, that the system tests interacted with, are internet standard protocols, layered over TCP/IP.


local instances, named instances), and they discuss some of the same examples as we do in section 5.

they make some different choices than we do: their constraints remain limited to arguments whose type was de.ned as a type class instance and their resolution is similar to Haskell s. They do not fully unify type classes with their associated record types, so that some of the advantages we can offer are not available (e.g.


Furthermore, pointer assignments, apart from initializations to some start element of the array to be traversed, are not permitted.

our algorithm can handle non-rectangular loops, more general pointer initializations, and the most common types of data dependent and independent pointer updates.


For all the advantages presented above, it is easily understood that CRM tools have become in the last decade one of the most important systems used by companies.

they carry an undeniable reality that is the low rates of success in its implementation.


In addition, it also helps application developers to design and optimize applications even before the target machine is available.

accurate performance prediction of parallel applications1 is dif.cult because the execution time of large parallel applications is determined by sequential computation time in each process, the communication time and their convolution.


The existing OCaml does not have a complete formal de.nition (type system or operational semantics) and we have not produced one for Hash-Caml.

we are partly guided by our earlier formal work, especially the full semantics de.ned for Acute [32].


Unlike WIISARD, CodeBlue employed an ad hoc multicast routing protocol based on ADMR [13], requiring sensor nodes to maintain routing tables and link quality state throughout the network.

the CodeBlue disaster drill study [12] demonstrated the challenges of using such complex, stateful protocols in highly dynamic environments with high mobility and poor link quality the focus of this paper is to assess the feasibility of using DTN protocols to support reliable communication in emergency responses when minimal infrastructure is deployed.


This is also the case with the Caesar implementation discussed so far.

caesar also supports reusable features encoded in their own model and ontology and provides language constructs to express combinations of these di.erent models.


In non-personalized UIs, these facilities would be used by the application developers.

the personalized history-based UIs require the end-user to incur this overhead.


However, the clause relevance originates from the shared environment entities of the scenario clauses.

the environment entities involved in same scenario clause are also related.


ICAF Reuse Since the main difficulty in adaptation systems is the implementation of the adaptation policy, the ICAF considers that this policy should take into account the adaptation rules and the information of the adaptation environment.

there are various ways of realizing this decision process, including the implementation of a procedural language algorithm.


Rather, it stores only the last write and read to any given location.

during MIME execution, there exist short periods where the most recent write or read is actually stored on the MIME staging page.


This guides the server obliviously through either the .nished or the active set, as follows: If the current level contains the sought-after item, the server s work is in fact done.

the server cannot be made aware of this.


We have presented the various solution strategies, and how they are implemented in C++.

the extendibility of C++, and the sequential model of execution inherent in C++, lead to simulation and structural semantic gaps when composing models together.


If a designer knows that the sorting function will be implemented in software, the designer may describe the function using the Quicksort algorithm [5].

if the designer knows the function will be implemented in hardware, the designer may describe the function using Mergesort, since it can be parallelized very nicely and forms the basis of many hardware-based sorting approaches [5][17][19].


The address translation then becomes a simple displacement with a scaling factor that depends on the relative sizes of the spaces.

the large reserved address space often con.icts with the memory layout requirements imposed by operating systems or applications, which constrains the deployment of DMS.


These extensions are adaptive, in the sense that first an initial sample is selected and checked and then additional executions are selected in the vicinity of any failures found in the initial sample.

unlike the form of adaptive sampling described in Section 3.5, the new methods iterate this process if additional failures are found.


From the perspective of design evolution, one single anonymous class does not have too many effects on software design, since, according to the Java specification, anonymous classes are mainly used to avoid creating a bunch of simple subclasses or implementations of interfaces.

as a whole, they may be indicators of designstyle preferences and development habits.


Cooltown essentially aims to support World Wide Web presence for people, places and things.

we use shared spatial and informational environments, supporting sharing of concrete or literal spatial experiences through to abstract or symbolic informational ones.


On the other hand, model checking is usually performed on coverage space is just S. Deep-hidden design bugs usually creep in on transitions and state-based coverage method is not su.cient to clear such bugs.

the transition coverage space is S ×I,where I is the set of in puts.


2.1.1 Load-Store Consistency (LSC) We saw before that Emscripten s memory usage allocates the usual number of bytes on the stack for variables (4 bytes for a 32-bit integer, etc.).

we only wrote values into the .rst location, which appeared odd.


A distributed registration system was introduced in [13] that regulated the number of identities a speci.c IP address could obtain.

it is possible for adversaries to control multiple IP addresses through spoo.ng or pre.x hijacking attacks.


4.2 Anonymity Considerations At .rst blush, it may appear that Tortoise allows eavesdroppers to distinguish between encrypted traf.c that belongs to a .lesharer and that which belongs to a web client by measuring the monitored connection s throughput.

upon inspection, this tactic will be less effective than anticipated.


Existing race detectors would conclude the execution shown in Figure 1(a) is erroneous because of the data races.

the data races do not indicate an erroneous MySQL execution; i.e., existing race detectors would report false positives.


The design of the tests ensures the correctness of the results.

simple sanity checks are also performed here.


They share the idea of searching for alternative architectural models where the problems, (possibly) emerged in the performance analysis step, are removed.

moving back to the architectural model to search for alternatives may introduce high complexity in the whole process, due to the (possibly large) number of forth and back transfers between software architecture and performance model, before .nding an acceptable alternative.


Usually the pilot observes that the aircraft is within 0.2nm of the current waypoint and updates the waypoint to the next one.

the aircraft still needs to descend to the altitude suggested by the previous waypoint.


Having removed std:: in front of sort in the code from Figure 3, the compiler still looks up sort in the std namespace, because the type of at least one argument is from std.

compilation fails in parallel mode because associated namespaces are not looked up.


MILP Formulation MILP formulations have long been proposed for modeling the heterogeneous multiprocessor task assignment and scheduling problem [8].

energy minimization has often been the main objective.


Both provide the possibility of scripting visualizations and having nested graphs.

because they are totally separated from the model, the possibility of interacting with the model is inexistent.


More general trace-optimizations of hierarchically layered virtual machines (VMs) have been described recently [7, 27, 29].

while our approach is based on compilation at all levels (JavaScript to CIL, and CIL to machine code), these approaches are based on interpreters at all levels.


An EPU is called producer when it does not consume any input stream in order to produce the output stream.

an EPU is called consumer if there are no other EPUs consuming its output stream.


al [12] utilize multiple threads in a shared-memory parallel environment, and overlap computation and communication between different computing cores.

we overlap the computation of one core with the communication of the same core.


In this case, f10 is a proper failing case that developers can base debugging on.

such proper cases cannot be found under T-Proximity, because there is no way one can judge whether a failing trace will suggest the same fault predicates as t. As an alterative, people may wonder whether a randomly-chosen failing case would similarly work.


Note thatbid values and arrival rates arelargerintheloaded regimethan thelight regime.

jobs appear tobeless urgentduring the loadedregime.


Size and scalability are, of course, also important issues: Language features may become much more influential when dealing with large systems.

we restricted the size of the systems used for a couple of reasons.


(ab) ".f@t1 The rules for apply look much like the rules for scale in the old speci.cation.

there is an additional rule explaining the composition of transformations in terms of composition of its components.


The SWITCH actor reads one token from the control input port,and depending on whetherthe value of the controltoken is true or false,routes the input either to theoutput portmarked T,or to the output marked F. It also produces anabsenttoken tothe other output port.

itisnot guaranteed whether the execution of a BDF model is completedin a finitetime or whetherit requires a T T F2 F2 F1 Fmux F6 F1 F4 F1 F3 F3 SWITCH F2 SELECT F4 bounded memory [9].In Fig.


If these values match within some tolerance given by the constraint then it advises no changes.

note that in Figure 5 that the sum would be 3 and the triangle s value is 5.


Formal, machine-checkable proof is widely agreed to provide the highest possible standard of evidence for believing such a system is correct.

all extant theorem proving systems that have been employed in metatheory veri.cation1 have high learning curves, and using them to verify the properties of a nontrivial system requires a great deal of effort even after the learning curve has been surmounted, because inductive theorem-proving is currently a brain-bound, not CPU-bound, process.


This work is related to ours, since both works are interested in pattern languages for the enterprise domain, recognizing that the notions of patterns and pattern languages should be applied to the enterprise domain.

eOPL is an ontology pattern language, while [18] focus on conventional pattern languages.


# if KERNEL VERSION > 2.6.32 pinned vm BIGINT FROM pinned vm, # endif  3.7.3 When things can go wrong The virtual tables we de.ned for accessing Linux kernel s data structures are correct, use the right synchronization protocols, and can be safely combined together in queries.

inappropriate virtual table de.nitions and ordering of virtual tables in queries might result in a kernel crash.


As we originally engineered the eBook, use of the hyperref package s run command [15] in the LATEXsource .le resulted in a pdf output that ran the codes directly.

abode apparently considered this a security risk and recent updates to their pdf readers forbid code execution.


Again, at 25Tx, the MMUs of FR and default are higher than that of HA.

as the workload increases to 40Tx, the MMUs of FR and default become lower than that of HA.


These correspond to patterns like those outlined in Figures 3 and 4, which illustrate how the intricate interplay between not-may summaries and must summaries can prevent SMASH from getting stuck .

sMASH does timeout on 1 check for the driver 1394diag and the reason for this (as well as all the 9 time-outs in Table 1) is that it is unable to discover the right invariant to prove the property.


Intuitively, HA M P I constructs an SMT query by unrolling the regular expression match computation over the symbolic string input.

to be practical, query construction must avoid unrolling obviously false paths (in our example, the .rst alternative can never match, as every string from the template starts with a, not y), and capture sharing (in our example, the substring match for cd, the last two characters in the string template, is the same whether the outermost Kleene star in the second alternative is repeated once or twice).


Thus, for the scenario that we used to perform the validation, our approach would not pay for itself, since the economy of 23,8 hours is less than the time needed to con.gure the approach, which was 38 hours.

it is important to observe that this result is not conclusive for a long term running experiment.


Some care must be taken to ensure that these do not con.ict with the proper pattern; we thus add additional constraints to the wildcards (see Figure 7).

the junk fragments can also contain statements that match barrier patterns and thus require annotations as well.


This is because the lru(n) techniques found all faults well before the 50 testing session cutoff.

the minimization, safe-random(n) and random(n) techniques allowed Table-2: Median, Average and Standard Deviation of Fault Age by RTS Technique (Model-l).


In practice this can be useful as ambiguity serves as a focal point for discussion between team members and moves the design process forward [9, p.117].

when describing pervasive computing systems, this ambiguity is a barrier to correct implementation of the intended system behavior.


For general task system scheduled with FP on a multiprocessor platform, an upper bound on the schedulable uti `´ m lization is + 1 , as shown in [3].

no known 2 3 priority assignment allows a schedulable utilization equal to the above upper bound and no exact schedulability test is knownfor such systems.


Types for .t O Choosing Types There are myriad type systems we could imagine for type-checking .t , given these examples and O many others.

our examples do highlight an important feature of the dynamic semantics of .t that can inform O our design of a type language.


In doing so, these researchers provided a system that allowed re-targeting through the addition and removal of components.

these systems did not have a synthesis or scaling infrastructure.


Therefore, most programming languages support source-code comments.

most languages and programming environments restrict comments to plain text; text formating is not possible.


Overall, the majority of time is spent executing traces.

for bisort and tsp, a signi.cant percentage of execution is wasted.


On the one hand, there are strategies based on data warehousing techniques, centralizing content from resources.

there are solutions involving integrated access to distributed data sources, federating available content.


Indeed, much of the other existing work on SBSE has also tended to consider software engineering problems as single ob jective optimization problems.

a recent trend appears to be developing, in which multiple objectives are considered.


Throughput is the rate of making progress.

this is dif.cult to measure directly without instrumenting the VM.


IBM has also used the term to denote template models with associated UML profiles.

in this work, the term is related to parameterized transformation processes.


We are currently evaluating a number of strategies for coping with this problem.

experience suggests that this compatible representation is useful even in the absence of such mechanisms.


In the world of semantics, these are sometimes called pre-methods [1]; Cook and Palsberg [7] call them generators.

an instance needs versions of its methods that are ready for execution, in these versions self is already bound.


For Google Maps, we could implement a generic adapter which would work with many Google-based AJAX components.

we chose to implement a wrapper for it instead, for two reasons.


It also has k children, with the subtrees rooted at them being Tp1(¯x1),...,Tpk(¯xk).

even for a pattern p(¯x) compatible with a DTD D,we may not be able to de.ne its inlining as the inlining of Tp(¯x),because Tp(¯x) need not conform to D. For example, if a DTD has a rule r .


Mobile phone based communication protocols allow people to access to information and services nearly from everywhere.

these capabilities can be easily accessed thanks to the general availability of powerful and a.ordable devices such as PDAs, smartphones and other application-oriented devices, that can be embedded in daily used objects, such as cars, trains, and even refrigerators.


Parsing Consider arithmetic expressions in the program: let x = "2" in let y = "3 -1" in let z = x + " * " + y in eval z  The result will be 2 * 3 - 1, which is 5.

we might be tempted to transform this to: let x = box 2 in let y = box (3 - 1) in let z = box ((unbox x) * (unbox y)) in run z  the evaled expression then becomes 2 * (3 - 1), which is 4.


Model-Driven Web Engineering Copyright 2009 ACM 978-1-60558-398-3/09/06 $10.00.

what happens when requirements are already defined?.


Outlook itself provides a simple voting mechanism (yes/no button in e-mail).

neither of these systems has the flexibility of SHOCK in designing forms and collecting data.


Therefore, we did expect implementers to have also noticed them.

the fact that we did a formal specification led us to notice exhaustively the underspecifications.


After this development, the music industry tried to sue individual users of P2P applications for copyright infringements, without much success.

a recent study [9] has shown some evidence that intervention by the music industry involving the dissemination of polluted content on P2P networks has been relatively successful.


Take Figure 1(a) as an example, assume op is unknown (denoted as 1 bx), logic simulation will generate inaccurate reachability report due to Xpessimism [4].

symbolic simulation replaces sum, a, b, op with symbols ssum, sa, sb, sop, respectively.


The larger your class the harder it is to reach everyone--especially with carefully constructed arguments that require strict attention from the students.

a really skilled instructor won't give all the possible explanations, hoping to cover everyone.


(start (tok end) ...) (end (tok) ...) (new-mode any/c))) #:tester #) contract from: (function less-broken-lexer) blaming multiple parties: (function pick-a-lexer) (function less-broken-lexer) if pick-a-lexer were to specify lexer/c as its co-domain, only less-broken-lexer would have been blamed but at the cost of checking the same contract twice: (define/contract (pick-a-lexer b) (-> boolean?


RL has worked on this problem under the name credit assignment [13].

these approaches do not consider program structure as those algorithms do not have the user s program available in a form they can use.


It was stressed by this project manager that cross-cultural training can only help understanding of cross-cultural differences at a high level.

it is important to understand and pay attention to nuances in practice.


As the application software is becoming more modular, there tend to be more and more function calls for sets of operations.

if the loop has function calls inside, it will be disquali.ed for the CGRA mapping due to software pipelining exploration limitations in SRP.


Virtual machines already pro.le the application and maintain a rough breakdown of the amount of time spent in the hot methods [1, 11, 21]; this information could be written to the pro.le repository, and fed into the program the next time it executes.

most programs have multiple inputs, and these inputs can drastically a.ect the running time of the program, as well as the distribution of time spent in the various methods of the program.


Network usage is a less important property that can also a.ect the system throughput.

because network usage not directly related with the algorithm for creating and looking up surrogate keys, it was assumed to be a nuisance variable.


With the discovered one, it predicts two metrics (application runtime and queue wait time) using instance-based learning techniques.

the main focus of the [6] do not lie on resource managements, but only runtime predictions.


The research objectives are on one hand in studying in situ measurements as an extension of existing remote monitoring implementations and on the other hand in next generation GIS services in low-rate networks based on interoperable communication.

this research does not cover SensorML features such as sensor discovery and run time replacement.


multiplication, that distributes over the reduction operator (summation).

to distribute a subexpression outside any reduction, we need to ensure that it has a constant value at all the points that map to the same answer.


It is worth mentioning that in our above example external web services are being invoked by a client, so little remedial action available to the client other than selecting another service.

the AuDeQAV approach could also be used by service providers as part of a feedback loop to control provisioning levels for services in response to detected violations wrt their QoS requirements.


In spite of these requirements, if we could easily layer Place Lab over an existing DHT, that would go a long way toward simplifying implementation.

this would not simplify operation of the service; Place Lab s operators would still have to deploy and manage a full-.edged DHT which is arguably not an easy task.


INTRODUCTION Cloud computing [3], with its pay-as-you-go pricing model, provides an attractive environment to provision elastic services as the running cost of such services becomes proportional to the amount of resources needed to handle the current workload.

sharing the physical resources among Virtual Machines (VMs) running di.erent applications makes it challenging to model and predict the performance of the VMs [5].


This corresponds to an instance of exploitation of TLP.

loops with dependences between its iterations (referred to as Non-DOALL loops in the rest of the paper) can be parallelized either speculatively or with explicit synchronization.


A spy has only two technical requirements (§3.2): it must eventually detect crashes of the layer that it is monitoring (and even then, Falcon handles the case that the spy fails in this charge, per §3.4), and it must be reliable, meaning that its LAYER DOWN answers are accurate.

in practice, a spy should be more ambitious; it should provide guarantees that are broader than the letter of its contract implies.


The Collective allows for the exchange of information between middleware platforms within a large-scale deployment.

many open research issues exist with the handling of this information.


This may not be the case in some systems, where a page is .rst requested without explicitly claiming the request type, and it is read or updated some time later.

most DBMSs use the classical pin-use-unpin (or .x-use-un.x) protocol [10] for pages requests.


More precisely, if a developer authored more than 5% of commits to a module, she is considered to be a major contributor of that module.

a developer who authored less than 5% of commits to a module is considered to be a minor contributor.


Introduction Modern mainstream programming languages incorporate advances in memory safety, type systems, meta-programming and modularity.

the sequential control in widely used systems remains largely unchanged compared to some of the earliest imperative and * Philippe Suter was supported by the Swiss National Science Foundation Grant 200021 120433.


A couple of sites though such as amazon.com and recipecenter.com had higher con.dence scores due to the presence of multiple sections that could be erroneously identi.ed using the same set of patterns.

the average con.dence score was less than 20% with seventeen web clips displaying alert messages within the validity assessment bar asking users to recreate their web clips.


When a design should be selected from a number of alternatives, this is mostly done by comparing the quality attributes that are considered relevant at the current point in time.

this evaluation can only be done accurately after a software system has been implemented.


Of course, the generated HTML UIs look different as we did not store static content (text/graphics) and the original stylesheets during the extraction.

this could easily be added (by adding model elements for static content) if desired.


While in large part successful, these solutions have so far been focusing on scheduling and managing computation and storage resources, while mostly ignoring network resources.

managing and optimizing network activity is critical for improving job performance.


Checking the current format of the ob ject at each .eld access incurs some performance overhead.

it should be noted that the level of each .eld is statically determined before the execution starts.


The putShadow method of an AccessEvent e performs an atomic-compare-and-swap operation: if the current value in the shadow location is the same as e.shadow, then this method replaces the shadow location with its argument and returns true.

if the shadow location is not the same as e.shadow (meaning that it was changed by another thread after the event object e was initialized), then the method fails and returns false.


The process for model development and qualification is therefore greatly shortened.

a major bottleneck for the mainstream use of model compiler technologies is that the efficiency of automatically generated model is not as good as of manually written device model.


As expected, the execution time .rst decreases with increasing unroll factors.

no further improvements in execution times are observed if the unroll factor is increased beyond a threshold.


For example, a boolean attribute of a CIO can easily be specified as a SFBool field in VRML97 or X3D.

whereas the colour of an element is specified as an attribute whose type is string in USIXML, the type of that attribute in the toolkit should be SFColor, which is the most appropriate to describe that property in VRML97 and X3D.


Informally, whenever several transitions are possible from one program state, they commute: they may be applied in any order and all permutations will result in the same .nal state.

due to the size of the semantics, we do not have a formal proof.


Our simpler speci.cations also come with fewer restrictions: SharC and Shoal require some contortions to satisfy the unique pointer constraint and thus change the sharing strategy.

our ownership policies may be changed freely, as may be the means employed by the program to enforce them.


The SAME4HPC architecture also adopts many of these industry standard practices as described in the above environments such as OpenStack, Ubuntu, and includes high-performance, mobileready JavaScript frameworks such as OpenLayers 3 and ExtJS 5.

this architecture also satisfies the above needs by applying various collections of next-generation technologies and emerging standards to deliver scalable and mobile environment for HPC including Node.js, PostgreSQL 9.4, ECMAScript 6 (ES6) - next version of JavaScript standard, and HTML5.


The problem is that, in our scenario, disconnections are the norm 1In theory, it is not possible to send a message to a peer that has never been reachable in the past, since there can be no entry present in the registry.

to overcome this possible limitation, we provide a primitive through which information can be added to the registry without using the normal channels.


while addressingquestions such as what topics the past research has focused on,they missed other important questions such as the main researchchallenges in domain testing and application testing and how suchchallenges have been resolved in each approach.


Consumers can safely asynchronously execute work items put into analyzedSet.

theorem 1 has nothing to say about livelocks, in which a program reduces in.nitely.


When looking at Conditional Compilation, only a single configuration file is used to configure a product (Q13).

at larger granularities a Makefile is also used for the composition of alternative modules or directories, so that at least these two artifacts are required in the discussed system, which is not seen as a pressing problem.


In addition, there is widespread agreement in the literature that the strategic oversight of IOP ( IOP governance ) is a key factor for achieving IOP in Government Information Networks [20-25].

there is not sufficient research about the role of the impacts for IOP governance, thus requiring further investigation.


Step 1 -Data acquisition and pre-processing: Using a structure-light based 3D camera system, we can capture the high resolution 3D expressions in real time.

the captured raw data usually contains noise, holes and other artifacts.


RELATED WORK Several strategies have been proposed to derive formal models from the full scope of natural language (English), including conceptual dependencies [16] and conceptual graphs or semantic networks [18].

processing the full scope of natural language is excessive for analyzing privacy legislation.


Basic types and strings are directly supported by the open compiler.

in order to differentiate class types from CORBA object references we need a more sophisticated approach.


Furthermore, this approach is suggested by the authors as suitable for large legacy databases with little or no semantic advice available [29].

this method is not entirely applicable, mainly due to its focus on relational database systems, as well as due to the large effort required to reverse engineer the database structure, especially since reverse engineering of Mnesia databases is not a central issue for this project.


Indeed, parameterized modules such as ML functors express parametric dependencies and they are well-known to be useful.

existing deployment frameworks almost exclusively disregard this form of dependency.


The sampling technique used in QVM is objectcentric, in that, all the events to a sampled object s instance are pro.led.

our samplers are based on cold-region hypothesis.