Much work has been done and many solutions have been proposed based on Service Oriented Architecture (SoA) and using varying technologies like business process management, AI planning, semantic and ontology, contextaware, etc.

most of the currently proposed frameworks or systems for composing service are static or semiautomatic; even some famous usercentric solutions like YahooPipe [5], MashMaker [6], and MARGMASH [7] still need human intervention for completing a service creation.


In our experiments, we have found that the event trace of only the most recent events nonetheless retained enough useful information to assist in locating the bug.

more detailed studies need to be performed to determine how to most ef.ciently log the most useful events.


Second, the demanddriven model facilitates recursive partitioning of the compute resources and therefore, lends itself to elegant scheduling.

current solutions for task parallelism do not support parallelization of the demand-driven execution of DAGs.


The coupling and cohesion metrics use a form of directed relations, based on which their value is calculated.

this is not the case with complexity measures.


They can formalize industrial patterns and practices while increasing the scalability of veri.cation, because input programs are written at a higher level of abstraction.

engineering new DSLs with custom veri.cation is a non-trivial task in its own right, and usually requires programming language, formal methods, and automated theorem proving expertise.


The browser used for the tests is Mozilla Firefox 3, except for kb since the smltojs version made Firefox completely hang for some unknown reason, so we used Opera 9.5. test ocamlc JS ocamljs smltojs O Browser ack 160ms 1.6s 5s 3s 1m20s kb 1s - fails10 > 1h30 9m15s queens 75ms fails11 2s 3s 21s nucleic 800ms - 2m8s 32s 5m15s If we look at the raw data, the performance is poor.

we chose these examples because they show three common cases and allow us to put these bad results into perspective: ack is a computation intensive task, with a unique recursive function over integers, so is a function quite easily optimizable by the JavaScript interpreters (integers unboxing, etc.


The application team recently widened key integer variables to 64 bit to support matrix indices that grow with scale.

they overlooked the de.nition of Table 3: STAT sample and merge times for a 256 task job in seconds Trace Type Sample Time Merge Time Function Name Only Function Name and Line Number 0.74 6.57 .004 .004 this function, causing the type coercion.


Two of them match the user request and the client pro.le (the MapProviderA and the MapProviderB).

the discovery platform becomes aware that the MapProviderA is overloaded thus returns to the client the binding to the MapProviderB.


On all machines, operations such as replicates would need to process both the sources and starts .eld instead of touching the singular segmap.

indexing operations would not need to dereference the segmap, or maintain invariant 6, but as as we will see in §6 this can often be avoided anyway.


Sensor networks have been used in several data gathering applications, including environmental [9, 38], habitat [18, 32], and structural monitoring [12, 41].

most prior work focuses on outdoor deployments, in which sensors are sparsely deployed and power is the primary concern.


The algorithm approximates the performance of GA and ACS algorithms.

considering the simplicity of the basic PSO algorithm the performance achieved is impressive.


They apply their technique in di.erent examples of distributed system architecturesincludingEnterpriseJavaBeans andMicrosoft Enterprise Services for .NET.

their approach does not provide a .exible access control mechanism because updating the rules implies generating the security mechanisms again.


Our optimizations must work on multi-dimensional arrays represented in this way; restricting them to work only on one-dimensional arrays would severely limit the programs to which they can be applied.

in an array of arrays, subarrays need not be of uniform length, and it is even possible for subarrays to alias each other.


It can be implemented using continuations, thus: type IO a = FailCont -> SuccCont a -> Behaviour  (The reader may like to write implementations of return, (>>=), catch and so on, using this de.nition of IO.)

it is also possible to implement the IO monad in a completely different style, without any recourse to a stream of requests and responses.


We further narrowed the scope of potentially faulty code in [3] by, for the .rst time, using forward dynamic slices of failure-inducing input difference.

in this paper, we have shown that bidirectional dynamic slices of critical predicates can further narrow the search for faulty code.


cXprop is far less con.gurable, providing only pluggable abstract domains.

as far as we know, cXprop already supports a richer variety of value-propagation domains and concurrency models than does PAG.


2.3 Overall Grid Service Reliability The grid service reliability measures the reliability of one service executed in the grid.

for the grid computing system, it is important to obtain a global reliability measure that describes how reliable the grid system is for a given distribution of services and resources.


Conversely, if the network connectivity is at least 2F +1,then there exists strategies for the normal nodes to use that ensure consensus is reached [20, 23, 29].

these methods either require that normal nodes have at least some nonlocal information or assume that the network is complete, i.e., all-to-all communication or sensing [1, 3, 8, 15, 16].


Since net metering was not available, GreenSwitch consumed energy from the batteries when solar energy was not enough to power the load.

greenSwitch did not delay the entire workload until solar energy was available.


If we apply push schedule to the entire stream graph, it makes a signi.cant di.erence from single appear ance schedule in bu.er space requirement as shown in [16].

when we target 16 cores, the application is already partitioned into 16 pieces; and it does not make a big di.erence using either scheduling method on each small piece.


A Qualitative Assessment of the Efficacy of UML Diagrams as a Form of Graphical Documentation in Aiding Program Understanding Scott Tilley Department of Computer Sciences Florida Institute of Technology stilley@cs.fit.edu  ABSTRACT Graphical documentation is often characterized as an effective aid in program understanding.

it is an open question exactly which types of graphical documentation are most suitable for which types of program understanding tasks (and in which specific usage contexts).


Third, Address Space Layout Randomization [4, 5, 18] (ASLR) is a probabilistic protection that randomizes the locations of code, stack, heap, and other data.

return Oriented Programming [20] (ROP) and Jump Oriented Programming [7] (JOP) are two modern attack techniques that no longer rely on injected executable code but reuse existing application code.


Refactorings are only a tiny fraction of the changes that programmers make.

they illustrate a general principle: by focusing on a narrow class of change, it is possible to make those changes much more effectively.


Vec a (Succ n) We declare two empty datatypes, Zero and Succ, to serve as type-level values , and use a generalized algebraic datatype (GADT) [24] to de.ne a type Vec whose .rst argument is the type of its elements and whose second argument is a type-level natural number re.ecting the length of its values.

for a language like Haskell with a strong, static type system, this example is rather embarrassing: it is untyped!


x abs(x|y1,true) .-x the transformation is not sound for arbitrary CTRSs.


For recall, all code elements could be assigned the type Object; for precision, similar hacks are conceivable.

such optimisations would make the respective other metric drop to almost zero.


Any test cases that cover the dangerous arcs must be rerun, and these test cases should be selected safely for regression testing because their behavior may be changed during maintenance and evolution phases.

according to the algorithm developed by Harrold et al.


As in an exokernel system, each application is linked with a library operating system (libOS).

unlike in exokernel systems, the libOS focuses only on performance-critical services; other services are obtained from the controller through the gateway.


The literature demonstrates how applications are implemented for multithreaded execution, and with lower clock frequency achieve the same performance as their single-threaded versions with less energy consumed.

this approach is only valid as long as the increase in static power when enabling cores is less than the decrease in dynamic power when reducing the clock frequency.


This approach was abandoned because it ignored somepractical considerations mainly that without actually executing those codepaths, onewould missbugsintroduced by theC statements(e.g., a segmentation fault).

it is worth recording the scheduling-related ideas in this approach.


The overhead for shifting threads among the cores for thread packing is potentially higher (reaching millisecond range in some cases).

these effects are automatically factored into our delay estimation in the experiments, which nevertheless show signi.cant improvement in performance, power, and energy.


In particular, the identification of relevant Categories and of the Choices to be tested is left to the tester s judgment, and this is natural.

lexical and syntactical analyzers for natural language requirements could be used to extract useful information to identify the relevant Categories.


The complete system slows down execution of SPEC JVM98 by 4.5x on a 4-way machine.

we compute a relative speedup of 1.3x by comparing run times to a control experiment that does not allow successful speculation to commit but otherwise incurs the same overheads.


Such stimuli has the bene.t of being realistic.

this realism is also the main problem with this approach.


If the player wants to build their .nances more slowly, but with less e.ort, they can invest in watermelons or pineapples.

note that both watermelons and pineapples produce coins in the same ratio.


To achieve better mapping, it is important that the pivots for each dimension be separated as much as possible.

.nding a pair of objects far apart can be the most time consuming part of the FastMap algorithm.


Thus, their work is complementary to ours.

they do not perform analyses of the evolution leading to changes in variability.


class Data Size a => Size a where gsize :: a -> Int data Exists :: * where Ex :: a -> Exists instance Size Exists where --Does not type check gsize (Ex (ex :: b))=1+ gsize ex Here, in order to de.ne an instance of Size for Exists, we need to call gsize on the existentially packaged value ex.However, calling gsize requires that there exist an instance of Size for type b.

because b could be anything there is no way of determining whether such an instance exists.


Nongovernmental organizations (NGOs), with their history of activism and involvement in the local development programs, are often the most trustworthy citizens to broker ICT4D research, but rarely incorporate formal informed consent processes into their interactions with communities.

by leveraging the transitive rapport established with the NGO, researchers may better engage in discussions about the iterative, formative nature of ICT4D research with the target community.


CONCLUSION The shift and reset operators attract many researchers interest because of its expressiveness and rigorous semantics via CPS-translation.

there are theoretically not pleasant features in these operators.


We thus remove all duplicates from each list of statements.

we retain the visit order in our representation (see Crossover description below).


But certainly there was a big movement for Web standards during the last years.

the will of authors to adhere to Web standards is usually not su.cient standards are complex and there are just few people around the world who know all details of (X)HTML language from a top of their head.


4.1 What to Log How to trace a message in a distributed system has been discussed before.

with previous methods, one only knows the routing information of the message (from the message header).


* Service ; }} erties, such as all provided interfaces, all required interfaces, or all ports attached to a particular role.


