3.1 USB Connectivity The e.ective transmission distance of the standard USB interface is about 5 meters.


i,j If k = m = N, RTA detects an optimal task assignment by formulating the problem with QAP.

as the variables of two problems have di.erence, we will de.ne a cost matrix, a distance matrix, and an objective function to detect an optimal with QAP solution.


1 10. cost 7.21 $/slot because it fully exploits the temporal and/or location diversity of power price, carbon emission rate, carbon tax rate and bandwidth price.

the MEBC and [21] Q. Zhang, Q. Zhu et al., Dynamic service placement in geographically distributed clouds, in Proc.


It also facilitates the instantiation of new concrete architectures.

we currently lack procedures for systematically designing reference architectures that are empirically-grounded.


However, the call-graph and control-.ow-graph representations do not adequately capture the multiple contexts in which functions can be invoked, and force the contexts to be the edges of the call-graph and control-.owgraphs.

our framework explicitly distinguishes function-call invocations based on their dynamic context of invocation (call-stacks), which can be much more varied.


Figure 19 illustrates that CSPTU runs faster than both SPTU and LOCSP.

the performance improvement is not dramatic.


Similar to the first level, inter-MB segment merging intends to minimize the overlaps and narrow gaps among all segments.

it has to guarantee that D(Bt) is always smaller than M for t=ct, ct-1, .., ct-N+1.


However, similar to the work on k-anonymity, this body of work targets privacy preservation while maximizing data utility, for the purposes of statistical analysis and data mining.

our goal is to limit the utility of the query result for the translators, such that they can blindly translate its values, while providing complete accuracy for the querying client.


The proof P assumes use of a modular speci.cation for each function.

our analysis needs to refer to the assertions in the local function with respect to the variables of the caller, all the way up to the top-most work function.


Abstract data-types are useful, because whenever an entity behaves like an ADT, we can check whether the entity s operations maintain the ADT s invariants.


Particularly, this pointer is reloaded into the page-table pointer register CR3 upon the occurrence of a context switch that gives control to the thread.

if the thread was executing in simulation-ob ject mode, CR3 would need to be .lled with the address of the sibling PML4 (rather than the original page table).


A direct comparison with these other approaches is beyond the scope of this paper and is currently under investigation.

one advantage of our framework is its transparency to the OS, which was unchanged in our experiments.


Similarly, the project function is typically used for pattern matching, and thus atomic left-hand sides are suf.cient.

there are use cases that do require compound signatures on the left hand side.


Coupling of a type with others can therefore be quantified as the number of imported types, for instance by the Coupling Between Objects (CBO) metric [2].

in presence of subtyping different imported types express different degrees of coupling: at one extreme, if an imported type is declared final, the coupling is maximal, since only instances of this type are allowed; at the other extreme, if the imported type is the root of the type hierarchy (e.g., Object), the coupling is minimal, because any instance is allowed.


The method for reasoning about such programs is not yet established.

the development of the partial evaluator is detailed in the paper to give a degree of con.dence that it behaves as we expect.


They would have been false positives since they are not the root cause of the failure.

these statements are not part of the dynamic backward slice because they do not affect the value at the symptom, and so they would have been .ltered out from the candidate set.


For example, if the self-adaptive application is not in the optimal con.guration for its current execution environment, model analysis may produce an advice to change its con.guration.

if the environment conditions are close to a change and the current con.guration is the optimal for the future environment, the best behavior may be to resign itself to executing for a short period in the sub-optimal con.guration without requiring any adaptation, instead of performing two adaptations in a short time interval.


The second related SRP is History Features, since keeping track of the events occurred is needed to provide versioning.

the sibling SRP are the ones belonging to the same subcharacteristic, i.e.


CasterStats [2] provides audience measurement for streaming media, in the form of reports that can be generated through a web interface.

this appears to be limited to media distributed on the Internet and not broadcast television media, unlike the work presented in this paper.


Hence, the initial reqcan be re.ned y in this case.

as already pointed out above, strengthening guards may lead to increased performance penalties.


Consequently, many memory requests are simultaneously sent to the data-side memory in the VLIW mode.

since the code other than innermost loops is scheduled in an acyclic fashion for the Non-VLIW mode, the latency of the data-side memory is more important than its bandwidth.


Natural language (NL) speci.cations continue to be the most commonly used form (as opposed to formal models, based on a logical framework), accounting for up to 90% of all speci.cations [6].

nL speci.cations are prone to a number of errors and .aws, in particular due to the ambiguity inherent in natural language [11].


We note that not only is the structure of QVT de.ned using MOF, but OMG also uses QVT itself for de.ning transformation behaviour.

execution behaviour is de.ned by a combination of English and .rst order predicate logic.


The current version of the language can utilize features of Visual Studio to ensure much more comprehensive performance testing.

if the code generator of the language is extended to support other platforms rather than .Net, the implementation of generated load test suite must be written from scratch.


These arguments will be evaluated using our plural semantics, which intuitively means that they will be treated like sets of elements of the corresponding type1 instead of single elements, while the others will be evaluated under the usual singular/call-time choice semantics traditionally adopted for FLP.

we have precisely formalized the semantics of this new language through a novel variant of CRWL called CRWLs p. the main goal of this paper is not formalizing this semantics but exploring its expressive capabilities.


For example in Figure 4, the XPointer must point at the same point of the cup in both time frames 24 and 6.

the basic DXED algorithm presented in Algorithm 1 can achieve consistent XPointing effects only if the viewing time frame is the same as the pointing time frame.


Theorem 5 does not apply here, because of Assumption 5.

by Lemma 2, yki/Yk =1/N .0 as N .8, and thus any limit point (p1, y) of the sequence (p N 1 , y N) satis.es the competitive equilibrium optimality conditions.


Thus, the learning order that many learners employed can be extracted as a dependency.

with the decrease of the minimum support, the extracted dependencies were complicated and a unique learning order could not be determined.


The recommendation was sometimes direct, as in you should use X (BEN, CAL, ENU, KEN), and sometimes more subtle, as in you might try X (HAL, GUS).

not all subjects reported this immediate interruption.


Additionally, a qualitative comparison investigating how faithful a given pattern representation is with respect to the original pattern and how it compares to alternative representations (so that a direct comparison with related work is possible) would be interesting.

such comparisons are di.cult because of the lack of precision in the original pattern de.nition in the .rst place.


Examination of the results of AV for Tasks 1, 3 and 5 also indicates it was appropriate to include a visualisation tool in the AJDT, since for these tasks the visualisation is doing better than the purely text-based tools.

asbro can further reduce the time spent on tasks, due to its more compact visualisation.


Among the control transfer instructions, the branch targets of conditional branch and direct jump instructions are fixed, which can be replaced by the TPC address directly.

for Indirect Branch (IB) instructions, whose branch target cannot be determined until runtime, DBT system must perform an address translation from SPC address to TPC address at every execution.


However, these structured and easy-to-read test cases present specific limitations as they can not easily include and describe alternative behaviour paths expressing exceptional conditions.

test cases, written in machine-readable form using programming or scripting languages offer great benefits in terms of repeatability and speed of execution via computer-based test drivers.


In the RoSES project [15],[24], a recon.guration framework for embedded systems has been developed.

the RoSES project does not consider the modeling of dynamic adaptation.


CRC committee members expressed a great deal of interest in seeing the prototype finished and used to replace the current Word template form-submission system.

completion of the prototype depends on using it as the basis for another student project in a subsequent computer science class.


a certain amount of precision with a certain refresh rate is desired.

more complex utility functions could use dependence between QoC attributes.


The other common approach for reducing TLB misses is virtual caching [10,31,45,46,54].

bigmemory workloads often have poor cache performance, so virtual caching merely moves, but does not solve the problem.


This is because the costzones partitioning scheme used in tree-building is based on the cost, not the number, of bodies.

the computational overhead of the update phase is a function of the total number of bodies in each partition.


a content delivery, is characteristically the same as in a slower content delivery.

a characteristic distinction exists between downloading and streaming content as the outcome for the user is characteristically different, i.e.


Consider the following program: fun fx= (print; x) fun gx= if true then x else print dead In conventional terms, the uses of print in these de.nitions are redundant or dead code, and the compiler would be free to remove them.

print is a sited value, it cannot be pickled.


Tools to recognize fault patterns are appealing because they are able to provide quick feedback about potential faults without requiring program execution.

the e.ec- Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage, and that copies bear this notice and the full citation on the .rst page.


Leupers approach is very capable of .nding SIMD instructions in the code, because it essentially considers all possibilities and selects one with the best cost.

it does not scale well with the width of SIMD and the size of basic block.


1.1 Motivation Grid is designed to enable the sharing of geographically distributed autonomous resources.

sensitive resources could be abused by malicious grid applications.


It attempts to allocate exclusive access to a NUMA-node to each request.

if the number of cores divided by the number of concurrent requests is smaller than the number of cores in a NUMA-node, then each request will attempt to acquire exclusive access to that number of cores on the same NUMA node instead (with a minimum of one core).


The modular semantics obtained provides meanings for higher-order programs with constraints and, more generally, Dmodules de.ned on a higher-order constraint domain D.  5.1 Compositional and Fully Abstract Semantics An important aspect to be considered when a declarative language is extended for modular programming is the sound integration of as done in [3].

to obtain full abstraction with respect to the deletion operation, we have to consider pattern models of programs obtained by deleting any signature included in the underlying signature.


256MB 512MB 1GB 256MB 512MB 1GB 1 11 0.95 0.95  outperforms both the fair share and uncontrolled partition ing schemes under both the LRU and LRFU replacement schemes.