This includes both randomly generating inputs and creating and evaluating condition trees for model transitions.

none of the aforementioned approaches facilitates the generation of realistic and meaningful input stimuli, i.e.


Indeed, some of them had a fear from the machine to the point that they were reluctant even to touch the kiosk.

they were able to do it after seeing the assistant doing it.


In asymmetric AOP languages such as AspectJ, primary concerns and crosscutting concerns are modularized as classes and aspects, respectively.

a concern considered primary might be crosscutting in other situations.


Since we cannot guarantee the same message m1 will be received again, we cannot guarantee m2 will be reconstructed and resent by p1 .


of Computer Science University of Maryland College Park, MD 20742  hollings@cs.umd.edu ABSTRACT Detailed cache simulation can be useful to both system developers and application writers to understand an application s performance.

measuring long running programs can be extremely slow.


Usually, after parent selection, individuals are crossed in order.

if we need a di.erent mechanism for mating (for example, using more than two parents, or parent selected several times) a duplication of e.ort is needed.


Upon closer inspection, this is not a conflict because java class C is within both footprints and thus would provide a unique footprint for {c3}.

the input {c5,c6} isAtLeast {C,J,S} defines java class C to be about either c5 or c6.


OCaml partially solves this problem by automatically adding a type equation pointing from the internal de.nition to the external de.nition, when typechecking the body of a recursive module.

in OCaml, a type de.nition has at most one type equation and therefore this approach is only applicable to datatype de.nitions, but not to type abbreviations or datatype de.nitions with equations.


The main goal for abstraction is given as simpli.cation because generalising abstraction is not discussed in that paper.

it is also stressed that abstraction (especially the automatically resolvable one) tends to be highly domain-speci.c.


Of course, this example is contrived in many ways: the number of runs and components is small, no latent errors have occurred, no routine in the program has multiple call sites, etc.


[3, 4] use MILP techniques to solve the synthesis problem.

their models are more restrictive than the one we are addressing.


The subsections below describe how RAMCloud divides its work among all of these resources and how it coordinates the resources to recoverin1-2seconds.

3.2 Scattering Log Segments Forfastest recoverythelog segments for each RAMCloud mastershouldbedistributeduniformly acrossallofthebackupsinthe cluster.thereare severalfactorsthatcomplicatethisapproach: Segmentplacementmustre.ectfailuremodes.


For example, the I/O function al write con in the ttsprk816 benchmark has a coverage of 17.25% (the benchmark ttsprk816 has very low (< 1%) innermost loop coverage; due to this we do not list it in Table 6).

there do not exist any loops in the function (see below).


The Universal Description Discovery and Integration (UDDI) is a registry which holds information on registered Web Ser vices.

neither the registration of the service is necessary, nor does the registry contain su.cient additional information on the service, which would allow the user to obtain information on the kind, nature, behaviour, quality, etc.


Instead, she simply repeated actions she had tried before, with no progress in the mashup itself or in evolving her understanding of the problem or potential solutions.

flexibility in reframing did not seem to be difficult for the more successful participants; they seemed to recognize the time to abandon nonproductive ideas.


As an example, Software Cost Reduction (SCR) has been designed to detect and correct errors during the requirements phase, also allowing test generation.

sCR syntax is not trivial for those who are unfamiliar with it.


fewer predictions than self-advice, on average they match self-prediction advice for 81% of the sites for which they give advice.

occasionally (9% on average of the sites we predict) our advice makes a potentially expensive error by pretenuring a site when it should not; more rarely, we make cheap errors by failing to pretenure.


Definition: A set P of event-sequences satisfies the event coverage criterion if and only if for all events v E V, there is at least one event-sequence p C P such that event v is in p. 3.1.2 Event-interaction Coverage Another important aspect of GUI testing is to check the interactions among all possible pairs of events in the com- ponent.

we want to restrict the checks to pairs of events that may be performed in a sequence.


For sliced causality, complete monitoring, i.e., observing every instruction of the program, is desired for an accurate data-.ow analysis.

such monitoring imposes huge runtime overhead that we want to avoid in practice.


Polymorphic Identi.ers are a result of the same basic premise that identi.ers should always be late-bound.

it doesn t follow the apparent implicit assumption that only messaging can be late-bound and therefore identi.ers must be messages in order to be late-bound, and the related assumption that interfaces must therefore be message-based.


To minimise errors due to inadequate memory, developers often over-estimate the memory space that is needed.

this translates into greater hardware cost without giving any guarantee on memory adequacy.


Introduction Refactoringistheprocess ofimprovingthe structure ofsoftwareby applyingbehavior-preservingprogramtransformations[9], andhasbecomeanintegralpartof currentsoftware developmentmethodologies[4].Theseprogramtransformations,themselves called refactorings, are typicallyidenti.ed by a name, such as RENAME FIELD, and characterized by a set of preconditions under which they are applicable and a set of algorithmic steps for transforming the program s source code.Checkingthesepreconditions and applyingthe transformations manually is tedious and error-prone, so interest in automated tool support for refactorings has been growing.Currently,popularIDEs such asEclipse,1VisualStudio,2 and IntelliJ IDEA3 provide automated support for many common refactorings on various programming languages.In addition,thereis much recentresearchliterature on soundlyperforming a variety of refactorings(seeSection7for an overview).

most research on refactoring has focused on statically typedlanguages, such as Java, for which expressing the preconditions and source code transformations can take advantage of static type information and name resolution.Refactoringfordynamiclanguagessuch asJavaScript is complicatedbecauseidenti.ersare resolvedatruntime.Of thefewpreviousapproachesto refactoringfordynamically typedlanguages, the most well-developed one canbefound intheSmalltalkRefactoringBrowser[24], whichrelies on a combination of runtimeinstrumentation andthe existence of a test suite to ensurethatbehaviorispreserved.By contrast, we aimfor a sound technique thatdoes not require comprehensivetest suites.


It points hardware to the shadow page table, so that TLB hits perform the translation (gVA.hPA) and TLB misses do a standard 1D page walk.

changes to guest or host page tables incur substantial performance overhead to keep the shadow page table coherent [1].


For instance, programmers might rely on this behavior to implement hash functions and random number generators.

there exist also situations in which this behavior might lead a program to produce unexpected results.


(A new type tintroduces a family F, tEiF, iff no other type was a member of F.) Observe that the dispatching result for such a newly introduced family and every other type is always hn ul l. Therefore, we extend the row of tand place the entries for these new families at the end.

instead of extending all the other rows with hn nl lentries, we perform a range-check before accessing any given row.


On the one hand, the model can been seen as a software architecture viewtype [4].

as demonstrated with the example in the UML context, aspects can contain views of other viewtypes thus contributing to modularizing multiple views.


We present a simpler, more abstract, formalization of idempotence in the appendix.

the preceding de.nition in terms of the ideal semantics will be useful in formalizing progress properties, as below, and in proving correctness of our implementation.


One way to support atomicity when making a change to a number of different domain entities is to take the system off-line, evolve the metadata and all the affected domain objects, and then perform a clean restart of the system.

when a system must keep running, or when the system cannot be taken offline for the long period of time required for performing system-wide changes, then dynamic model evolution is a viable option: the incremental evolution of the metadata and the domain objects can be done when objects are loaded into memory.


The requests are sent using SOAP over JMS.

the component web services continue to run on HTTP servers, each running on a separate machine.


Scale-out using MapReduce does provide some speedup for idealized (embarassingly parallel) MapReduce workloads.

for the median job size of 15 GB, the speedup is far short of linear (only 3x with 20 servers).


For ease of evaluation, we implemented our own de-duplication mechanism, which enables us to selectively combine the de-duplication and compression optimizations for speci.c VMs.

live gang migration can potentially be implemented to use any of the above mentioned de-duplication mechanisms.


Compared to hardware-based schemes, a compiler-based approach can have a limited scope (namely, compiler-analyzable codes).

in cases where it is applicable, it can bring much better improvements than hardware schemes as the compiler can analyze future data access patterns and restructure code to maximize BLP.


In our experimental evaluation so far, we compared our approach to pure data migration and pure task migration.

one of the strengths of our approach is that, in considering a given communication statement, we consider the correlated ones as well to make globally acceptable migration decisions.


a high number of Feature Changes could be used to encourage the implementation of an agile approach instead of staying with traditional development methods.

the intention is completely different and might lead to misinterpretation when seen in the traditional sense: in agile processes, Feature Changes are seen as opportunities to be embraced instead of risks to be avoided.


Seaside 3.0.5 includes 696 tests that cover only 34% of all 5104 methods.

if a method is covered, 20 tests will pass this method on an average.


Hard to see overall design 94 Hard to understand behavior of system 94 Code becomes of poorer quality over time 92 Too difficult to restructure system when needed 93 Difficult to change code without adding bugs 93 Changing code takes too much time 94 Our programming language leads to complex code 94 More skill is required than is available to develop high 91 quality code Programming languages are not expressive enough 91 Organization culture does not like the code-centric approach 92 Our programming language is likely to become obsolete 93 Overall, most developers clearly see the value of the modeling approach, even though they practice it only to a limited degree.

there remains a hard core of code-centric zealots who seem dead set against modeling.


The output clusters are stored in set, Cf inal , which gives us the cluster hierarchy.

if the last cluster in Cf inal is not found to contain all the entities in G, Cf inal would yield a disconnected hierarchy as the entities have not been clustered into a single cluster.


The resulting prevailing procedural programming style, which provides very little room for higher abstractions, also results in a high level of conservative attitude when choosing the language for implementation for simulationsoftware,still making FortranandCtheprevailing languages in, e.g., the area of physics or engineering.

the low level of abstraction used in these codes increases the amount of code which has to be written, as reusability, which is not commonly a goal in this setting, is usually low.


2.1 Squid s Implemented Cache Replacement can be cached and decrease the network bandwidth.

in Squid, it assumes what is called the  Strategies uniform cost model, that is, for all objects, Ci = 1.


To overcome those undesirable e.ects while maintaining the expressiveness of the temporal constraints we elaborate a semantic analysis that is capable of detecting such situations during compile time.

to obtain a meaningful analysis, the correctness of an algorithm for the semantic analysis of actions must be veri.ed formally.


2006) and, in the Scala community, the encoding of type classes using implicits is folklore.

as so often with folklore, it was never written down coherently, while the more advanced features have not been documented at all: later sections of this paper describe Scala s answer to overlapping instances (Peyton Jones et al.


(The Check and CheckTrue identi.ers refer to control .ow macros that jump to the Error: label, commonly used for cleanup code, if a condition is false.)

this particular system function returns a negative nonzero value on error, which is incorrectly interpreted as success.


In [11] and the OpenShift PaaS platform [17] the focus is on achieving performance isolation at the middleware level.

these approaches inherently result in less operational cost bene.ts in comparison to applicationlevel multi-tenancy.


Thus, during test generation all test executions use a customized class loader that ensures the instrumentation.

we need to ensure that the generated JUnit test cases faithfully represent the exact same behavior as observed during test generation.


We observe that SQUIRREL greatly simpli.es the implementations, boosting code re-use and enabling easier maintenance.

section 6 investigates SQUIRREL s run-time performance.


As passive devices, a host has to seek out a honeypot.

this limitation when compiled with other devices on the network provided different aspects of visibility and supports a defense in depth strategy against botnets.


Gesture Coder [24] recognizes multitouch gestures via state ma chines, which are authored by demonstration.

proton allows developers to author gestures symbolically using the equivalent regular expressions.


The goal of their veri.cation procedure is similar to ours: verify all systems of the product line at once.

their model checking procedure is only sketched and, as far as we know, no implementation is available.


Recent work has started to explore the use of AOP to improve the isolation of specific features in designs of frameworks [19] and product lines [16, 21].

none of them has analysed the impact of AOP on heterogeneous evolution scenarios of program families.


AUTOSAR goals include reusability of software modules in vehicle.

the standard is a kind of application framework.


Finally, the abstract boolean method hasUnitTest(..) should be re.ned to handle the desired naming convention.

it is important to recall that this is only one particular form to realize the TestFirst aspect, and many other forms exist as well.


In addition, the sessions limitation to a 40 minute time frame does not ensure that we recorded all the commonly asked questions of Pharo developers.

our results indicate a similarity with Sillito s studies and we believe that the asked questions could be generalized to the other change tasks in Pharo.


As with our approach, van Delft treats the zero quantity as having polymorphic dimension.

van Delft does not provide a speci.cation for the semantics of dimension types, does not encode dimensions as part of a class hierarchy, does not allow for the de.nition of new methods speci.c to a particular dimension, and does not include parametric polymorphism over dimension types or separate types for units.


Like [6] and [7] we do not know how to achieve such security.

in all cases where messages consistent with the side information can be sampled e.ciently, our security proofs remain valid.


In general, this nuanced distinction can be ignored as it often does not impact the correctness of a program3 .

it does allow the runtime to execute code in non-deterministic ways to improve performance.


In the ideal situation the translation of each construct will be isolated from the rest.

this is possible only if the structures of the source and target languages are congruent.


6.2 Limitations of the Powerlaw Fit In our experience the simple, two-parameter powerlaw .t works amazingly well.

there are situations where a powerlaw .t does not precisely capture the variation of a cluster s cost across workloads.


On the one hand, this provides a significant advantage of openness and flexibility.

it means that if this definition is not shared by other tools, the definition will remain local.


Strict referential equality, which is the default in the OCL language and is written simply _ = _ in the standard, is an overloaded concept and has to be de.ned for each OCL type individually; for ob jects resulting from class de.nitions, it is implemented by simply comparing the references to the objects.

strong logical equality is a polymorphic concept which is de.ned once and for all by: I[X " Y ]t = LLI[X]t = I[Y ]t JJ It enjoys nearly the laws of a congruence: t |= (x " x) t |= (x " y) =.


We implemented a .ow-and context-insensitive analysis based on object allocation site abstraction, and found that it proved only 1334% of the queries for our benchmarks, with an average of 27.5%.

the combined dynamic-static approach presented in this paper, which is .ow-and context-sensitive, proves 38-72% of the queries, with an average of 52%.


7 Conclusions DVFS is a widely deployed power-saving technology that works well for stable workloads and/or systems with low utilization levels.

web-facing applications running in data centers have bursty workloads and high utilization levels.


These inspiring works can potentially help all testing and diagnosis tools, including ConSeq.

due to the scalability constraints of symbolic executionandtheoremprovers,previouswork only experimented with relatively small applications or relatively simple interleaving problems.


It can provide good address translation time, less garbage collection overhead, and high space utilization but with signi.cant memory requirement.

the block-level FTL maps the logical block number into a physical block number, and requires much less mapping information.


An ERD may also show specialization, or subtype, relationship as an is-a relationship which can be transformed into the UML class diagram as a generalization as shown in Figure 10.

one must be careful that the ERD is-a relationship is actually a generalization and not a role.


For example, incorrect use of explicit refreshing is missing refreshing information, resulting in memory being reclaimed too early creating dangling pointers.

unreachable objects can never be explicitly deallocated in the persistent memory model (source of memory leaks) whereas refreshing needed and thus reachable objects is always possible.


For example, the CERT Basic Fuzzing Framework (BFF) [14], which supports fuzzing a single program with a collection of seeds and a set of mutation ratios, uses an MAB algorithm to select among the seed-ratio pairs during a fuzz campaign.

we must stress that recognizing the MAB nature of our problem is merely a .rst step.


Computation insynchronousport-numberednetworkshas beenstudied fordecades; oneofthepioneerswasAngluin[2] in 1980.

the main focus has been on global problems such as leader election [2, 24], construction of spanning trees [24], computation of functions that depend on all nodes [5, 7, 23], recognition of topological properties [2, 24], and graph exploration and rendezvous [16].


Previous research has shown the bene.ts of collaborative learning in introductory computer science classes through pair programming assignments [5], with signi.cant improvements to students experience and performance in the course.

pair programming is not the only way for students to collaborate on their assignments, and its value as a pedagogical tool has not yet been unequivocally established.


The use of JML, as a DbC tool, minimizes the symptoms of code tangling and scattering of Java applications.

since the nature of JML 1 Programming with assertions http://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html speci.cations still are crosscutting, the use of the contract aspect pattern provides a better solution to separate the contract concern from the base code, and therefore gaining in attributes such as maintainability.


More importantly, the higher MTA malloc curves correspond to greater numbers of processors: the total elapsed time increases as the number of processors, and hence the contention, increases.

the higher curves for MAMA correspond to smaller numbers of processors.


in some cases, the compiler can notice that this principle is violated, and issues a warning.


6.2 Other discussions In the introduction, we mentioned that an environment changes over time and objects in that environment should change accordingly.

our model does not directly support changes of environments.


In general, using instrumentation along with burst profiling (only running instrumented code for brief periods of time) leads to lower overall overhead over interpretation.

instrumentation needs to modify the target binary before it can start profiling which can be fairly expensive if the binary is large and block structure information is not known ahead of time.


The latter refers to the fact that dynamic languages are often interpreted instead of being compiled.

this has more to do with implementation techniques suited to support the dynamic aspects rather than to being an inherent property of the languages themselves.


From the Sogeti dataset we get: FP = 5.15 TF + 4.74 DF From the dataset reported in [9] we get: FP = 3.76 TF + 7.6 DF This means that in the Sogeti dataset the transaction functions were more complex, and contributed more FP than the data functions.

in the second dataset the data functions provided the greatest contribution.


In the case of Figure 3(a), the target block uses no outer variable, so that the block can be extracted as a new method simply.

in the case of Figure 3(b), thetarget block refers to and assigns a value to outer variables, so that extracting theblockrequirestoaddargumentsandareturnstatementto the new method.


To this end, many formal approaches support dynamic recon.guration through the de.nition of recon.guration operations and their formal semantics, as in [26, 32, 4].

the formal semantics underlying most of those approaches generally allow only for operational (as opposed to declarative) descriptions, and when equipped with veri.cation tools, they focus mainly on model-checking techniques.


When execution cost averages 100 µs, BASE performs the best since the agreement overhead dominates the cost of processing each request and our implementation of separation incurs additional cost for the agreement replicas.

for execution costs exceeding 0.75 ms, the execution replicas become the system bottleneck.


If M and N have the least common re.nement, then this is the desired result of the merge.

if M and N are consistent but do not have the least common re.nement, then the merge process should result in one of the minimal common re.nements of M and N. Model merging should support the modeller in choosing which minimal common re.nement is the most appropriate.


When synchronous advice execution is not a necessity, asynchronous advice execution has the potential to parallelize program and advice execution on multicores.

asynchronous advice execution requires communication between threads, causing some overhead.


4.1 Standalone Web Server & Database When we first started designing the tool, we thought that we may be able to write a tool that ran directly in the web browser.

it quickly became apparent that it would be much easier and flexible to use the browser as it was designed: in conjunction with a web server.


Then, the continuous state can be derived via a linear combination of the clock and the sampled state.

observability and observer design for timed automata considers the discrete state reconstruction, see e.g., [20], which is straightforward for the class of systems under consideration.


And there has been e.orts to write these down, such as [3, 13], with the most recent and complete description being [2].

it turned out that at least this latter rendition did not have principal types due to a problem with the monomorphism restriction, and since then we have found another problem, this time involving type signatures.


All of these publications promote the theoretical bene.ts offered by different characteristics of ontologies, such as explicit semantics and taxonomy, lack of polysemy, ease of communication and automatic data exchange between distinct tools, and computational inference.

only few approaches put those ideas into real practice.


In this paper, we assume that the SEval function satis.es all the properties mentioned above.

the results of our paper can also be extended to prove relative completeness for a theory if the SEval function does not satisfy property B2.


4.3 Control Flow in Wavefront As we have shown, the primary problem in e.cient AllPairs is managing data access.

in Wavefront the problem is almost entirely control .ow.


S·S) · E) and allows calling a method m from a state s if s·m is a member.