the choice of a good replacement pol icy and exclusive caching is crucial to multi-level hierarchies as it is observed that fair share scheme with LRFU and Normalized I/O Latency 0.9 0.85 0.8 0.75 0.7 0.65 exclusive caching can outperform our MLMS scheme with 0.6 BTIO HPIO IOR MPI-TILE-IO LRU and inclusive caching, although it is not better than MLMS with the LRFU policy itself.


For example, testing all possible combinations for 100 features requires testing approximately 1030 con.gurations.

100 instrumentation points is well within the range of medium sized programs.


Compared to alternative observation mechanisms, such as debugging interfaces or virtual machine modi.cations, bytecode instrumentation is often more portable, less complex, and offers higher performance.

observation through bytecode instrumentation also exhibits two signi.cant problems: one concerning the safety of high coverage analyses, and another concerning the semantics of asynchronously executing analysis tools.


There was no organization dedicated to SPL design and development, therefore the organization cost cannot be measured.

we can measure CAB costs, unique costs and reuse costs.


SinceChangeClassi.cation learns from past changes, it can onlybe applied to projects with somerevision history.

itwas observedintheChange Classi.cationproject thatchanges couldbe e.ectively classi.ed based on a history of about 250 revisions [19].


Various regression test selection processes have been developed and have been shown to be cost effectiveness.

the majority of these test selection techniques rely on access to source code for change identification.


The .rst one is the interaction with the user to de.ne system parameters like the degree of freedom for an appliance and to visualize the current state of the smart home for the residents.

the external signals from the energy provider deliver data for the objective function, too.


TR ANSI T borrows from traditional software [18] and hardware [4] protocol description languages to specify the protocol skeleton (i.e., types and variable de.nitions) and transitions (using a guarded command language).

tR ANSI T offers the additional ability to mix concrete and symbolic transitions as snippets, and to under-specify elements of transitions for the tool to infer.


such that they have no repeated occurrences of the same logic variables.

this restriction is immaterial for our intended application, thanks to leftlinearization, a simple source to source transformation, where we replace repeated occurrence of the same variable in a clause head with fresh variables which are then constrained in the body by .


Most studies of information gaps focus on users in learning or tutorial situations (e.g., [2, 20]).

we are interested in the just-in-time learning users undergo to enhance their productivity, i.e., to make progress in solving a problem; we will return to the relationships between our coding scheme and others in Section 5.


With an average patch ratio of 1.32%, CDC-16 follows.

the di.erence to SC-8 (1.45%), and SC-16 (1.59%) are unexpectedly small.


Such a policy will still create more unnecessary links than lazy linking.

deferred linking will reduce some context switches compared to lazy linking.


4.2 Compatible Metadata Representations The wrapper speci.cations described above have proved useful for relatively simple external functions such as the core of C s standard library.

c programs often make use of library interfaces that are much more complex.


With the recently added support of WebGL, web browsers natively support running 3D visualization applications [Marrin 2011].

for the wealth of existing desktop software with graphic interaction, migration to the Web represents several major obstacles: (1) Redevelopment entails signi.cant mastering of languages and standards for web-related programming.


The evaluation also included some new metrics proposed by Shen and Zhao, for example the Crosscutting Degree of an Aspect caused by Pointcuts (CDP), Crosscutting Degree of an Aspect caused by Intertypedeclarations (CDI), and Coupling on Advice Execution caused by Advices (CAA).

di.erently from our study, they did not correlate the proposed metrics with faultproneness of the modules, but with other attributes of the programs (such as LOCC -Lines of Class Code).


Overhead associated with the SQFCFS method is not accounted for in this current work.

since this is not a large distributed system and overhead was not considered with the other methods either, we expect this policy would still outperform methods if overhead were considered.


MS, with few exceptions (all small applications), does not .t any distribution at the 80 CI.

at 90 CI and above, there are good .ts to all of them.


There are di.erences between ReImInfer s result and JPPA s result due to limitations in JPPA as discussed in [8].

jPure crashes on this simple program, throwing an exception that we were not able to correct.


The altered FM is equivalent to the original one as it de.nes the same product space.

constructing a sound stage model for this adapted FM is much simpler as now the selection of GeneralIndex directly in.uences the possi 2200 2000 1800 1600 1400 1200 1000 800 600 400 200 0 CTCR in % Figure 9: Experimental Results established by SCREAM #Inner Loops bilities for selecting or deselecting MetaDataIndex.


The data did not indicate that the use of static analysis tools has a strong effect on software security.

it is difficult to draw strong conclusions using this data due to the large number of confounding factors.


CONCLUSION AND FUTURE WORK Developers perform small-scale reuse regularly during the course of their development activities.

the integration of source code during reuse is tedious and error-prone, even when conducted on a small scale.


Accessing this functionality is a regular process within this system.

basic Function  Extended Invocation Function Figure 1: Functions with Prologue and Epilogue an additional protection of functions or combining them with an accomplishment of transactions is not intended, generally.


This type promotion is formalized as a close operation by Igarashi, Viroli and Rimassa in [8], where the close operation is only applied to the result type of an operation, and in [15], where also the argument types are closed.