in the examples we have experimented with, there are often scenarios where a safe method call sequence m·m ' is disallowed from a particular state q even though calling m guarantees that calling m ' is safe.


9 Conclusion Shift and reset have long gained a critical mass of applications to warrant .rst-class support in modern functional programming languages.

research on the pragmatics of supplying and ef.ciently implementing shift/reset has only just begun.


Polarized Logical Relations The parametric relation is useful for proving parametricity properties about (the positive wrappings of) G terms.

it is all-ornothing: it can only be used to prove parametricity for terms that expect to be treated parametrically and also behave parametrically cf.


The process function is used to identify a process execute comb (line 2).

at the moment it can only be used to extend the processes sensitivity list.


Abdel-Hamid and Madnick (AHM) modeled the basic software testing process, which is a sector of their integrated software process model with system dynamics [3].

their model is based on the waterfall testing process, rather than the incremental development.


While Dt2c and St2c policies provide speedups higher than 5% in seventeen and .fteen mixes, respectively, Linux scheduler only surpasses this value in four mixes.

the speedup of Linux scheduler falls around or below 2% in six mixes, while St2c and Dt2c policies only do that in one mix.


Once it is done, we can achieve all possible combinations by submitting them to Prolog.

some atomic formulas can reference the same attribute feature.


To gain a broad understanding of operating systems, it is useful to have hands-on experience with several di.erent major components of an operating system.

the sheer size of these systems makes them di.cult to understand.


Semantically, these routines are just copying from unmanaged memory (provided by MPI) into managed objects.

the result type of Marshal.PtrStructure is object, meaning that the result is boxed before being returned and then unboxed, causing unnecessary overhead.


Observe that the tag bag test as de.ned above causes the supercompiler to terminate when the domain of the tag bag is equal to a prior one and where the total number of elements in the bag has not decreased.

since there are a .nite number of tags, we can think of a tagbag as simply a very large (but bounded) arity tuple so by the Cartesian Product Lemma we need only terminate if each of the tags considered individually occur a non-decreasing number of times.


We ran a similar model using the Number of Location measure and the results were equivalent.

we report the results for Number of Regional Units because the explained deviance of the model was higher than the model which included the Number of Locations measure.


Power @ may.ie malloy @ cs.clemson .edu ABSTRACT Formal grammars are well established for specifying the syn- tax of programming languages.

the formal specifi- cation of programming language semantics has proven more elusive.


According to Yee, PRACs should enable the initiator to identify the .rst malicious host, and so trust only the data gathered before visiting that host.

it is not clear how this identi.cation can take place in practice.


On the simulated system, each thread has a separate pipeline.

similar to the UltraSPARC T1 processor, a total of eight 8 KB .rst level caches are available and each .rst level cache is shared between four threads.


Kellner, Madachy and Ra.o (KMR) discussed four types of simulation in their seminal paper in ProSim community [2].

our review identi.ed ten simulation paradigms from the primary studies (listed in Table 3).


Additionally, it o.ers a simple way to assess results and to compare di.erent prediction models and systems.

because 20% can still seem a somewhat arbitrary value, in [28] we proposed an alternate measure called the fault-percentile average that represents the average fault yield over all values of the cuto.


Equally important is that the subsystem/function/component requirements are complete and stable enough for carrying the design to the next level.

it is also necessary to have a clear overview of the total architecture, i.e., to understand the design (this is related to Sec.


Class construction with XVCL Code fragments that recur in buffer classes without changes, such as method hasArray() in Figure 4, are included as is .

other meta-fragments must be adapted for reuse in a given context.


We did not assess usability in this evaluation with dedicated usability studies.

the calculations for each of the 15 PLs could be modeled by one Siemens VAI engineer within one working day, even for the larger models.


Due to their traditional cost and complexity, implementations of CE Systems have historically been the domain of seasoned computer professionals, academic researchers, and large corporations.

many of today s average technology consumers have persistent Internet connections, extensive web experience, and mobile Internet enabled devices.


We obtain a similar complexity to theirs when expanding the algorithm to the type field of variables.

we incur a constant overhead due to the intraprocedural type analysis and an additional linear term due to the iterative analysis of methods in the program.


Those affects dominate performance for those benchmarks, rather than anything due to recovery.

this is not a fair comparison because V8 implements both the recovery mechanisms as part of its compilers along with many other optimizations, making it very dif.cult to tease out and isolate the effect of each of the recovery mechanisms.


When packet loss reaches 5%, Skype reacts with a FEC mechanism up to 10% packet loss, and the frame drop rate decreases.

even if packet loss drops to 0%, the frame drop rate has still a considerable difference compared to the no-loss experiment.


Code-size increase PB I sampling does not require any change to a program.

a signi.cant amount of instrumentation is needed to support sampling in traditional systems.


Only applications that request to be offloaded, and given user acceptance will be offloaded whenever they are accessed.

there is another side to Static Reconfiguration.


reasoning about dynamic state is not typically part of the service advertisement or discovery phases of the protocols.


implementation ReadOnlyList [String] extends ReadOnlyList [ReadOnlyList]{ int size() { return this.length(); } Character elementAt(int i) { return this.charAt(i); } } 2.5 Static Interface Members It is a common task to construct instances of a class from an external representation such as XML or some other serialization format.

the desired methods behave like class constructors and thus cannot be speci.ed in a Java 1.5 interface.


The game places you as a military commander who is able to launch air strikes against terrorists.

the missiles have a lag before they land, and invariably hit civilians, radicalizing others.


Most multitouch devices cannot detect which hand (left or right) generated a touch event.

we can simulate hand ID using the screen location attribute as a proxy for hand ID.


The component and its realtime thread structure, as well as its scheduling and temporal parameters are generated automatically following the component s abstract speci.cation.

as explained in [2], special care needs to be taken concerning the use of standard Java libraries.


For example, maximal matchings can be veri.ed without any proofs, and hence we say that this problem is in LCP(0).

verifying a maximum matching ( edges with label 1 form a maximum-cardinality matching ) requires some auxiliary information.


They tend not to be about creativity, or reflection methodologies are more concerned with normal design (which after all dominates the field) and with normal designers than with radical design and innovative designers.

expert practice is highly reflective, and gives due attention both to seeking insight along a suggested trajectory (about making progress within a conception of the problem, and a notion of the destination) and to reconsidering the trajectory as understanding develops.


When we generated constraints without including the results of the pointer analysis algorithms, the tool output 251 warnings (as opposed to 295 warnings).

this method resulted in the warning on the array dfname being suppressed, so the tool missed the off-by-one bug that we described earlier.


PARALLELS AND DIFFERENCES In principle, software is technically easier to evolve than buildings; software is not constrained by physical laws in the same way that physical artefacts are.

software evolution is a very hard problem, as physical constraints are far from the only forces acting on a software project; business and social forces are more important in software engineering.


4.1 Comparison of port ommand/2and port all/3 Since the primary purpose of Erlang s port driver mechanism is to implement ef.cient I/O drivers, e.g., for network or database access, one of its important features is to allow transfering binaries by reference between Erlang programs and drivers.

the functions that support this feature, the port ommand/2Erlang BIF and the driver output term/3C function (and similar functions), have limitations: driver output term/3uses a special format for encoding terms which supports only a few types of Erlang terms, and port ommand/2does not encode terms (encoding must be done explicitly before calling it);  they are inef.cient, when used only to pass simple Erlang terms to and from a driver without needing to pass binaries by reference.


As expected, this change improved overall network utilization and reduced latency.

this custom WebDAV method required that all of the data (including the content stored in Subversion which, of course, could be binary and of arbitrary size) be XML-encoded.


During a traditional software installation, the installation program prompts the user to choose the right components relevant to the particular deployment.

when the VA producersgenerate theVA, they are not aware of the actualdeployment scenario.


For a single resource case, the optimized resource design parameters, that is, period and execution length, can be obtained by a method based either on an exact schedulability test [4], [5] or on resource supply and demand functions [1] [3].

it is often intractable to .nd the optimal set of resource parameters mainly because the local optimality of each resource does not necessarily lead to the globally optimal solution [4], [5].


Let us assume that we are running an instance of a calendaring application on our PDA; when meeting a colleague who is running the same application on his/her PDA, we want to synchronise our diary entries.

the application pro.les on the two hosts may con.ict in the following way.


Solution B was identical, but aimed to parallelize all the queries (at the cost of increased memory consumption) so that the data could be returned faster.

the performance improvement achieved with solution A was found to be more than satisfactory and, therefore, solution A was adopted.


One approach to meeting these needs is to control and schedule the individual resources used to serve each .ow.

this approach has a number of limitations as described in Section 2; most importantly it requires support in the server software and/or the hosting platform.


We will refer to source-sink[1,1] problems simply as source-sink problems.

the problem of determining that an untrusted value never .ows into a trusted location is a source-sink[0,0] problem.


Their protocol uses an additively homomorphic public-key cryptosystem to protect con.dential data from intermediate aggregation nodes.

their scheme does not address the issue of integrity discussed in this paper.


In fact, in order to design their applications, software programmers usually rely on thick abstraction layers that make hardware appear as a perfect machine.

hardware may be independently developed as long as it complies with a set of fixed, softwaredefined conventions.


A call to the super-method, like in Truck, will look to the regular superclass (originally Vehicle) for the method.

in Traffic, where TrafficVehicle is the superclass of Truck (now TrafficTruck) that call to super.move(..) will invoke the move method in TrafficVehicle and the same is true for a supercall in the adds-part of TrafficTruck.To be able to invoke the overridden method in Vehicle,weadd a new keyword to PT: tsuper.


In the past years, many software metrics have been proposed in order to represent several different concepts such as complexity, coupling, inheritance, reuse, etc.

this requires the collection of large volumes of metrics and, without flexible and transparent tools, is nearly impossible to collect data accurately.


To illustrate this, the reader may think of what happens when the notation model is lost for some reason: A new diagram can easily be created from the remaining semantic model and the diagram will contain all nodes and edges the old diagram contained.


For example, it can be di.cult to extend an existing washing machine model into one that has a built-in dryer.

the SHF provides models that can be easily extended into specialised models.


This method identifies the need for creating abstractions that remain stable during the evolution of the product line, also steps that perform this estimation is included in the accompanied PASTA process.

no direct technique is proposed to perform volatility analysis.


Dynamic Interoperability between Heterogeneous Services Franck Chauvel High Confidence Software Labs School of Electronics Engineering and Computer Science - Peking University franck.chauvel@sei.pku.edu.cn  ABSTRACT Service-Oriented Architecture (SOA) is now one of the most acknowledged paradigms to design and realize scalable ubiquitous systems.

the emergence of various versatile service technologies (WS, UPnP, DPWS, OSGi, etc.)


Daikon produces operational speci.cations to facilitate understanding of internal class logic and postulate legal static snapshots at particular execution points.

more interaction-oriented behavioral descriptions that describe the legal invocation sequences are useful for the development tasks discussed in Section 1.


6.2 Implications for Practitioners Researchers have to take the initiative to build the SERP taxonomies using rigorous approaches.

the taxonomies will be of little value without the practitioners providing their challenges and classi.cations of these challenges.


The direct construction approaches such as Korat [3] construct desired object states by directly assigning values to member .elds of classes under test.

these approaches require speci.cations such as class invariants [26], which are rarely documented by developers.


The scalability and elasticity of these applications is crucially impacted by architects early decision for an architectural style.

whether this decision fostered scalability and elasticity can currently only be tested with the .nal application deployed in the target cloud computing environment.


The MSF is one of two complementary frameworks (besides Microsoft Operations Framework (MOF)), forming an overall solution for large software companies occupied with medium sized and large projects.


The more accurately a DSL matches its domain, the easier and more precisely users can specify their solutions through the DSL.

accurateness might hinder the expressivity of the DSL so that the DSL falls short to capture some requirements (too narrow focus).


Recent work shows that automatic extraction of pipeline parallelism is an effective way to speed up single thread execution.

two problems remain challenging load balancing and inter-thread communication.


For the driver, the global state can be inconsistent, since the driver explores a failure path when no failure occurred.

thisinconsistency has no effect on the execution, aslong as the OS does not make assumptions about whether or not buffers are still allocated after the driver s failure.


For the eval function calls after compiling modules, the semantics are preserved.

the temporary helper functions have a chance of name con.ict with new names that the eval function calls introduce during compiling modules.


Note that sensor networks are designed to have long operation time (i.e., several years).

sensors do not have unlimited resource supplies, e.g., power, CPU, memory, etc.


the expression assert nats [4,-2] raises an exception, because the assertion is violated.


Novel debugging modes: Our debugger supports the usual fashion of debugging, in which the user starts in some entry point ( main ) and runs until a breakpoint (placed on a behavioral element) is hit.

we also support a unique feature we call interactive debugging .


For example, repetitive downloads can be detected by simply checking the timing of the download pattern.

without ADEL, the application developers do not even know the speci.c problems that should be tested for.


If X .y has con.dence c%, then X .y has expected con.dence c% since there is no reason to believe, without prior knowledge, that y is more/less likely to be in a trans action with X than one with X.

as y is an ancestor of y, the rule X .y clearly has con.dence c% and possibly much more.


They can use provided library functions to write code to manipulate the architecture.

they do not need to write any code for managing versions and con.gurations among architectural elements.


However, it requires human expertise on the targeted device or system, which may include proprietary con.gurations and use of algorithms and optimizations that are not disclosed.

the so-called black box method can serve as a more general-purpose approach.


Alternatively, further AoUCM elements could be supported by more advanced transformation rules.

any additions to the Adore notation have to be carefully weighed against Adore s need to keep its meta  model as reduced as possible to be in a position to prove its composition mechanisms.


This is similar in spirit to our focused checking.

there are many situations where type discovery succeeds in showing that a statement is race-free while their static analysis does not.


As part of this traversal, we compute 17,328,102,175,815 SHA1 hashes (for random number generation).

the algorithm from [35] achieves its peak performance with a few thousand cores and slows down to a crawl beyond that due to overwhelming termination detection overheads and network contention.


Current release does not tackle session hand-off of TCPTE applications.


This would have terminated our equality computation, returning false.

if the target object is not found on the stack, it is pushed on the stack.


For the smaller data sizes, MPI and SHMEM generally outperform CC-SAS.

for our largest test case consisting of approximately 1.3M triangles, the CC-SAS implementation has lower runtimes than the message-passing versions.


In this example, the RA is updated every 18 months, the IA every 7-8 months, and the agile cycle sessions last 2-3 months.

it is important to note that any major issues appearing during a Level 2 design session should be propagated to the encompassing Level 1 IA.


The Carousel Assistant has requested callbacks for changes on any of these variables.

as the operations that need to happen on the basis of these events may involve communicating to the Narrative Engine the operations are not executed inline, but instead a second thread is signaled, which will then implement the operation.


These include MobiS, and Ambient-PRISMA.

c2Sadel, LAM model, Community, p-ADL and Con-Moto only flat migration is supported.


[1] propose a basic gossip-based protocol for establishing friendship links in a distributed social network considering network dynamics.

many requirements of social networks, such as dissemination of updates, availability of data, and privacy were not in the scope of their work.


The IT team from the Institute has developed a REST interface for their CAS server in order to provide the required methods to create users from Drupal.

gRIAL has developed a client to use the REST services and process the creation of new users in the social network.


Advanced programmers may be benefited by NCL Eclipse in order to accelerate the development through the use of features such as content suggestion and syntactic and semantic validation.

beginners may be benefited by improving their NCL skills.


Their approach and ours share the same starting point, as we both believe that developing a JIT compiler for each dynamic language from scratch is prohibitively expensive.

their technique is still complicated to use for programming language implementers, as they need to extend the existing JIT with their own implementation language.


Scan results for IP addresses belonging to the same network, for instance 216.151.157.140 and 216.151.157.135, were di.erent to the open ports.

all of the hosts were running remote controlling services such as VNC (Virtual Network Computing, a remote control program which allows one to view and fully interact with a computer remotely), AFS (Andrew File System) or, in most cases, both of them.


It's a heuristic method and can only handle periodic tasks statically.

in most of the above work, perfownenoe is the only cow c4ma.


As illustrated in Figure 3, the Periodic and Random policies checked assertions at the expected frequency since they were both given 100 for their interval and range, respectively.

adaptive Timing clearly performed many Figure 2: Average overhead by policy Figure 3: Percentage of checked methods Figure 4: Percentage of errors detected  more checks on average for constant-time assertions than the other policies.


Since data evolves naturally over time and is often replicated among different applications, it becomes frequently necessary to mutually convert between such formats.

traditional XML transformation languages, like the XSLT and XQuery standards of the World Wide Web Consortium (W3C), are unsatisfactory for this purpose as they require writing a separate transformation for each direction.


Existing approaches tend to address one or the other of the problems, ignoring the second one.

we present an integrated approach and argue that this is more powerful than two isolated solutions.


Whit.eld and So.a [18] propose a framework for specifying transformations and an automatic optimizer generator in order to experiment with transformations.

this does not solve the problem of which transformations to enable.


Assuming the application is deadlockfree, at some point at least one of the threads will stop holding the lock speculatively acquired by the other thread.

neither thread can transfer lock ownership to the other thread, because they are both in speculative mode.


For data sets exhibiting linear trends, our GLS algorithms achieved an average 10% improvement over existing local based methods.

for data sets with nonlinear trends, our GLS algorithms exhibited more significant improvement (approximately 50% increase) over existing local methods.


The .rst case study showsthesituationinwhich theSAO and OABAS would help the go/no-go decision.

there are another situations and steps of ATAM which the described ontologies would act as e.ective means.


Scalability Testing: A complete UnLoc system needs to be tested over larger scale, in terms of the number of users and data size.

as with other crowd-sourcing based systems, it is dif.cult for us to deploy a large scale testbed.


Furthermore, we think that these concepts may be applicable to general data models.

this assumption has to be veri.ed after completing the research proposed in this position paper.


It is interesting to note that an application of the approach from Section 3.3 to the case q = 1 also gives an absolute upper bound on the length of the input string.

the bound is not as tight as that given in Section 3.2 using a different approach.


Higher values of D increase the size of the pipeline of panels in .ight and allow for communication-communication overlapping in addition to communication-computation overlapping, since more than one message is transferred at the same time.

increasing D leads to more outstanding messages.


Software vendors are increasingly becoming aware of security issues in web services, as can be seen by the large number of vulnerability detection tools available nowadays.

most of those tools focus on the detection of vulnerabilities at the application level (e.g., SQL Injection, XSS [9], [10]), disregarding the underlying framework, which is frequently (wrongly) assumed to be secure.


To the best of our knowledge, no implementation exists for executing C code on top of the Common Language Infrastructure (CLI).

there are efforts to implement a CLI C compiler [23].


We have tackled this question in the context of repeated bestresponse.

we believe that the examination of other dynamics from the literature is an interesting direction for future research.


This approach is able to handle all data references uniformly through the cache and capture data reuse that occurs.

this is typically an expensive approach since the data cache is completely implemented in software.


In the hard reservation case, devices other than the reservation owner and target(s) shall not transmit frames; that means that unused time should be released for PCA.

the soft reservation type permits PCA, but the reservation owner has preferential access.


Those studies mainly focus on desktop and server processors, such as x86CPUs.

we aim at an OpenCL framework for multicore ARM processors with the NEON vector unit.


On the average, selective migration is 3% slower than the original algorithm.

premature migration always sends pages over, paying the full price of a data transfer, to communicate values that will be read only once.


5.2 Frequent top-k hotspot services We motivate the need for this step with an example.

table 1 shows top-k (k=2) hotspots in .ve SCG instances of a functionality F. Based on the frequency of occurrence in top-k lists, the services {x2, x3}are the best candidates to optimize F. optimizing these services together might not have a huge impact on requests to F in general, because they co-occur only once in the .ve top-k lists.


Computation on data with index i does not require that all input channels contain tokens with that index; it is well-de.ned even if only a subset of input channels ever receive tokens with index i.

a node may not proceed to compute for index i unless it knows that no further tokens with this index will ever arrive at its inputs.


Typically, vendors try to maintain the old component version s key properties (e.g., granularity, implementation language, and interaction paradigm), while enhancing its functionality (by adding new features) and/or reliability (by fixing known bugs).

component upgrades raise another set of questions, including whether the new version correctly preserves the functionality carried over from the old version, whether the new version introduces new errors, whether there is any performance discrepancy between the old and new versions, and so forth.


Oneapproach tomitigating theriskis dumbingdown thesensordata thatispassed on to the application, saybyquantizing it to a coarse-grainedlevel.

since application needs cannotbe anticipated, itishard todo suchdumbing down withoutimpacting generality.


When two method signatures do unify, there may be overlap in the declarations.

if we can prove that overlapping elements are infeasible, then the declarations are still unique.


The square-law with AGC combiner is linearly summed the energy detector s outputs which are normalized by the NT in each hop, and the yn is computed by L-1 2 r n,l1/NT yn =ln l=0 (6) L-1 r2 /NT n,l0 l=0 In this combining method, the combiner needs to know N0, and NJ .

if the parameters N0 and NJ are unknown, we can used the square-law with equal gain diversity combining scheme.


They also in ii clude rules activate( f (x1,...,xk)) .

f ([x1]1 f ,...,[xk]kf ) ' for k-ary symbols f where f does not appear in the .rst part of R µ Giesl and Middeldorp have recently shown that FR.


Data dependency and load instruction So far in this section, we have dealt with just the dependencies between PEIs.

in a program there are redundancies of load instructions protected by PEIs, and redundancies of PEIs that are data-dependent on those load instructions.


Networks of interconnected veri.cation routines are formed, so that all or almost of the interconnected veri.cation routines must be disabled at the same time to succeed in modi.cation, hence, it has an e.ect of increasing the cost of attack.

concrete method to create them or the implementation are not clearly exhibited.


Another solution would be to use state transfer functions (STF) to bring the system into a consistent state.

as the explicit use of STF compromise transparency, we advocate application designs that tolerate less strict correctness criteria before resorting to STF.


NASD [7] is similar in that a central server delegates access rights to clients.

it uses intelligent drives rather than separate storage servers to provide access to data.


Also, the inconsistent policy con.gurations detected from the non-IE components (such as Adobe Flash Player and QuickTime Player) can also lead to security vulnerabilities.

because we lack domain-expert knowledge on these components, we have focused our analysis on the IE components.


Like Java, PHP combines interfaces and single inheritance.

since version 5.4, PHP also supports traits [5].


New test cases were generated as long as there were targets to be covered or a maximum execution time was reached.

the encapsulation problem was not addressed, and this proposal only dealt with a simple state problem.


Previous systems [10, 11] usually assume stable network connectivity and adequate cloud computation resources.

in mobile environments a mobile device may experience varying or even intermittent connectivity, while cloud resources may be temporarily unavailable or occupied.


Operating system resource identi.ers, such as process IDs (PIDs), must remain constant throughout the life of a process to ensure its correct operation.

when a process is moved from one operating system instance to another, there is no guarantee that the destination system will provide the same identi.ers to the migrated process; those identi.ers may in fact be in use by other processes in the system.


In some extent, this step is similar to the MapReduce model which is widely used in cloud computing.

this pub/sub way is quicker than using MapReduce model.


IBM Jazz is one of the most recent and fullfeatured CDE, which provides both presence and workspace awareness in one place [5].

1 http://sourceforge.net/ 2 http://code.google.com 3 http://github.com/ 4 http://www.assembla.com/ 5 http://twitter.com/ 6 http://www.facebook.com/ 7 http://www.lastfm.it/ neither Jazz supplies informal, personal information on coworkers in order to provide them with group awareness, that is, the consciousness of individual collaborators in a group with regards to affective behaviors, collective orientation, particularism or diffuseness [13], which is extremely beneficial to maintain a sense of teamness between geographically distributed software teams [10].


Once a .ow through some call-sites is allowed and user preference is saved, mimicking attack using same callsites will also get approved.

a parameter-aware approach can differentiate outgoing data.ows according to the destination URL, and thus, exploitation of a previously allowed callsites will still raise a warning.


In particular, any behavior the concrete program exhibits should also be exhibited by the abstract approximation of that program.

we must be precise as to which behaviors are relevant.


Channels act as locations of control, and messages are exchanged between communication points and channels to negotiate synchronization.

knabe assumes a global ordering on processes and maintains queues for matching communication points; we do not require either of these facilities in our protocol.


XIS represents a useful solution to model simple desktop or web interactive applications [17].

when the goal is to model mobile applications XIS presents some limitations, namely regarding a proper support for the specification of gestures, internet connection, localization and other context-aware issues commonly used in mobile applications.


Luckily and this comes to their rescue  these MAKE language features are currently not used very frequently in KBUILD.

they are used4 and their usage is not discouraged by Linux coding guidelines.


There is some previous work dealing with the integration of SIP with external services and the uni.cation of the various signaling plane protocols for call control.

these approaches focus on the development of VoIP like applications and only provide limited functionality for the reuse of components.


There are an enormous number of such caches: for example, every .eld and method potentially has an associated cache of re.ection data.

when the program is under memory pressure, it would be appropriate to clear these caches.


This was implemented using the same process as discussed above.

the need to calculate the point charges from the environment was something that the original design did not take into account.


Given similar succesful ERP implementations for Randstad Holding in the US and in Germany, PeopleSoft and SAP were high on the vendor shortlist.

none of both vendors succeeded in convincing Randstad Holding Nederland of their suitability for the job.


By performing if-conversion and total loop unrolling previous to ISE identi.cation, the CRC function is transformed into a single basic block, and state of the art ISE techniques [2] are then able to identify the whole block as a very high-performance 2-inputs 1-output custom instruction.

we cannot expect a compiler for a noncustomizable processor to aggressively perform such transformations systematically: a traditional compiler is guided by heuristics that limit register pressure and code size increase.


Tools like DTrace [7] and Sys temTap [27] perform dynamic or binary code instrumenta tion.

lT Tng [9] performs automated source code instrumentation.


Assuming an ef.cient, well-de.ned API, product lines can be designed without the need of individual adaptations to speci.cs of the hardware and OS, which reduces development time should further product lines have to be added.

modeling product lines instead of concrete applications reduces the development time required if further product variants are de.ned.


INTRODUCTION Gustafson s law [25] states that any sufficiently large problem can be efficiently parallelized and has proven that parallelization is an effective way to accelerate the processing of massive data.

in practice not all applications are easily parallelized and finding the right programming model and architecture for a given algorithm is quite challenging in the multicore era.


For example, Google Earth [8] and Google Maps [9] provide an intuitive Web-based interface to access geographic information.

such systems do not provide support for infomobility services where dynamic georeferenced information can be communicated to users (e.g., dynamic noti.cation of tra.c jams).


A contending thread couldn t make progress and in this scheme must request that the owner in.ate the header before he waits on the Monitor.

bias and thin locking approaches can compare-and-exchange in a Monitor at this point (with the contending thread waiting on the Monitor).


provide an early approach to perform linear scan register allocation directly on SSA form [19].

they still deconstruct SSA form before register allocation during the construction of the lifetime intervals: They insert move instructions into predecessor blocks for phi functions, leading to intervals that start in the predecessor blocks and extending into the successor.


In this proposal, discrepancies with higher locating the discrepancy, identifying the cause of the dis-priority affect more requirements and, therefore, deserve more attention than lower priority ones.

we are interested in more qualitative classifications, which address Permission to make digital or hard copies of all or part of this work for the role, or the use, of the discrepant statements.


The precision of RA SSA is not as good as that of the other two SSA representations because we lack iteration vector information.

iteration vectors would become very complex in interprocedural contexts (they must include call stack information), whereas USRs represent arbitrarily large interprocedural program contexts in a scalable way.


In Case 2, all the regression test failures can be detected by the reduced regression test suite.

for Case 1, no  regression test failures were found.


Lockstepping also provides more complete fault coverage than SRT, particularly for permanent faults, as redundant computations are executed on physically separate hardware.

lockstepping uses hardware resources less efficiently than SRT, as both copies of a computation are forced to waste resources--in lockstep--on misspeculation and cache misses.


A centralized point of view may be taken on collaboration, which nicely suits service orchestration.

modern processes and applications are much more collaborative in nature.


The high correlation among the two is quite natural, since the larger the Loc of a class, the larger is the chance of .nding lines of code containing calls to methods or variables belonging to other classes.

fan-in is not so correlated to Loc, since for a class, to have many lines of code does not directly imply to have a large chance of being used by other classes.


Therefore, there is no cost of introducing an AOP tool to a new language when using UniAspect.

for example AspectJ has a similar syntax to Java, but AOJS has a syntax based on XML.


Three workloads, except for MatriMul, shows RSVM, as an extra software layer, introduces small overhead.


Both the primary cell and this counter could safely be freed when the count reaches zero.

while our access capability is still linear with RCRef, we can never be certain that we possess the only reference to cell in question.


Figure 7 shows the results obtained with NAS EP class D and NAS MG class C. The results show that automatic runtime power management (i.e., PM_CONSERVATIVE policy) does not provide signi.cant energy savings.

application level policies allows the programmer to manage energy/performance tradeo.


Peer-to-peer (p2p) mechanisms naturally address these drawbacks by using players resources and of.oading the servers from performing game management tasks.

the absence of a central coordination entity leads to a number of new design challenges, including an ef.cient coordination of the distributed simulation, data storage and discovery, handling player churn, load balancing, consistency and latency related issues.


The idea of Ray and Ray [26] is similar with the ideas motivating part of this work, namely utilizing an existing model checker for verifying a set of rules.

ray and Ray only address a speci.c execution model with primitive events stemming from updates of cells in an active database.


Thus, a TPM can be used to perform cryptographic signatures on user-provided data using hardware-protected private keys.

due to limited TPM memory, keys have to be swapped out of the TPM when not in use.


Multi-channel FTL schemes spread out pages in a logical block across multiple channels for increasing I/O parallelism.

this scheme can bring about high garbage collection overhead.


Given an agent plan that posts several messages, our method assumes that all messages are posted by the plan.

a designer may intend only some of these messages to be posted for any single execution of the plan, depending on some logic internal to the plan.


High-level machine description languages have been proposed [17, 23, 37] to alleviate this problem by factoring descriptions into simpler parts.

creating these descriptions is time-consuming since the writer must still model the inherently complex interactions present in a microarchitecture [9, 16].


The effort categories that co-occur with the most negative evaluations are Legal Efforts and Technological Efforts.

it should be noted that despite the clear majority of negative evaluations of effort categories, there are is nevertheless a share of 2 Since each group of interviewees and both cases had different number of interviewees, a comparison based on absolute coding frequencies would give a misleading picture.


First, memory oversubscription can be avoided by running the 12 instances of a workload sequentially, i.e., without multiprocessing.

its execution times are worse than the execution times of a concurrent schedule with memory oversubscription.


We .nd that this fundamental cost is signi.cantly lower than previously thought; for the dynamic schedule, it is no more than 32% slowdown in parallel execution and 4% on average.

in the presence of skewed execution conditions, this cost can slow down execution by a factor of almost 2x.


In the previous example we saw that @Java permits to mark a particular code section, so that a third-party tool can then retrieve it and inspect it further.

@Java makes available all the tools that may be necessary to perform code transformations.


Clock synchronization is a prerequisite for composite event detection i In general distributed systems, such as the Internet, time synchronization is commonly based on the Network Time Protocol (NTP) with time servers running GPS or atomic clocks.

standardNTPisnot suitablefortimesynchronization in sensor networks (see e.g.


Although the property patterns are extremely useful, it is still very di.cult to accurately formulate a property speci.cation based on them.

our approach extends these property patterns with templates that explicitly indicate the alternative options associated with each property pattern.


5.2 Mitigating Non-Determinism When non-determinism is acute, one might seek to prevent it altogether.

as discussed in §4.2, deterministic replay tech niques [15, 20] force the minimization process to stay on the origi nal code path, and incur substantial performance overhead.


In the case of the values, clearly the subset relation has this property.

for formulas the situation is more murky.


Today, several process frameworks, such as ISO 24744 [19] claim to implement basic SME concepts.

although SME was proposed in the mid 1990 s and there is a considerable number of contributions based on SME ideas, there are only few studies dealing with analyzing the state-of-the-art and, in particular, the feasibility when applying SME concepts in practice.


This result is directly useful to language implementors and does not require a notion of serializability.

the Weak language remains unrealistic because its transactions never execute partially and then abort.


Concept schemas resemble the notion of worlds described in (Sch¨urmann 2000), however while similar in spirit, we simplify mattersbydrawingonthepowerofpairsand cross-productstoexpress the relationship between multiple objects in a context.

weassume that type constants and object constants are declared ina signature S which we typically suppress since it never changes duringa typing derivation.we willkeepin mind thatall typing judgments have access to a well-formed signature.


A «Modelica-Port» stereotype could for example be uniquely applied to a SysML port.

users would still be required to manually complete the definition of the Modelica port through the properties of the «ModelicaPort» stereotype.


Without grouping, we would have three intervals with stride three and data width one byte, and each interval should be compared with the rest of memory operations.

if the compiler realizes they form a group, it can consider one interval with stride three and group data size three (see .gure 10.b), and save an important amount of arithmetic and compare operations.


Second, it breaks the complete collaborative text editing workflow into increasingly complex parts users may well benefit from never going beyond the basic steps.

choosing not to represent reviewing as a separate menu option may cause some communicative problems.


Although the situation of 4 successful separated sources gives good accuracy, it does not have very high percentage of occurrence.

the sum of percentage for successfully separating 3 sources and 4 sources has the percentage from 88% to 91% at most of tested levels of noise, so a tracking technique with memory can be used to infer the rest source.


Multiplying by the unroll factor accounts for the in- crease to the number of temporaries and edges added to the interference graph.

this formula tends to overestimate the increase because the compiler per- forms optimizations such as common subexpression elim- ination, dead code elimination, constant folding and others that can eliminate some of the added tempo- raries.


If we add a notion of fair- ness we exclude a few specifically undesirable possibilities.

very often we know a bit more and we would like to assign probabilities to the different possible behaviours.


On the one hand, such an implementation may be used by very many people, which makes optimization worthwhile.

such a library must be very robust and general, which impedes .nely-tuned optimization.


Most feature-level processing tools rely on preprocessed data, such as noise .ltering or multi-touch identi.cation, before the fusion occurs.

this means that data-level processing can typically not bene.t from recognised features as existing architectures enrol a one way propagation of events as illustrated in Figure 3.


We should also note that backtracking is not a rare event.

the number of backtracks is close to half (46%) of the matching attempts, even for an NFA based engine with aggressive tail recursion.


Sharing a computing platform is a natural and e.ective solution to reducing the cost of those systems.

the sharing can cause serious problems in mixed-criticality systems where applications have di.erent levels of criticality.


Similar to DMV, this scheme distributes read-only requests on a cluster of database replicas and replicates writes lazily for scaling.

the con.ict resolution employed by this previous scheme is coarser grained, per-table instead of per-page as in DMV.


Akanksha Prakash1, Jenay M. Beer1, Travis Deyle2, Cory-Ann Smarr1, Tiffany L. Chen2, Tracy L. Mitzner1, Charles C. Kemp2, Wendy A. Rogers1 1School of Psychology Georgia Institute of Technology Atlanta, GA, USA wendy.rogers@psych.gatech.edu 2Dept of Biomedical Engineering Georgia Institute of Technology Atlanta, GA, USA charlie.kemp@bme.gatech.edu  Abstract Successful management of medications is critical to maintaining healthy and independent living for older adults.

medication non-adherence is a common problem with a high risk for severe consequences [5], which can jeopardize older adults chances to age in place [1].


In our sample, we found that 9% of .x revisions involved string literal changes.

it may still be useful to classify these explicitly.


This ultimately leads to scalability issues at higher levels in the hierarchy particularly when overlay links are bandwidthconstrained.

bullet attempts to recover lost data from any non-descendant node, not just ancestors, thereby increasing overall system scalability.


If the query schema is di.erent from the database schema, the query is rejected.

when dealing with XML data, especially when it originates from the Internet, users may not know exactly what the schema is.


To describe what is required of a program does not necessarily require a description of persistent storage it will maintain.

it often seems impossible to give a formal description of required actions that depend on previous history without explicitly capturing that history.


With SystemC, all hard-and software components of a digital system can be described using one language which in addition most hard-and software architects are familiar with.

currently SystemC does not extend the modeling capabilities of VHDL or Verilog HDL but rather resembles them.


Since fewer M often occurs synchronization problem, we should choose adequate M. M should be increased in case 1)an adversary can access the tag easily, 2) a communication error often occurs, and 3) an application is damageable against synchronization problem.