in case of nested types, the promotion proposed by these authors may need to discard some type information in order to provide an expressible type [13, Sec.


3.2 Architectural Memory Models The students were now shown how the unoptimized code itself would break on a multiprocessor.

they often had to re-run the following code multiple times, to run into a situation where the underlying hardware actually ends up reordering instructions.


(The transformers can be viewed as a symbolic representation of relations, and their composition corresponds to conjunction and existential quanti.cation.)

when the domain and the transformers are of a certain restricted structure, composition becomes feasible.


[13] describe some issues introduced by overlapping instances.

they do not consider the interaction of overlapping instances with some other type-class system features, such as improvement.


Drivers vary widely in how much code they use for different purposes; a simple driver for a single chipset may devote most of its code to processing I/O requests and have a simple initialization routine.

a complex driver supporting dozens of chipsets may have more code devoted to initialization and error handling than to request handling.


It is associated to a durability criterion evaluated with the ID Cards of hosts.

it still exist an obvious limit to our method.


This is mostly due to improvements on the technical side: increased awareness of the importance of architecture, better refactoring tools, use of patterns in the design documentation, and use of scenarios in requirements and design.

management of legacy-based development is still weak.


Overall, the results showed that the pairs had an 8% decrease in duration with a corresponding 84% increase in effort and a 7% increase in correctness.

the main effects of PP were masked by the moderating effect of system complexity, in that simpler designs had shorter duration, while more complex designs had increased correctness.


We use the set Ki = {ni1 ,ni2 ,ni3 ,···niKi }to denote the nodes that could be visited next, which is determined by the structure of the RG (based on the static constraints as explained earlier).

taking into account the dynamic constraints, gives as a subset of Ki, denoted Li, which can be written, without loss of generality, as Li = {ni1 ,ni2 ,ni3 ,···niLi }, where Li = Ki.


However, lack of involvement of the design, development, and testing team may have been the reason for not .nding the two hidden faults in the Requirements Spec.

this team did tabulate defects found at each of their major development stages.


In this respect, the proposed model is similar to a model of configuration described in [2].

the latter addresses the dynamic nature of the problem by reacting to changes (such as decrease in resource availability), and maximizes the utility in a point-wise manner.


3.1.3 Backtracking search Haskell instance search never backtracks: if no two instance heads unify, then no predicate could be solved by more than one instance.

combined with overlapping instances, this complicates reasoning about instances.


As the structure of the environment is unknown, no good transmission model is available.

in an indoor setting, the user s mobility is restricted by the environment (we cannot go through walls), and we can assume that not all possible movements within space are actually realized.


An activation of a task releases the execution of one instantiation of that task, called job.

tindell s technique did not allow offsets to be larger than the transaction period.


Firstly, the intermediate representations, such as the dependence graph, SSA, and PRE, on which the reuse in scalar and vector processors is exploited, assume that data participating in the computation has the same length.

stream references may have di.erent lengths.


The context factors recorded in a case study are to some extent a function of what is being studied.

we believe there is a minimal set of essential, omnipresent metrics that must be recorded for each study of software engineering technology, whether it be of a software development methodology (such as XP) or of a specific practice (such as pair programming).


Access Control: Its mission is to deny access to users who are not allowed to use a particular resource.

it must ensure access to those users who are allowed.


The authors conclude that the combination of the two approaches reducestheeffortto trackdownfaulty components.

the computational complexity of this approach is determined by MBSD.


This translates into a disk subsystem with two 15K-rpm SCSI disks.

the disk subsystem of a proxy server would need to provide at least 31.2 MBytes/second, assuming 4340 requests/second and a 10% hit rate in the memory cache (which is an optimistic main memory hit rate assumption for proxies).


We might use a simple analysis such as CHA, which considers the class hierarchy of the program and the static type of the object reference at the call site to determine a set of reachable method implementations.

this approximation may be too conservative because CHA considers all the code of all classes declared in the program, including ones that may not have instances in the heap H .


Figure 5(a) shows that vmrncESP is around ~wme as slow as vmmcOmg fbr 4 byte messages and 38 % slower for 4 Kbyte messages.

vmracESP is only 35 % slower than vramcOrQNoFastPathsin the worst case (for 64 byte messages) but has comparable performance for 4 byte and 4 Kbyte messages.


Statement 2 cannot give any guarantee that the results of a verification on a finite-state version SN may be extended to an unbounded S. For example, a deadlock in S may occur only when a certain number k of instances of a model have been created: checking only SN with N<k cannot detect the deadlock.

it is often the case that either a system does not work correctly for a small value of N or it works correctly for every N. Hence, even with small values of N we can increase the confidence in the correctness of the specification: the results of the verification obtained on the approximation give some useful and meaningful hints on the correctness of the original package, although they cannot be automatically generalized.


Search techniques have also been applied to automatically derived concurrent garbage collection algorithms [VYBR07].

our synthesis uses the mathematical structure of a decidable theory to explore the space of all functions that satisfy the speci.cation.


5.4 Comparing Analysis with Measurements The results of our static analysis give an upper bound on the worst-case execution time of kernel operations.

this upper bound is a pessimistic estimate.


Only theclasses written with or after the reviser will access the added membersandthusit is acceptabletoenforceprogrammerstoincludea using declarationin thesource .le ofthoseclasses.

a using declaration helps modular type checking.


Generally speaking, source code based approaches are more promising when system design documentations are unavailable.

there still exists a number of challenges remaining unsolved for software clustering.


Thus test cases for FooBar do not need to repeat these operations.

the states of the Bar object are part of the expected result of the test cases and need to be verified against the actual object states achieved by the aspect code.


For the aim of improving the reconstructed secret image quality, method for obtaining optimal contrast [3] was introduced.

some de.ciencies still remain in the above-mentioned VSS, as described as follows.


If it is not equal to 0, the CSMA-CA algorithm shall return to perform the second CCA, as shown in step 3 of Figure 1.

if it is equal to 0, the MAC sublayer assumes the channel access is a success and shall begin transmission of the frame on theboundary of the next backo.period.


For example, it is reasonable to assume that including 10 lines from the minimal cause of the bug (an important subset of the counterexample trace [6, 28]) might also cause more bug reports to be addressed.

the Normal bug reports in our experiment did include complete counterexample traces, which were on average only 6 events long (and at most 34 events long).


they mention, 3-D stencils are not handled well by overlapped tiling on GPU architectures due to the amount of redundancy computation that is needed for even small time tile sizes .


This is because Mimic captures and compresses the content of the clipboard as binary data, and then transmits it to the server along with the FAR.

the copied objects that follow the OLE format have much larger size in the memory than the originally generated objects.


According to Arnold and Gosling [4], there are two main motivations for .nal: security and performance.

declaring a method m in a class C as .nal can improve security because a programmer cannot declare a subclass that re-implements or overides m. Therefore, one can rely on its implementation wherever m is sent to an expression with static type C or a subtype of C. since Smalltalk is not statically typed, it o.ers no such type-based guarantees in the .rst place.


In theory, this scheme appears resistant to attack because innumerable ISAs can be created for the purpose of program protection.

in practice, researchers have discovered that obfuscation tools that use secret ISAs are much more restricted.


The generalization is often the desired affect.

in some cases an automatically synthesized statechart diagram might also accept unwanted or erroneous paths and thus be overgeneralized .


Both of them contain all the elements that are required to satisfy the requirement scenarios.

the generated diagram has more classes and operations.


While both translations are more ef.cient than the original code, the translation in Figure 3(b) is more ef.cient than that in Figure 3(c).

dependences in different part of the code may (or may not) permit either of the translations.


This method is constructor-polymorphic (just as isEqualLists) to work for a reversible list or any subclasses (whose de.nitions are not given here).

the argument type has to be exact, since binary methods are in 6 Here, the meaning of binary methods is slightly expanded so that they now refer to methods taking another instantiation of This; so the argument type is not necessarily the same as the type of this.


Obviously, a particularly good compact representation would be a name given by the developer in the source code.

the JavaScript language does not require names for many program artifacts, and, as we shall see, nameless or anonymous artifacts are more common than named ones.


OpenJava and ELIDE are also similar in that they allow strings to be dynamically converted to syntax objects and do not support general syntax extensions.

where OpenJava allows a single metaclass to control the compilation of a class declaration, ELIDE allows an arbitrary number of modi.ers.


ViCo: An Adaptive Distributed Video Correlation System Xiaohui Gu, Zhen Wen, Ching-Yung Lin, Philip S. Yu IBM T. J. Watson Research Center Hawthorne, NY 10532 {xiaohui, zhenwen, chingyung, psyu}@us.ibm.com ABSTRACT Many emerging applications such as video sensor monitoring can bene.t from an on-line video correlation system, which can be used to discover linkages between di.erent video streams in realtime.

on-line video correlations are often resource-intensive where a single host can be easily overloaded.


AOSD 06 March 20-24, 2006 Bonn, Germany Copyright 2006 ACM 1-59593-300-X/06/03... $5.00 code needed to add concurrent behaviour to applications.

they fail to eliminate the problems associated with crosscutting.


IMS uses height as priority, which, to some extent, gives more priority to the nodes on the critical path.

if two nodes have the same height, there is no provision for selecting one over the other.


Even with more sophisticated techniques like dynamic bytecode instrumentation, which only instruments methods of interest, pro.ling is usually only used to analyse an application if poor performance is experienced in order to understand the reasons for such behaviour.

the dynamic bytecode 1Please refer to http://www6.informatik.uni-erlangen.


The average number of avoided executions decreases by about 10%, which means a greater number of functions with unique code were generated.

the decrease in avoided executions is much less than the average decrease in generations required to reach the best sequence found in the search, as shown in Figure 21.


It is corrupted , from the standpoint of the functional paradigm, by its use within each method definition of the default control mechanism referred to in structured programming terms as sequence , which requires a series of machine states and hence completely disqualifies Smalltalk as a functional language in the purest sense.

one important element often seen in functional languages is also seen in Smalltalk, namely functions as first-class objects.


These so-called transformation languages aim to ease development efforts by offering a succinct syntax to query from and map model elements between different modeling domains.

development and maintenance of model transformations themselves are expected to make up a substantial share of the lifecycle costs of software products that rely on model-driven techniques [20].


During query evaluation query parameters might be left unbound, returning all possible matches.

binding some parameters to a concrete value (most commonly model elements) e.ectively .lters the match results by removing matches without the selected elements.


Studies show that the use of PREOP significantly increased the students self-ratings of confidence and computing abilities [6, 22].

pREOP does not allow users to simulate sensing or create programs that result in adaptive behavior on the robot (e.g., automatically detect and track objects).


For the set reduction rule, it is tempting to write simply: Mi .ß N .

(M1,...,Mn)C .ß (M1,...,Mi-1,N,Mi+1,...,Mn)C this leads into problems: note that if [M1] · GC = [M2]· GC then [(M1,M2)C]=[(M1)C],but the above rule may let (M1,M2 )C and (M1)C reduce differently.


Selecting a 1 to 1 mapping would imply that the number of threads in the block must be equal to the range of P a, which is the tile size used for the tiling process in the previous step (T A).

it seems more convenient to decouple the size of the threadblock from the size of the tile, which has a direct relation with the amount of data processed by the threadblock.


Acomprehensive survey of these analysis problems and their solutions can be found in Benavides et al.[6].

sPLC 12, September 02 -07 2012, Salvador, Brazil since the core assets include reusable Copyright 2012 ACM 978-1-4503-1094-9/12/09&#0133;$15.00.


More importantly, design rationale schematics offer a means in which a group can mutually discuss, understand, and illustrate the prioritisation of elements given to the formation of a product.

the significance of design rationale schematics, when offered to a variety of diverse collaborators in an open design environment is uncertain.


4 Transient and Dart s checked mode The transient semantics for Reticulated is reminiscent of Dart s checked mode [12], in which values are checked against type annotations (which are otherwise ignored at runtime).

dart s checks are performed under different circumstances than Reticulated s, and these choices cause Dart s type system to be unsound even when checked.


As expected the performance of the C implementation is better than the DistNumPy implementation.

by utilizing two CPU-cores it is possible to outperform the C implementation in the case of the Jacobi method.


In the program class D={int foo(){return 0;}} class C={int m(){return new D().bar();}} the class constant used as de.nition of C is ill-typed (there is no method bar in class D), hence the whole program is illtyped.

a similar program where the ill-typed class constant is only used as meta-expression, as the following: class D = {int foo(){return 0;}} class C = {class m(){return { int n(){return new D().bar();} } } } is considered well-typed, but not deeply well-typed.


Ideally, the compiler would be able to analyze the data accesses perfectly and insert these paging directives precisely where they are needed.

this ideal is not realistic for the following two reasons.


This introduces a tradeoff between ef.ciency and precision, since on one hand, considering each path separately leads to an exponential number of paths to consider.

merging at each join looses correlation information between variables which may be necessary to prove certain properties.


For example, in Figure 1, state 3 of E has a non-deterministic choice over label releaseWriteLock.

in E +u F , this state is reached when F is in state 1, which is deterministic on releaseWriteLock.


By providing the text of the requirements and a set of keywords, a user can iteratively arrive at a set of concern clusters, and get a clear view of potentially aspectual requirements.

because of its pure lexical nature, Theme/Doc involves signi.cant user intervention to obtain a set of concern clusters, and to identify aspectual requirements.


The authors introduce a system where a (1 - e)-fraction of peers and data survives the adversarial removal of up to half of all nodes with high probability.


The original benchmarks in this study were written with medium-grained parallelism; a larger relative improvement can be expected for programs written with .ner-grained parallelism.

even for the medium-grained parallel benchmarks studied in this paper, the signi.cant improvement obtained by the transformation framework underscores the importance of the compiler optimizations introduced in this paper.


FCFS (.rst-come-.rst-served): If process pdoorway-precedes process q and the two processes request different sessions, then q does not enter the CS before p. Previous works [15, 16, 21] have designed algorithms satisfying P5.

for the sake of enhancing concurrency, we will not try to satisfy P5.


At this stage, the novice functional programmer is typically introduced to other sorting algorithms with better asymptotic complexity.

to write the swapping sorts that we have seen thus far in terms of primitive recursive morphisms, we need variants of our cata-and anamorphisms, namely para-and apomorphisms.


Then it is impossible to match the memory area of a communication tile before A2A with the memory area after A2A because we divide the input array into communication tiles along the z dimension.

for a special input with Nx = Ny, we can have the same memory area for A2A source and destination data in each communication tile, by generating the y-z-x layout (as opposed to z-y-x)after A2A and Unpack.


This result implies that one could consider removing the monitors on the shared resources potentially lowering the execution times of the tasks accessing them.

this approach changes the timing properties and hence it cannot be ensured, that there is no race condition.


But in our study, both sets of components measured in series 2 and 3 are implemented in C. However, as pointed out in [26] also object-oriented design implemented in C can cause a Code Size penalty.

reference [5] shows that a good model compiler can eliminate this penalty.


Channels can exceedtheir share and take overfree space, if any is available.

as soon as the bu.er is full, the policy pushesthebu.er sharesbacktotheirjustproportion.


Due to the light traffic of control commands, the uplink delay will be seldom caused by network congestion.

the user commands from the client to the cloud server must be delivered within a user acceptable latency threshold.


Note that ambiguity is inherently a structural problem depending on how a language is de.ned by a regular expression is de.ned, not on the language it de.nes.

the above characterization permits a change of perspective in that it allows us to analyse ambiguity as a .nite number of linguistic equations (of non-empty intersections and overlaps of languages and epsilon-containment).


Introduction Multi-core based processors are widely seen as the most viable means of delivering performance with increasing transistor densities (13).

this potential can only be realized, in the longterm, if the application programs are suitably parallel.


The data for the nearest neighbor method ( NN/Perm ) is taken from [12]; one can see that no test run has a score of 100%, meaning the defect is never pinpointed.

16.51% of all test runs achieve a score of 90% or better, meaning that the programmer can stop her search at 10% of the code in 16.51% of all test runs.


INTRODUCTION The ability to overlay and to register digital information on the user s workspace in a spatially meaningful way allows Mixed Reality (MR) to be a more effective operational medium.

research into software structures, design methods and design support tools for MR systems are still in its infancy.


Cache behavior can also vary signi.cantly depending on the con.guration of the memory hierarchy.

we observe that the true/false sharing is only related to the size of a cache line and the application s behavior, and is independent of the other memory hierarchy parameters.


Predictions made from user tags, which may be left blank, are more accurate because tags themselves constitute an open category set which the uploader selects as most relevant.

a combination of all the features signi.cantly improves the performance (TDU); providing YouTube category further re.nes the predictions (TDU+YT).


We have demonstrated that Function Coverage exposes errors that can remain undetected in test cases that satisfy Global Branch Coverage.

it usually does not expose errors in reachable functions, so these need to be tested separately.


Notably, in [14] a decision procedure, along with an implementation, is presented for the automatic analysis of a class of security protocols which contains the IBM 4758 CCA API.

the protocol class and the decision procedure is especially tailored to the IBM 4758 CCA API.


The merit of that work is mainly in the exploration of the nature of the relations that link FPA and COSMIC BFC.

according to the reported results, the method is of little practical value: on the one hand, it is expensive, since you have to perform most of the FP measurement process (as you need to identify FTR); on the other hand, you only get a relative wide range of possible values for the size in CFP (on average, the estimate is in the 29..+26% range).


If we perform arithmetic using 32 bit numbers, then q 232 and the error probability can be made arbitrarily small with even a small value of c.The ratio r is bounded above by kv.

it has been reported [3] that r typically varies between 0.3to2.8 irrespective of program size.


One obvious concern is the feasibility of recording all collaborative situations.

since the goal of the video is primarily to capture gestures and timing information, and offer context to verbal interaction, even low-.delity streams are suf.cient.


Another approach would be to use as directives method calls which could be linked to a dummy library.

this places unpleasant restrictions 44 on the syntactic form of the directives.


Single event reliability describes the probability that a randomly-selected stimulus will be executed without failures in the long run.

single use reliability represents the probability that a randomly-selected use of the software will be without failures.


Korat s generation of HashSet objects respects non-isomorphism with respect to the (buckets of linked lists) implementation.

dianju s generation respects non-isomorphism with respect to the mathematical notion of a set.


The .rst phase traverses source code and generates constraints akin to .c constraints.

while .c programs specify a correlation between a lock and a location explicitly, in C such correlations must be inferred.


Some of these approaches rely on concepts anaologus to those found in OSIRIS, like late binding.

most of them deal with incorporating traditional (centralized) work.ow orchestration into grid environments,e.g.


An extra argument is reach(a,X) (1) (1) Normal Looping  Tabled Looping Subgoals Answers Alternatives reach(a, b) reach(a, X) (1) reach(a, c) reach(a, a) Figure 1: DRA Resolution for Example 1 added for the predicate reach/3 to record the found path.

this extra argument results in the .xed point of the computation to be in.nite, since there are in.nite number of paths from a to any node due to the cycle between a and b.


Simulation accuracy and .exibility have to be traded-off with simulation speed.

fig.2 shows that our platform, despite being signal-accurate and cycle-accurate, is fast and usable.


Porting parallel applications to the Grid could reduce the total computation time, or it could be used to create solutions with higher degrees of resolution.

the Grid brings with it network state conditions that all too often work to the detriment of expediency in parallel applications.


Finally, as we can see, the time for Tarantula is signi.cantly smaller.

given the superiority of scores produced by our approach, we believe that the added cost is well justi.ed.


One difference is that we have a second helper analysis to identify redundant start monitors calls; many calls are not necessary because they are dominated by a previous call to start monitors.

our approach to stopping monitors differs signi.cantly from Section 3.3.


The tools used in a commercial software development firm may be slightly richer than those in the academic setting.

displacing an existing tool with a new tool-----even if that tool is arguably better--is an extremely difficult task.


Suffice to say that leaving y undefined complicates reasoning, although not nearly as much as allowing aliasing; and that leaving y with either an arbitrary or a distinguished value of its type is actually quite a reasonable thing to do.

we have found that the last approach --swap-ping the values of x and y --is both efficient and safe with re- spect to modular reasoning, and it results in remarkably few changes to how most programmers write imperative code [3].


, but the representation of state in those approaches is based on a .nite state machine that considers the execution path up to that point, and not the set of variable values.

future work could investigate how state-based anomaly detection techniques and the approach presented here could be combined, for instance by further simplifying the representation of expected states according to semantic equivalence.


Type-Based Specialization of XML Transformations Kazutaka Matsuda Zhenjiang Hu Masato Takeichi The University of Tokyo/JSPS Research Fellow National Institute of Informatics The University of Tokyo kztk@ipl.t.u-tokyo.ac.jp hu@nii.ac.jp takeichi@mist.i.u-tokyo.ac.jp Abstract It is often convenient to write a function and apply it to a speci.c input.

a program developed in this way may be inef.cient to evaluate and dif.cult to analyze due to its generality.


The reason is that this is a term typing rule that blocks the evaluation.

we require the coherence of the type environment extension S under G. This is a very important premise because we do not want the incoherence of .


Without deduplication, space reclamation is simple as one has to just migrate as much data as the desired space reclamation.

in deduped volumes there is no direct relation between the logical size of the .le and the physical space occupied by it.


$15.00 Chen Ding Department of Computer Science, University of Rochester, Rochester, NY, USA  cding@cs.rochester.edu strategy in the past utilizes the most space that does not cause data con.icts due to limited associativity (for examples in [5, 10, 18, 25, 32, 39, 40]).

these methods do not consider the effect of cache sharing.


The practicality of our implementation is currently hampered by long compilation times.

we will argue that this problem is not intrinsic, but caused by the inef.cient evaluation strategy of Agda s compile-time evaluator.


The reason behind this choice is to allow for scalability and minimize memory leaks.

paradisEO, which inherits this feature from EO, has a state object which manages every object created by the library.


Of course between the 100% code production and the 100% functionality reuse by toolbridging, it is likely that an intermediate way may have to be found.

what we define here as a case study is the possibility to achieve a significant experiment in virtual tool building.


A .rst step would be to tailor a commodity operating system to o.er only features that are actually required by the application and hardware at hand.

tailoring a commodity software such as Linux has its limitations, as recently demonstrated: A minimal con.guration to run a predetermined service on a speci.c hardware con.guration resulted in about 80% reduced code size, while only half of the known security issues from the Common Vulnerabilities and Exposures database (CVE)1 could be eliminated [16].


Since the diagnostic accuracy of dermoscopy signi.cantly depends on the experience of the dermatologists, and the visual interpretation and examination of this kind of images is time consuming, several computer-aided diagnosis systems of digital dermoscopic images have been introduced.

a reliable ground truth database of manually segmented images is necessary for the development and validation of automatic segmentation and classi.cation methods.


Since a nested module may be compiled to a separate binary (as is the case in Java and Scala), method compile returns a list of all generated .les, which enables Sugar* to keep track of them and initiate a recompilation when necessary.

we do not support extension declarations as nested modules, since we have no means of extracting the extension declaration from the outer module.


Like iTalX, Pizza s internal type system de.nes a join operation over existential types.

to the best of our understanding, the operation computes the join of .a.IList(a)with itself as a type of the form .a « .C is a set of classes not C.a, where .containing a.


It is also interesting to see that the smaller difference corresponds to the much more experienced expert.

with two domains this correlation is not significant.


The set of constraints used in the previous section on WCET analysis contains edges from both the source representation Ga and the target representation Gb, and therefore cannot be used directly in such tools.

when considering the ILP problem for the CFRG, edges e .


In principle this write-barrier could also be implemented in microcode to avoid the expensive invoke of a Java method.

the interaction with the GC, which is written in Java, is simpli.ed by the Java implementation.


This can also be considered a threat, as some underlying phenomena might have been caused by the location.

this bias was addressed by selecting the organizations to represent different release platforms, different business maturities (startup, recent startup, established developer) and different production sizes.


According to our experiment, using the MMU for read access detection puts a high pressure on its TLB and leads to severe thrashing.

without supporting read-only sharing, the K2 DSM detects both read and write accesses solely with the second-level MMU, which has a larger TLB and a hardware page table walker.


This is a great advantage since the rules operate directly on Zinc expression, so transformation rules are often compact.

this integration forces to merge the metamodel concepts of MiniZinc with the MiniZinc syntax.


The problem with this is, Petri nets are not an easy language for modeling workflows.

there are not many theoretical results available with high-level Petri nets, which can be used for analysis[2].


At the concrete level, these arrays are different.

they both represent the same set (more precisely, belong to the same equivalence class) and thus only one need to be explored to generate all non-equivalent DAGs.


So, the corresponding FDU value is equal to two.

number of Features per Use Case (NFU) is used for quantifying how many features are tangled within a speci.c use (a) 1 Composition mode 2 Structured data operations 3 Folder management 4 Content type 5 Create and send a message 6 Receive a message 7 Select and display a message 8 Con.gure composition mode 9 Manage user de.ned folders 1 x x x x 2 x x 3 x x x 4 x x 5 x x x 6 x x x x 7 x x 8 x 9 x (b) 1 2 3 4 5 6 7 8 9 1 Composition mode 2 Structured data operations 3 Folder management 4 Content type 5 Create and send a message x x 6 Receive a message x x 7 Select and display a message x 8 Con.gure composition mode x 9 Manage user de.ned folders x 10 Forward a message x x 11 Structured data operation x x x Figure 7: Features and use case dependences  case.


aPGAS provides a global address space, as its G indicates, so objects can be remotely referenced from other places.


In the worst case, the cost of GC will be as big as in the shared heap system.

since in many applications messages typically occupy only a small fraction of the data structures created during a program s evaluation and since this shared area can be quite large, it is expected that these global GCs will be infrequent.


Regarding the mean monitoring error for the peer count, the tree-based approach even catches up with the centralized approach.

the hierarchical structure results in a biased distribution of results, because leaves or distant nodes from the root obtain  1200 0.9 1000 0.8 800 0.7 0.6 600 0.5   Mean Rel.


5.2 Containment of Detectors in Real-Time Programs In order to show the existence of detectors in hard-masking fault-tolerant programs, we would like to show that the program contains a detector for a detection predicate associated with the fault-intolerant program.

we need to identify syntactic characteristics of a program before detection predicates can be identi.ed.


Specific applications based on such information work exclusively for a single type of content and sometimes even need a special set-up on site.

a classifying or weighting of ROIs can hardly be applied based on bottom-up information only.


Otherwise, these x victim groups undergo hole plugging.

the absorb counts refer to microscopic FTL management activities, and we found the absorb counts fluctuating during runtime.


With only six programs studied, any attempt at a statistical analysis of the signi.cance of this apparent trend would be extremely questionable.

the apparent trend is noteworthy: It may suggest that the choice of .tness function becomes less important as the size of a module increases; perhaps EVM is only more robust than MQ for smaller programs.


Another key di.erence is that reuse of a dead ob ject does not introduce any risk of changing the program s behavior.

since we are looking to share live objects, we face the additional challenge of somehow checking whether a proposed refactoring to introduce sharing is safe or not.


A Haskell solution that exploits this approach is showninOliveira(2007).SinceScala now supportstypeconstructorpolymorphism(Moors et al.,2007), a solution using such an approach should also be possible.

as discussed by Oliveira, abstract types seem to be more expressive than type-constructor polymorphism alone, and allowthede.nition of a slightly moregeneral visitorlibrary.


SELECT ?contentA ?contentB ?connector WHERE { { SERVICE { ?contentA to:connects ?connector } } { SERVICE  { ?connector to:connects ?contentA } } } With this framework, biomedical application developers are provided with the tools to deploy their own seeds and connect them in Knowledge Gardens.

not only this naïve approach is allowed.


The existing work mainly develops OpenGL/DirectX programs to exploit the specialized hardware features of GPUs.

we use a general-purpose programming model to utilize the GPU hardware features, and implement our algorithms with two common building blocks, i.e., scatter and gather.


This allows research into cheap strategies for eliminating inapplicable monitors (indeed [9] demonstrates such a strategy).

it is not appropriate in this context because it would wrongly give the impression that overheads are low, simply because the benchmarks may not heavily engage in the monitored events.


1.1 Motivation Despitethefactthattheterm virtualizationisahottopicnowadays, the main advantages of virtual machines were already summarized back in 1973 [6].

xen s [2] and VMware s [19] current implementationsforthe x86-32 architecturehavelessthanadecade of activedevelopment and more recently theyalso support the x8664 architecture.


1We could similarly perform type .ltering on stores into heap objects.

because all stores must go through variables, such a type .lter would only catch one extra case when the base object is a null constant.


of data aggregation and processing in sensor networks.

ours does not target particular applications but instead provides a generic framework which ful.lls common requirements.


There has been significant interest internationally over the last decade towards fostering a climate for e-research and making Big Science more effective through shared data repositories.

small science still constitutes a significant area of endeavor and challenges of data archiving, networking, and collaboration still persist.


Some of the annotations described above(e.g., NULLTERM and ARRAY) are closely related to the annotations proposed in SafeDrive[43].

the annotations used by DriverSlicer differfromthoseusedbySafeDriveintwoways.First,DriverSlicer uses the annotations to guide the generation of marshaling code, while SafeDrive uses them to synthesize memory safety checks.


Table 8 summarizes the LMS results we obtained.

in this case, the LMS regression model does not appear to be statistically signi.cant.


Graph-Based Application Architecture The architecture of the application is structured by its data-dependency graph.

current debuggers only o.er a sequential view of the source code instruction stream.


RELATED WORK This work focuses on various aspects of cyberinfrastructure: execution management, resource provisioning, work.ow planning and fault tolerance.

there is no prior work that integrates grid and cloud sites through a single provisioning mechanism, nor any enabling execution of work.ow sets with deadline and accuracy constraints.


Their results con.rm the bene.ts of such an aggressive scheme.

being a purely hardware based scheme, the bene.ts are severely (on average, by 30%) a.ected by frequent transitions from active mode to sleep mode and vice-versa because of many short idle periods.


The objective is to provide a meaningful class invariant and this is represented in the instance variables (.elds).

the actual algorithms to test the relations have not been used in previous work on .eld analysis.


Predicting Fault Propagation Faulty states in physical layer are monitored by SCADA systems.

most existing SCADA systems only report faults.


It is not adapted to express methodological inconsistency rules.

the framework not only offers inconsistency detection but also inconsistency resolution based on graph transformation.


This is particularly tricky as the objects being compared are potentially in.nite.

as any in.nite sequence of transitions within either LTS must contain either a function unfolding or a substitution, a record is kept of previously encountered function unfolding and substitution transitions.


To overcome these limitations, we believe a data-driven approach [17] to performance diagnosis should be adopted to leverage the rich telemetry collected from applications and systems in the cloud.

any performance analysis tool may be overwhelmed by the sheer amount of performance data and statistics collected at di.erent levels of the stack.


1.3 Notation and Terminology We believe that our approach to reasoning about syntax is fairly general and does not rely on any special features of the theorem prover we use.

since we implement this theory in MetaPRL, we introduce some basic knowledge about MetaPRL terms.


The crawler repeatedly requests peers from the tracker server untilit can nolongerget any newpeers.

probing peers from the clients is complex.


Scala s implementation uses type erasure in much the same way as Java, so it does not provide runtime access to rei.ed generic types.

scala has two functions that may be used to provide substitute functionality in the user program directly.


We would have wished to make a clear statement on comparing bactracking automata and decision trees.

sophisticated compilation techniques exist that minimize the drawbacks of both approaches.


Other than ABW, applications would also monitor the packet loss rate and apply di.erent forward error correction mechanism.

these techniques can only help applications remedy their performance loss, and not proactively improve it.


Note that we could encode the meta information as an extra argument to M1: data M1 ..f. = M1 Meta (f.) data Meta = Meta String Fixity ...

with this encoding we have trouble writing generic producers, since when we are producing an M1 we have to produce a Meta for which we have no information.


Has the wrong standard been prescribed for the business application?

analyses can also focus on the totality of the non-conforming business applications, e.g.


Assume thread creation order (T 0, T 1, T 2, T 3).

the assertion can also fail via: (a, b, d, e), with one delay/preemption at d. a preemption bound of one yields 11 terminal schedules, while a delay bound of one yields only 4 (note that an assertion failure is a terminal state).


Figure 6c con.rms the robustness of the LATE scheduler even for high amounts of failures and stragglers.

the performance of all other schedulers diminished quickly in the face of failure.


Weaknesses Instructors need to provide an implementation of the algorithm with the weakness and then run each of adversarial inputs through this implementation.

with some work the grading can be made fully automated.


The JITter is not able to perform any optimizations.

replacing the class initializer function with a no-op function at .rst incurs a high runtime overhead.


For example, in adding a new recovery interaction for Sender and Channel component, we cannot add new transitions or ports to Channel.

existing ports could be composed with new ports introduced in Sender.


In the innermost case expression, we can be certain that x has already been evaluated and we might like to use this information to generate better code for that inner case split, by omitting evaluatedness checks.

notice that it translates into Strict Core like so: f = {.x.


The last solution is always replaced by the current solution unless the user explicitly chooses to save it.

this replacement does not occur until after the second solution is constructed.


We wanted to address many of the different aspects of coding style.

the different aspects depend on different properties of the code.


I started considering alternative languages whenI had trouble expressing more complex algorithmsinR.I wasawareof Haskell as my husband both works as a functional programmer and is active in the Haskell community.

one motivation for choosing Haskellwastotakeadvantageofhisexpertise.I found our programming styles surprisingly incompatible, and in practice programmed almost entirely independently.


However, the Eq class already exists as part of the Haskell Prelude, so we cannot modify it to use eqR as the default de.nition of (=).

for each speci.c type, we can use eqR in the Eq instance.


The Poisson regression model is a basic model for count outcomes.

the Poisson regression model has the assumption that the conditional mean of the outcome variable is equal to the conditional variance, something that rarely occurs in practice.


Some of the problems with the segmentation that we describe in this case study may seem obvious to those UCD researchers who are generally skeptical of market research, especially surveys.

we have seen many cases in which UCD people have been swept up in the enthusiasm about quantitative segmentation research, which they see as providing a scientific basis for screening future research participants, without questioning whether the methodology really supports the claims.


The specialized library code has 2.4X fewer SIMD instructions.

the SIMD instructions make up a higher percentage of instructions in the specialized library, more than 80% of all instructions.


More studies need to be performed to address this issue and the issues of how best to present available fault-localization results and how to integrate them with other information useful for debugging.

the more accurate fault-localization methods are, the more meaning ful such studies are likely to be.


Even if instance optimizations have been performed to reduce the array footprint, strictly-equal array sharing, array value set indirection, and caching could realize further savings.

we do not need to recalculate the array sharing hash table, as instance optimizations only elide zeros and do not change element values.


To get this information the R&D Agency depends on the Professional.

the Professional is imposed a constraint (by the Department of Health) to Keep Patient Anonymity.


(Kx :*:) Previously, we produced AnnFix1s by supplying fully annotated AnnFixs to a constructor of ExprF.

producing an AnnFix1 in multirec is not as easy: we cannot supply annotated children to the constructors of the original datatypes Expr and Type because they only accept unannotated values.


In other words, the objective here is to increase TR reuse.

since we are restructuring the code, the impact of our transformations on other aspects of the code (e.g., cache behavior) should be studied as well.


fS(p,n)((n=ip.f=i)1(v=S(,n))) J(v) votherwise Alteringobjetreferenesatrandominagivenprogram doesnot,ingeneral,preservethemeaningofthatprogram.


One may think that instead of unrolling, one could apply DAG-Solve to the body of the loop and then scale the input volumes by the number of iterations.

if the loop has loop-carried dependencies where fluids from different iterations are mixed in ratios, such simple scaling will not work.


Consider the following example [1] x = null; [2] if ( getTransformType().equals("f1") ) [3] x = new T("1"); [4] else if ( getTransformType().equals("f2") ) [5] x = new T("2"); [6] x.foo() The dereference of x at line 6 is a potential null-pointer exception.

the transform author may know that getTransformType() always returns "f1" or "f2".In this case, we need to add a .lter so as not to generate an unnecessary rule.


Moreover, our approach does not pinpoint which of the .le system checkers whose recoveries are being compared has a bug.

we have found it easy to discover through manual inspection which of the .le system checkers has performed an incorrect recovery.


Statistical and machine learning techniques are effective against such static web pages.

javaScript adds a new level of complexity which requires understanding program behavior before it is executed in a browser.


Delta modules generalize feature modules by allowing removal of functionality.

dOP requires to select one particular product as core product from which all products are generated.


In a certain sense, each high-level runtime represents yet another browser target with yet another set of quirks and incompatibilities that developers must account for.

and importantly, a page has complete control over its high-level runtime.


Table 6 shows that as the trace event interval increases steadily as we increase the delay from 1 to 16364.

in Table 7 we see that frame instruction coverage peeks between 256 and 1024 dispatches.


Figure 14 and Figure 15 illustrate the transcoping process for red-black trees and for AVL trees, respectively.

it is also important to note that the candidates that were identi.ed as bad at smaller scopes (for instance, the 5 hybrid predicates (1, 4, 2, 6, 3), (4, 6, 2, 1, 3, 5), (4, 1, 2, 6, 3, 5), (4, 6, 3, 1, 2, 5) and (1, 4, 2, 6, 3, 5) for redblack trees) maintained their condition when transcoping: test input generation exceeded 5 hours as early as scope 8 for all these speci.cations.


In this scenario, we argue that it is possible to combine each approach agile methods and models for software process improvement to get the best of each one.

organizations have difficulties to adapt their agile methods to process improvement models dueto differences between both paradigms.


One way to deal with these challenges is to use a component technology that allows model-and component-based development of the systems with the support for modeling, analyzing, predicting and modifying the execution behavior.

building such a component technology raises many challenges.


If the frequency of messages is low, failure to check the send-busy flag may not cause lost messages because the buffer is more likely to be free anyway.


In these strategies, recording decisions about the architecture plays a pivotal role [8, 22].

we are currently lacking detailed insight into architectural knowledge management practices that can e.ectively be applied in a GSD setting, following observations from the literature on challenges in knowledge sharingin aGSD situation[15,4].


CrowdCode enables developers in a larger project to specify the behavior of a requested functionality as a library through an API (e.g., the API for executing checkers moves in our study), which can be implemented through Crowd-Code and added to the project.

this model imposes a significant burden on the requesting developer: they must precisely specify the behavior of the library, listing descriptions of functions and all necessary data structures.


The outputs of random forest are vote-based, so that it would be mathematically hard to track the estimates of outputs when it is implemented in FTF algorithm.

the randomness of tree building in random forest also breaks the possibility of estimates tracking.


The idea is to predict the values of live-in variables that frequently cause misspeculations.

its applicability is determined by the prediction accuracy.


in case of glimpse, the results obtained from the uncontrolled partitioning and .rst-level only schemes satisfy the SLO, mostlybecause the data set size in glimpse is small enough to .t into the two levels of storage caches used in our experiment.


Not all features need to be shared with other classes of the category.

sOC proposes to encode each concern in a separate module.


In the rest of the paper we have explored the technical challenges that lie ahead.

there is another dimension to moving software development environments to the Web.


Many research attempts presented a .xed set of rules to help .nding errors in a model.

.exibility is one of the characteristics during software development.


Numerous approaches have been proposed to reduce the requirement of a program to access memory, thus mitigating the memory bandwidth bottleneck, for example, improving data locality and eliminating useless prefetches [8] in a program.

as long as the working-set size of a job exceeds the size of the on-chip cache, the e.ectiveness of such approaches is quite limited.


Also, the cycletime required to introduce a small change and verify its correctness was found to be significantly greater for our MDD approach than traditional code-centric approach.

the fact that a model-level change gets automatically reflected at multiple places in a consistent manner was appreciated.


The major differ ence with advice is that a conditional region s condition is statically evaluated by the C preprocessor, whereas aspects conceptually are woven at run-time.

if aspect weavers statically exploit the known preprocessor .ags, aspects are as ef.cient as conditional compilation [1].


Another possibility is that developers are advised not to change any code of other authors, thus are forced to create a clone in order to apply a change.

such development strategies cannot be identi.ed by looking at the change history alone and thus it is not possible to measure their impact on cloned and non-cloned code.


The control and data .ow of these operations would be handled by the JavaMen framework in a similar way to that described in Section 5.

if no hardware component is available, a software instance of MultiplierSoftware is created and all invocations on the Multiplier instance are delegated here.


Under this assumption, it reduces register allocation to a k-coloring problem where k homogeneous registers for m variables are represented as k distinct colors on m nodes in the IG.

this k-coloring problem is no longer directly applicable to the heterogeneous register architecture such as DSP563xx.


In the random ordering case, the replicated and unreplicated data scheduling is interleaved, causing approximately half of the replicated data to be scheduled onto the high priority machine before its idle time is consumed.

the data unique to the high priority machine must be analyzed there, causing it to unnecessarily exceed its idle-time constraints.


The fast-path invocation code sequence generatedby the compiler checkeda frozen bit in the object descriptor.If the objectwasnot frozen, then thefast path code was free to construct the new activation record and jump to the appropriate method code.

if the object was frozen, then the compiler-generated code took the slow pathby calling into thekernel to perform the invocation.


4.3.2 Custom Return Objects In a DSL, some methods may require multiple structured objects, such as an array, to be returned to the caller.

accessing these objects from the outside directly binds the caller to the provided data structures.


2Donald Bren School of Information and Computer Sciences University of California, Irvine {sbajrach,jossher,rsantosm,pfbaldi,lopes}@ics.uci.edu  reuse.

the process of formulating code queries, .ltering the results and weaving them in a developer s workspace is still painstakingly laborious.


Applying Data-driven Tool Development to Context-oriented Languages Marcel Taeumel, Tim Felgentreff, and Robert Hirschfeld Hasso Plattner Institute University of Potsdam, Germany {.rst.last}@hpi.uni-potsdam.de  ABSTRACT There are numerous implementations of context-oriented programming on host languages that come with graphical programming environments.

comprehensive tool support is often missing because building and integrating graphical tools is still laborious; many programmers cannot a.ord to be both tool user and tool builder.


Due to time restrictions during the experiment, we opted not to introduce this additional complexity on our participants.

we believe there are signi.cant opportunities for exploring multi-touch feedback in both soni.cation modes in Timbremap, as well as exploring whether the addition of multi-touch provides a signi.cant advantage for one mode over the other.


they do not transfer to distributed software development in a straightforward way, if at all.


For example, a component interface contract design technique called recasting is sometimes able to achieve this [35,30].

for the rest of this paper, we focus on the more typical case for high-level control software: components where at least one operation takes time (or memory) that depends on the values of program variables in such a way that it is not bounded above by a constant.


2.5.1 Scheduler Modi.cations Inordertoimproveresponsetimes,theshedulermust bewillingtosheduleanappliation'sproessondemand.


Then the handler can fill the related table entry and set this page executable.

this mechanism only works at page-grained, and cannot deal with the case that several entries belong to a same page.


Below is a fragment of the logging aspect output indicating that the call opening the dialogue was synchronous: 3 If really developed independently, the two aspects would have probably differed much more.

the details of the tested example were not relevant for our purpose.


This happens because initially most individuals in that layer have fairly low .tness compared with the neutral layer.

after a certain number of generations the population is close enough to one of the optima and then being on the normal layer is no longer disadvantageous.


Comparison with Type Classes There are no signi.cant differences between the OO version of the program and the Haskell version (which can be found in Figure 14), except that the models need to be named.

client code is more interesting to compare.


DBRover, like MaC, is a monitor that uses a temporal logic with real-time constraints to verify runtime correctness.

dBRover encourages a stronger decoupling of the SUT and the veri.cation process than MaC.


In a shorter time interval, fewer software principals can run and the software execution dynamics has less impact on energy consumption.

measuring or estimating the system energy consumption E for them will be less accurate and less ef.cient.


What is more, they are convinced of its relevance for SE research and practice, and claim that research synthesis is feasible.

we also discovered difficulties in the fulfillment of pre- requisites and the methodological support.


This total interaction is unthinkable for textual languages, and some aspects coming from the integration of paradigms are not present in pure functional languages.

therefore some of the mentionedNiMofeatures are not easily exportable.a number oftheideasherepresented areinnovative and may result ofinterest.


Extraction for pairs is provided by typed projection, and a case construct allows to distinguish variants.

basic noninterference cannot be lifted to abstractions, so that we cannot support arrow types (c.f.


Code generation from class diagrams is widely known and supported by most modern case tools.

code generation from class diagrams creates class frames and method declarations without bodies, only.


This practice, however, may generate a great overhead to create and manage big numbers of virtual machine instances.

cPUReserve can isolate part of a machine processing capacity and assign it to a speci.c process with an almost insigni.cant resource usage.


In such cases, the signals and predicates of an interactor instance may be referenced using the corresponding group s key.

it is often more useful to be able to automatically aggregate across instances.


Users were almost evenly divided between those who agreed, disagreed or had no opinion when asked if they were overwhelmed by the number of interface elements.

when asked specifically about the impact of excess functionality on their activities they were more polarized.


1, both t1 and t2 need to read all their data from the main memory if they are scheduled to di.erent sockets.

if we could schedule t1 and t2 to the same socket, their shared data is only read into the shared cache once by one task, while the other task can read the data directly from the shared cache.


For MVM, Firepile was 15% faster than both the NVIDIA and hybrid con.gurations, indicating that data copying times were faster.

the Firepile version of DCT8x8 was consistently slower than the other con.gurations.


Second, our scheme recovers space by sharing stack across di.erent tasks in the system, while they recover space from within a task.

the work in [3] is complimentary to our scheme in that it can be combined with MTSS to result in a system that detects a stack over.ow using runtime checks and recovers space both within a task and across di.erent tasks, leading to increased system reliability.


INTRODUCTION Usually, researchers and software engineers do not give much attention to implementation methods [1, 6], because implementation mistakes have less impact in project schedule and development costs than mistakes regarding requirements and design.

the e.ort given to requirements and design can be wasted if there is not a commitment with the implementation activity.


The seventh ends in the same function as the .fth marker, schedule insns .

the two phase markers are in different branches, and each invocation triggers one sub-phase but not the other.


5.1 Dependency checking Build systems using the theory from §2 obtain dependencies using the Depends constructor, and cannot use a dependency without explicitly requesting it.

practical build systems must integrate with IO (§3), where dependencies are not always explicit.


Additionally, our go to de.nition properly respects the scoping rules of the language.

using this feature does require that the module is at least correctly scoped this is a restriction that we hope to lift to some extent in the future (see Section 6).


In short, ideal to the developer: the development and execution of a the gap between the smartphone programming style and that senselet will be indistinguishable from a smartphone softof various sensor platforms constitutes a practical barrier for ware module.

such complete transparency is very the majority of smartphone developers to leverage body expensive, if not impossible, given the huge discrepancy sensors and create applications.


An example of a technical DSL is the high-level de.nitionofaGUI,anexampleofabusinessDSL is the de.nition of insurance contracts.

the need to abstract from implementation details is a common motivation and the ultimate goal is to ease the software development process.


The PR strategy ranks the CM changes based on their number of prerequisites.

many CM changes share the same dependence complexity and thus cannot be distinguished by the number of prerequisites.


But after adding a new unit into the system, Unit C, which is a AOP unit that changes the behavior of several units in the system (including their unit tests), we .nd that Unit B stopped working.


It has a wide range of applications in code optimization and software engineering tools.

points-to analysis for JavaScript has not yet been developed.


Quoting Cockburn: [...] it seemed no one could say what a use case was, or name the difference between a use case and a scenario, the basic, attractive idea remained: write a short, textual description of how a system interacts with its surroundings while performing a function of value to one of its users [...] [6].

long ago Jacobson already proposed a useful analogy.


The first is at an ultra fine-grained level, among instruction sequences.

permission to make digital or hard copies of part or all of this work or personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.


This is often due to traditional family roles and linked to a perceived inability to hold their more dominant wandering husbands back.

husbands often find it easier to establish a safe environment for their demented wives, but nevertheless the fear of them escaping from the house and getting lost is high, too.


Despite the experiences in the 1980s, language-directed architectures nowadays experience a resurrection in the form of Java processors for embedded applications.

these architectures concentrate on bytecode execution and offer marginal to no support for real-time garbage collection.


We also note that we are not suggesting that the other topics from the RE 2002 challenge have been fully ad-dressed and that no further research there should take place.

we encourage the continuation of the extensive work on those topics but set additional challenges which also need immediate attention from this community of researchers.


Some readers may think that KLASY can pick the exact memory address by using the information of the variable position pointcutted, which is in the symbol information.

we believe that this approach should often fail because the variable position told in the symbol information is only warranted just before the line is executed.


The technique designed in this work for seminal behavior identi.cation shares certain commonality with the prior technique [19] in that both are based on statistical correlation analysis.


This can be considered run-time composition of dynamic arguments with static code.

not all paradigm concepts are allowed for parameterization.Typically,values and references are accepted arguments, but not types or statements.


a =3 ) in each path, we can distinguish these three paths in a sample taking at vd.

according to Theorem 3, we cannot distinguish these three paths by incrementbased marker methods.


To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior speci.c permission and/or a fee.

workshop on Modeling and Analysis of Concerns in Software (MACS 2005) the tyranny of the dominant decomp osition  states that no matter how well an application is decom posed into modular units, some functionality (or con cern) will always crosscut this decomp osition [17].


The algorithm creates new allowable values as new writes are seen.

the algorithm also discards old values (line 18) as soon as those values are determined to be not allowable.


Hand-written class instances of derivable classes Perhaps even more interesting is Figure 2, in which we specify the number of hand-written instance declarations of classes that  4.2 Usage analysis of preprocessing tools No library on Hackage speci.es in its Cabal .le that it depends on DrIFT.

since DrIFT is an external preprocessing tool using annotations in comments, this does not imply that DrIFT is not used.


AODV nodes do not keep routing tables to reduce storage overhead, and they perform a route request process when a route is needed, which is cached for subsequent use.

it does keep an up-to-date neighbour table by periodically generating hello messages.


The rating message is signed by ps and propagated using the same .ooding-based mechanism as the query message.

the TTL of the rating message is larger than the TTL of the query message by 1, so that the rating can reach all the neighbors of the peer pr that is being rated.


The outcome of the experiment in [13]was, that subjects required less development time in order to fulfill tasks which have a small number of type casts.

for bigger tasks (with even more expected type casts) no difference in the development time was measured.


This motivates both the need for parallelism to reduce latency and the need for adaptation to prevent system saturation, depending on the system load.

existing adaptive techniques [26] decide the request parallelism degree using only system load without considering request parallelization ef.ciency.


We account this higher reproducibility of our approach to two factors the use of the synchronization dependency graph to drive the execution and the pausing of only selected threads during execution.

deadlockFuzzer uses a completely randomized approach for reproducing the deadlocks and also pauses all threads with the required abstraction.


People in both projects had a history of working in waterfall type development, in which global visibility was neither needed nor required from the developers.

in Scrum everybody should care about the whole product, and according to Scrum, teams are responsible for inter-team coordination.


Browser extensions are able to listen for certain events associated with webpages, such as a document load which indicates when a document and all of its resources have fully loaded.

this event may fire before embedded documents (iframes) load, as they depend upon user or location parameters that dynamic pages detect in various ways.


If optimize is passed an expression like 1+0, the second and third methods will both apply, because this expression is both adding 0 to an expression and performing an operation on two constants.

it cannot be said that either of these methods overrides the other, because there are cases where the second applies and the third does not, and vice versa.


The previously expressed containment graph requirement of meta-models and the directionality property for aspect references, can be used as a separation criterion for legacy meta-models.

the criterion only shows potential candidates.


Example of label creep the if statement.

this means that the number of labels assigned to variables will increase [15], often unnecessarily.


Refined HAMSTERS task model for the Monitor AMAN advisories goal in order to evaluate temporal variability This qualitative assessment of variability is a support for reasoning about relationships between output variability and variability sources, in order to highlight possible coupling between functions outputs and detect potential resonance effects.

this conceptual framework does not provide support to estimate and assess quantitative values of functions output variability.


Recently, rendezvous of labeled agents using variants of Universal Traversal Sequences was investigated in [36].

as opposed to what was done for the graph exploration problem (see, e.g., [13, 21, 27, 34]), or for other tasks such as routing (see, e.g., [19, 20, 38]), not much is known about the amount of memory required by anonymous agents for achieving rendezvous.


As shown in table 1, the veri.cation with SPIN does not terminate.

our veri.cation process takes about 18 hours because of the time compilation (with separate compilation, our method would take 10.52 seconds).


However, type manipulations affect the binary code, thus currently we have to adjust the allocation site PC's listed in a field coallocation solution.

the object coallocation solution, which does not require type manipulations, is enforced automatically.


Compression has been noted as a technique to improve the performance of migration, especially if the image contains lots of zeroes [26].

these techniques all impose signi.cant downtimes for VMs.


Much of the work in scratch-pad memory management has eschewed dynamic management techniques due to their associated overheads, and have instead concentrated on allocating memory at compile time.

some of the earliest work into automatic scratchpad management involves the compiler using this memory to store spilled register values[7].This workhasbeen extendedby others to allow global variables to be allocated to scratch-pad memory by the compiler [3, 18], as well as enabling compiler allocation of stack variablesto scratch-pad memory[2,10].these approaches arelimitedinthatthe allocation of scratch-pad memory cannotbe modi.ed at run-time.


Furthermore, the amount of session coordinator changes should be minimal asachangealwaysproducesahighload, e.g.,used bandwidth.


It is roughly linear (in time and space) in the size of the trace.

it requires RPC-style communication (in which the messages are calls and returns) to make its inferences.


The concept of software product line engineering meets this ECS business background.

we should carefully investigate the expected technical, economical, and organizational effects of introducing the strategy into existing products.


Versionable, Branchable, and Mergeable Application State * David H. Lorenz1,2 Boaz Rosenan3 1Open University, Raanana 43107, Israel 3University of Haifa, 2Technion Israel Institute of Technology, Mount Carmel, Haifa 32000, Israel Haifa 31905, Israel dhlorenz@cs.technion.ac.il brosenan@gmail.com Abstract NoSQL databases are rapidly becoming the storage of choice for large-scale Web applications.

for the sake of scalability these applications trade consistency for availability.


Data-aware scheduling strategies exist in cluster and distributed computing [28][29][30].

these techniques are used in scheduling jobs to fit data in disks and to reduce data transfers among cluster and grid computing nodes.


they focus on the entire code (not only methods) and analyze many other kinds of preprocessors (like macros).


We could just as well have dropped an arbitrary sequence of messages in the node queue.

dropping all messages is certainly easier and it makes the fairness rule less complicated.


is a very restrictive hypothesis essentially forbidding the approximation of joins which is the basis for static analysis.


As a result, they can amortize the information of reuse on multiple blocks touched by the same instruction.

as we shall see, their scheme provides unstable performance in a shared CMP cache setting.


The same holds for putlinear , of course, as they are only refactorings of the put and putrefac function obtained by semantic bidirectionalization.

for the combination of the two techniques, we can proceed as follows.


The Maximal Causal Model for prediction: Given a run s corresponding to an actual execution of a program P, we would like our prediction algorithms to synthesize new runs that interleave the events of s to cause reading of null values.

we want to predict accurately; in other words we want the predicted runs to be feasible in the actual program.


2.1 Insuf.ciency of Priority-Based Schedulers Most common operating systems use priority-based schedulers to prioritize processes.

those schedulers lack the concept of idle resource use, and fail to properly control the execution of background processes.


In the cryptographic world, Alice and Bob use a public-key cryptosystem to e.ect a secret key exchange, and then communicate with a symmetric cipher; one would assume that some similar exchange would enable communication with a symmetric stegosystem.

a steganographic channel is fundamentally di.erent from a traditional communications channel, due to its extra constraint of undetectability.


Previous studies [3, 9] that have attempted DRAM power optimization have used a simulation-based strategy, using a set of applications running in isolation (dedicated mode).

this work conducts an evaluation on an actual platform, running a full-.edged operating system with a multiprogrammed workload.


So, it is fast, easy to implement, and requires minimum memory space.

the primitive to be called has to be compiled with the kernel.


More precisely, the relevant history of Pk known by Pj is transmitted to a process Pi viaacausal sequence of messages from Pj to Pi.

the protocol described in Section 5.2 used only a direct transmission of this information.


The students in this pair had the most programming experience and were also frequent IM users.

we did note dif.culties referring to speci.c locations in the code, even for this pair and differences in the depth of their dialogue on the problem to be solved.


As the number of NPCs with distinct behaviors grows, the maximal complexity of those NPCs must decrease to maintain performance.

when large numbers of NPCs are making individual decisions, they may be acting on distinct but very similar sets of information.


All of the generalization phase refactorings are based on pulling up commonalities in multiple aspects into a superaspect.

in the study, there was only one aspect under consideration during the refactoring.


Fortunately, across all Linux kernel versions, there is a standard inline function, PageBuddy(struct page*), that takes a page descriptor structure as the input and returns true if the page is a Buddy page.

the implementation of this function is different for different kernel versions.


AsmL could serve as a way to represent state machine model of the use-case described in this work.

for the use-case, Timed Automata formalism was considered for modeling the system as it can capture timing aspects and enables performing di.erent types of analysis using Uppaal.


This work proposes the development of a DIDS upon a Grid platform.

the resulting DIDS integrates heterogeneous IDSs whereas the DIDSs upon Grids presented by Leu et al.


7.1 Groups as Sets As a set, it is no longer possible to de.ne a re-mapping of the ranks of a group.

for those cases where a remapping is needed it can be accomplished by the following operation, once the group has become a communicator, MPI_Comm_split(comm, 0, newrank, *newcomm).


Therefore, they appear as a natural cheap solution for VoD applications.

applying the P2Pparadigm toVoD systems isadi.cultproblem fortwo reasons: (i) constraints on the piece download order and the low piece diversity in the system drastically decrease the performance of the system and (ii) considering the fact that the download speed relies on possibly sel.sh peers, it is impossible to guarantee any kind of quality of service to the users.


Therefore, the deletion procedure goes like algorithm 9: Algorithm 9 delete records on slave node 1: procedure INT DELETERECORDS(Query q) 2: Int count = deleteFromKDTree(q); 3: if (current cube has shrunk) then 4: Update cube on master nodes; 5: end if 6: return count; 7: end procedure  Figure 3: Cutting Node Cube  4.4 Extended Node Bounding With EMINC, we use bounding technique to .lter unnecessary queries.

eMINC has some limitations and could be further extended to provide much better performance.


Modern JVMs uses generational GC to handle objects that die young.

traditionally there was widely accepted belief that the young Young Generation Size Figure 16.


Although this Datalog program itself is an approximation to the concrete program semantics it is .ow-insensitive, does not handle primitive data, etc., we will informally say that a client query computed with respect to this analysis yields a concrete answer.

we obtain an abstract answer by computing the client query with respect to a k-limited abstraction, which we will discuss in Section 4.2.


A way to test this property is to randomly generate terms and check whether the rewritten version preserves the semantics.

a rule with a complex left-hand side will most likely not match a randomly generated term, and hence it will not be tested suf.ciently.


The algorithm attempts to load-balance the work across all workers during test execution.


Many criteria are generic and can be directly used across di.erent domain analysis executions.

some criteria depend on the scope of the analysis.


This means that .lters are routed further whenever insertion of the .lter into the RT produces new root child.

unlike SIENA s poset the RT allows for a .ne grained interaction between .lters on the attribute constraint level and ensures non-overlapping partitioning of the event space at each level of the RT.


Inside a vehicle there may be a .eld-bus like CAN [8, 9], TTP/A [17] or LIN [20], with a comparatively low bandwidth.

the vehicles are communicating with others in the platoon via a direct wireless link.


In this way, the full in.uence of the fast, circular trajectory is preserved without having to resolve it.

this scheme inhibits straightforward shared-memory parallelism even further, since the update positions need to be computed for each particle and at each time step.


This has been the basis of polymorphic method de.nition and for object subsumption.

a subclass relation in typical object-oriented languages is a name subtyping explicitly declared by the programmer, and is not directly representable by structural subtyping.


In this case, thekeypad input feature can be selected early e.g., by the system builder, when the software for the phone is compiled.

one can also imagine advanced handsets that support interactive input through a combination of a keypad, a touch-screen stylus, and voice.


So we expect a linear overhead compared to regular traits.

future work will focus on evaluating the impact of virtual traits on the size of the codebase.


Functional requirements may be achieved by even monolithic systems without any attention to the design.

to achieve non-functional requirements such as performance, scalability and security, we need to apply some architectural techniques.


6 and 7 it can be seen that the S-Attribute Selection Mode did improve the results of the clustering techniques in this regard.

their results were still inferior to (k, w)-CC s. On average, (k, w)  ( Figure 5: Total number of bad clusters generated for (k, w)-CC with S-Attribute Selection Mode and SLINK, CLINK, WPGMA, A-KNN with N-Attribute Selection Mode.