high frequency service by the server is a reason to decrease the M, and smaller M is desirable from the viewpoint of the server cost.


The open class pattern is not unique to Jiazzi; it can also be useful as a convention in Java code outside of Jiazzi components when separate compilation, and especially separate type checking, is not important and source code is open to modi.cation.

jiazzi makes the open class pattern s use more realistic, and also enables con.guration of features with external linking.


Signs that the field is maturing to become an engineering discipline include textbooks on the subject; the work in repeatable design, exemplified by architectural styles and patterns; robust methods for evaluating software architectures; international conferences devoted to it; and recognition of architecture as a professional practice.

treatment of architecture to date has largely concentrated on its design, and to a lesser extent, its validation.


Processes own persistent memory regions and thus all objects allocated in these regions are persistent.

these solutions do not provide the required granularity for serializing individual object states.


It was able to adapt both VM and application con.gurations to the tra.c dynamics.

during workload variations, the performance of both VM-Only and App-Only con.guration agents .uctuated in a large range due to their limited adaptability.


On the other hand, this step could be not making sense in the end of the evaluation because the evaluation is coming to be executed in a few moments and a lot of effort was spent yet.

this is a new proposal evaluation process and a lack of expertise in define the costs in the begging of the process could become enviable the execution of this process.


Thus, if we replace return h3 in test3_internal by return h2, we get the type error Inferred type is less polymorphic than expected Quantified type variable s escapes In the first argument of newRgn , In a do expression: h3 <-newRgn (test3_internal h1) This message adequately describes the error and pinpoints its location.

although the handle h3 is also created in test3_internal, that newSHandle operation actually occurs in the parent region (thanks to liftSIO), so the type of h3 only mentions the monad IORT r m. The type r is quanti.ed in the type of runSIO, called by test3.


"NOTES1 Concurrent task execution may be implemented on multicomputers, multiprocessors, or with interleaved execution on a single physical processor.

whenever an implementation can determine that the required semantic e.ects can be achieved when parts of the execution of a given task are performed by di.erent physical processors acting in parallel, it may choose to perform them in this way.


There may be several applications running simultaneously inside the Lively Kernel, and they all remain active while another application is used.

due to the restrictions of the client-side JavaScript environment, the applications share the same virtual machine that executes them in a single process, and parallel executions have been executed in terms of the JavaScript eventing system at the level of implementation.


Besides, due to the sampling by availability we also made an assumption that the difference on development experiences may not significantly impact the performance on code inspection.

all these assumptions might be questionable to a certain extent.


Another technique based on impact analysis of CSS changes across a web site [14] noti.es the developer if changes made in a CSS .le are introducing new presentation failures in other web pages of the web site.

this technique relies on the availability of the golden version of all the web pages in the web site and is not able to handle presentation failures caused by changes in the DOM structure of the web page.


Because the suggested clauses generalize observed executions, they may not be true; even if true, they may be beyond ESC/Java2 s ability to verify them.

nimmer and Ernst [28] found that (1) users annotating programs are not encumbered by false inferred clauses, and (2) for two of their three subject programs, including inferred clauses had a statistically signi.cant positive correlation with successful veri.cation.


Allowing both operators --which have long left scope --and functions --which have long fight scope --to be ambivalent would require mote complex syntactic rules to insure unambiguous parsing.

an operand 'with an UNDEFINED value opens up the possibility of essentiaUy monadic use of otherwise-dyadic operators.


This enables the implementation of a pro.ling tool that suggests where to insert laziness.

in an impure context, improper laziness can change the semantics of programs and correction requires static analyses.


This information may also be obvious to many observers in certain collections of scenarios for example, many people will understand that banks should not walk around.

as with the ownership issue mentioned above, it is important for scenarios to represent explicitly information such as the mobility of the entity so that observers may have a solid understanding of the interactions that are occurring.


The goal was to possibly enable their reuse across multiple projects.

this generalization process was performed without acquiring specific knowledge of the 5 projects.


The alternative solutions generally only differ with respect to quality attributes such as performance or adaptability, therefore the alternative should be selected which satisfies the quality requirements best.

it is very difficult to focus on multiple quality concerns simultaneously during the design of a software system.


These characteristics are poorly matched to conventional general-purpose programmable architectures that depend on data reuse (captured by hardwaremanaged caches), cannot exploit the available parallelism and cannot support high computation rates.

specialpurpose media-processing processors tailored to one speci.c application require signi.cant design effort and are thus dif.cult to change as applications and/or algorithms evolve.


Clustering techniques can be used to signi.cantly reducetraining cost[30] and sampling canfurther reduce the cost on machines with large numbers of cores.


That shows our prototype implementation is working well enough even in realistic environments.

we have recognized several framework issues.


For every run, and for every pair of nodes, those two nodes can sometimes communicate far beyond their supposed maximum communication radius.

the same pair of nodes have, at an other instant, a very large delay for connection establishment, although they move very close during a few seconds.


2) Similar to product lines, services can be reconfigured into new product architectures.

product lines usually address variability explicitly, in terms of features, assets or decisions, i.e., on a higher conceptual level.


We believe the solution to this problem is to introduce a QoS negotiation mechanism between client application and middleware where the client can agree to certain access patterns, and the middleware can agree to carry out multi-resource reservations to guarantee query execution times.

we want to introduce as minimal complexity as possible to the design of client applications.


We do not want the system to implement heavyweight protocols in support of more consistency than the subscribers need.

we want to promise enough reliable semantics so that applications can confidently react to the states they receive.


While cloud scheduling techniques can be potentially used for scheduling cloud based applications efficiently to Internet cloud resources, these techniques do not consider the mobile network constraints.

the conventional mobile network scheduling techniques do not consider cloud computing constraints when making decisions to schedule users to network resources.


It can be reduced by selecting or developing better tools.

essential complexity is caused by the characteristics of the problem to be solved and cannot be reduced.


It had three goals and failed to achieve any of them over the long term.

two important facts must be discussed at this point.


We found that the programs had the same results for the valid input test before and after the conversion.

we found that the programs returned sensitive information or inserted un-validated data for the SQLIA test before the conversion while all programs returned non-sensitive results or inserted validated data after the conversion.


As seen in the fragment above, Rupert initially interprets these two letters as being part of a word from the previous line.

vollgraff's reading of the start of the line as 'EMI' translates as: to purchase or to buy.


Ownership types reference containment property says that in the object graph all reference paths from a root (all live objects are reachable from root objects which live in the world context) to an object must go through its owner, and in fact through all of its dominators.

effective ownership types effect-based encapsulation says if an object is mutated then its owner, and each of its dominators, must be the target of an active call on the current stack.


It might also help the reader to develop a better mental model of the system's behavior than would otherwise be achieved in a fiat state machine.

by not explicitly specifying all the transitions of a state machine, superstates can also lead to confusion regarding execution of the state machine.


As a result, scopes have not been included into ProProST.

if needed the pattern system could be extended accordingly.


One of the reasons is that Scheme itself is used for implementing writing transformations of abstract syntax trees.

sugar* employs metalanguages SDF, Stratego, and Spoofax editor speci.cations that are independent of the base language.


Figure 11: Experiment result of data padding If the .rst level memory is direct mapped cache, the average execution time will become larger due to the con.ict misses.

the same result as Table 1 can be achieved after data padding is applied, which is illustrated in Figure 11.


For example, in the iPhone dataset, Markov appears to be the most accurate component predictor for Launcher, 0 0 0 5 10 15 20 25 which is similar to previous findings [13, 20].

cell-Geo seems to be a strong predictor for Dialer.


Intuitively, in a well-behaved program, metadata converge into stable states quickly.

this insight canbe exploitedinlifeguardhandlersbycheckingthe frequent case stable state in a fast path while branching intoa slowpathformoredetailed checks.eventhe most optimizedcheckingoperationhastodo metadata access, comparison, andbranch.


Most processors on the market today have them in some form.

commercial compilers still cannot always use the opportunity to improve performance of an application on a SIMD processor by automatically generating SIMD instructions and permutations.


If the client requests the service A, two connectors are instantiated to perform a SLP to UPnP and a SLP to WS-Discovery translation.

only one of the two service providers send a reply that is translated to the client.


With this strategy, low-priority jobs wait time is not bounded by Twaitlmt , as it may take several dispatch operations for them to move to the top of the queue.

our relatively low Twaitlmt value renders a short job queue most of the time, so only a small number of jobs will be a.ected.


This limit comes from the base hypothesis of XTic that states that an expert is a developer who committed in her .eld of expertise.

we can overcome it by performing analysis according to a time window (some weeks or some months) with the objective to normalize production of newcomers with the one of older developers.