Exploiting o.ine pro.le data is certainly not a new idea, and has existed for many years [18].

technical challenges prevent the straightforward application of these techniques in a fully automatic virtual machine.


Prior work [21, 6, 3, 7, 8, 19, 10] indicates that this is a feasible solution to a sound reporting of erroneous code.

our work dodges many of the dif.culties in a proper program analysis, relying instead on the type checker to throw out any invalid suggestions on our part.


With the advent of Java and .NET, the possibilities for cross platform and cross language computing have increased greatly.

libraries which support GUIs have, for the most part, not been included in this advance.


As shown in these figures, the coverage of all the methods at this environment is almost the same and is close to 100%.

the number of re-broadcasts is different.


FCF [25], GAFES [36], and CSP based approaches [20][18] [26] support constraints on the stakeholders resources.

our approach handles constraints over both qualitative and quantitative non-functional properties.


Instead, together with a 202 (Accepted) status code, they provide a URI from which to download the response at a later point in time.

as it can be seen from this example, this is only a non-blocking synchronous interaction.


The reason is that multiple tasks may overrun simultaneously and hence run in besteffort mode to compete for the CPU.

the deadline miss ratios are still below 5% and hence meet application performance requirement.


Several approaches have been proposed to integrate i* and OO-Method [1,2,3].

these works only deal with functional requirements and completely ignore non-functional requirements (NFRs).


Middleware is used in a diverse group of application domains such as remote database access systems, distributed transaction systems, cooperating systems, and distributed multimedia systems.

the main idea in all cases is that middleware should provide support to address issues of heterogeneity and distribution.


CONCLUSIONS Preserving consistency between artifacts is not a new research topic.

most researches are focused on specific concerns.


The Delay Scheduling approach delays all the jobs for the same amount of time as long as they do not have local data access.

the impact of data locality varies with the task s input .le size.


After some analysis we concluded that either our tasks are aperiodic with a wide distribution of inter invocation and response times or what is more probable the initial assumption that we adopted from RMA of tasks having a single period and response time does not hold in our case.

it may be possible to identify a small set of typical ( peak ) periods and response times of a task.


After making all scheduling decisions and during the postponed process that maps VCs into PCs, whenever the number of the VCs is lower than or equal to the number of PCs, a valid cluster assignment has been found.

not all VCGs can be mapped into a given number of PCs, due to the constraints imposed by the edges in the VCG.


This memory storage structure makes the smvp subroutine complex, which prevents our compiler from applying PART technique to EQUAKE.

the sparse input matrix has less than 0.01% nonzero elements, which enables our LDSM system to apply PCO technique.


The input buffers and output buffers are sized in the system such that they withstand the asynchronous reads and writes from the system and the environments.

if the system is too slow to consume data from the input buffersorproducedatatotheoutputbuffersinthepre-de.nedrates, the input buffers will eventually be full of data when the environments write (over.ow), or the output buffers will be empty when the environments read (under.ow).


This can be mitigated by using CPU support for single-stepping to ensure that only one instruction is executed before control is handed back to the master s code.

this would increase runtime overhead because of the need for handling the additional singlestep interrupt.


OpenORB [2] is an object request broker implemented over the e.cient component model OpenCOM that provides re.ective mechanisms that may be used to introduce dynamic changes to component-based applications.

openCOM does not provide proper adaptation abstraction for the design of system changes.


This dynamic mergeability behavior could be managed by modifying the operating system and attempting to merge when the available memory is exhausted(a swap operationis requested).

this solution is operating system speci.c and hence limits the portability of our system.


Traditional documentation usually becomes stale in the absence of systematic tools to detect discrepancies between a description and the related code.

approaches such as those described in this paper are not only useful in detecting rules violations, but can better support the traceability of specifications to code artifacts by using approaches that keep the consistency between aspects and base code as described in [30] .


It might be argued that users in general pursue accurate answers and not approximations.

discussions with our focus group suggest that the role of causal relation visualization is to provide the user with a quick overview, and that accurate answers are best found using direct queries and o.ine analyses, not graphical diagrams.


Most examples seem to combine a level editor to create the Initial State, a common feature in videogaming culture20, with lists of choices for the other parts.

the Sims Carnival Wizard allows players to create full games using only predefined lists; it presents a series of choices to players in order to create a game from scratch.


This suggests that further research on measurements other than branches as proxy for complexity would be important.

we would like to highlight that for the templateit project the relative improvement was +68.5%.


Polygraph guarantees correctness as long as the last noti.cation is conservative with respect to the actual compromise time.

for effectiveness and ef.ciency, it is best if replicas receive noti.cations that are earlier in time compared to the prior noti.cations to ensure that they do not discard innocent versions.


This is due to the overheadintroducedbythedata transferbetween host and device memory.

when dealing with more complex con.gurations this overheadis overshadowedbythe advantages of the parallel PSO execution.


In traditional quorum-based protocols, clients access quorums randomly to minimize per-server load.

in the Q/U protocol, clients access an object s preferred quorum.


Moreover, their bound applies to q of any characteristic.

our bounds are the best known and the only ones achieving q m(1 - o(1)) for m = 3.


That is, if the input vectors to ddotp are themselves the results of vector computations, generalized stream fusion will potentially fuse all operations in the chain into a single loop.

the C programmer must manifest the input to the C implementation of ddotp as concrete vectors in memory there is no potential for automatic fusion with other operations.


When carried too far, in too many situations, the approach presented in this pattern will produce technical debt, especially if the focused designs are not done professionally.

one should decide how much architecture work needs to be done in the early stages and how much can be left to be fixed in refactoring of the code.


For example, in Figure 1, the text attribute is used for frames, buttons, and labels.

since the wxWidgets Window class provides for a text attribute, we could use inheritance to de.ne the text attribute for any kind of window: text :: Attr (Window a) String this is not such a good de.nition for a library, as user de.ned widgets can no longer support this attribute.


Like retrieval, deletion can, therefore, not be completely ignored during application development.

it can be simplified by providing this basic functionality within the PersistentRoot class with the database access functionality carrying out the actual data removal from the database (this is discussed in more detail later).


Mathias Schubanz Brandenburg University of Technology Cottbus -Senftenberg, Germany M.Schubanz@b-tu.de ABSTRACT More than thirty years of research on the topic of design rationale (DR) have passed.

as of today there are just some exceptional cases where DR are applied in industrial practise.


Traditionally, ASICs have been used to meet these demands.

aSICs have two major drawbacks: one is the lack of .exibility in functionality, and the other one are the high non-recurring costs involved in designing them.


The advantages are ease of implementation and low deployment overhead, as only one controller is required to manage the composition.

this pattern su.ers from a communication bottleneck at the central controller.


The VENUS-C infrastructure supports both open-source cloud solutions and a commercial ones.

the necessity of porting an application to run it on the VENUS-C infrastructure may be a dif.cult challenge in case of many existing legacy applications due to necessity of using APIs and programming libraries provided by the project.


Another group of techniques, such as cross-browser testing [11] and GUI differencing [25], can also .nd presentation failures.

these approaches assume the existence of a bug-free previous version of the web application and detect failures by comparing against this version.


A great number of users ranging from individuals to large-scale corporates grow and hold on the almighty information to cloud storage services.

the lack of guaranteeing data security is a mortal defect resulting in the strong mistrust of users.


We deem this work very relevant to the present proposal, as it inspired the the idea of graph comparison and similarity measure construction presented in this paper.

the underlying mathematical apparatus in both approaches di.ers drastically.


As a result, the type parameters got very cluttered and Scala s type checker was clearly pushed to its limits.

if anonymous type functions get direct support in Scala, this might be the preferable approach.


Code usually is not intended to evolve during program execution.

programs that are able to manipulate runtime code as well as runtime data can have a number of useful applications, from knowledge representation (e.g.


This formulation solves the freeriding problem, since uploading .les is a necessary condition for being able to download.

we do not explicitly introduce a currency; users must upload .les in order to earn a budget for downloading.


Expressiveness is better than with a TA X O N O M Y, but TH E S AU R I demand more attention to semantics, which can imply more effort during creation and maintenance.

in practice, maintenance may not actually be harder than with a TA X O N O M Y, because the meaning of each TH E S AU RU S entry is more .ne grained and better de.ned it s easier to improve an entry while being con.dent that the rest of the TH E S AU RUS remains consistent.


We made this choice so that programmers do not need to think about the swap relations when writing programs, which could make error messages confusing in some cases.

at runtime, we must consider swaps in order to preserve well-typedness wrt reductions (Subject Reduction).


For example, executing two vector addition chunks with a size of 65536 on a GPU in mc1 takes 71% longer than running one chunk of twice the size.

a scheduler for OpenCL task partitioning requires small chunks, due to the high differences in performance of the heterogeneous devices.


We can use it to directly derive the corresponding SPL instance.

when creating an instance from an incompletely specialized SPL, we have to bind remaining variability .rst.


This inconsistency is because as mentioned earlier, correlation coef.cients cannot capture non-linear relations, whereas the prediction models can.

even though crafty shows high correlation coef.cients between loops and node pro.les, the prediction accuracy of node pro.les is only 45%.


Star is not purely functional like Haskell: it supports .rst-class references, like ML.

star has, like Haskell and F#, a monadic framework for describing effectful computations.


The fundamental knowledge is so important that even if you have a domain expert working with the team, communication could break down when the software engineer has little or no knowledge about the domain.

this can be more severe for multisites and multi-teams.


Furthermore, MetaEdit+ enables the developers to document the rationale for the changes made.

as stated in the Introduction it is not a light weight solution targeting small systems development companies.


The reason is that in case of multiissue negotiation, it is not easy to evaluate many negotiation issues, consequently making it difficult to develop an automated negotiation system.

under current e-commerce environment an automated negotiation system is critical in dealing with complex problems and diverse changes in business environment.


Concerning the discovery (Decentralized), identi.cation (Global), and binding (Dynamic) facets, we do not observe any di.erence due to the properties of the HTTP    RESTful HTTP RPC over HTTP WS-*/ESB Discovery Discovery Generated Generated Binding  Binding Code Code Evolution Platform Evolution Platform State Interaction State Interaction Orientation Orientation Model Model Model (a) RESTful HTTP (b) RPC over HTTP (c) WS-*/ESB Figure 3: Measuring the degree of coupling implied by di.erent Web services technologies RESTful HTTP RPC over HTTP WS-*/ESB 4.1 Discovery Referral Referral Registration 4.2 Identi.cation Global Global Context-based 4.3 Binding Late Early/Late Late 4.4 Platform Independent Independent Independent 4.5 Interaction Asynchronous Synchronous Asynchronous 4.6 Interface Orientation Vertical Horizontal Horizontal 4.7 Model Self-Describing Messages Shared Model Self-D. Messages/Shared Model 4.8 Granularity Fine/Coarse Fine/Coarse Fine/Coarse 4.9 State Stateless Stateless/Shared, Stateful Stateless 4.10 Evolution Compatible/Breaking Compatible/Breaking Compatible/Breaking 4.11 Generated Code None/Dynamic Static Static 4.12 Conversation Re.ective Explicit Explicit Table 2: Web Services Technology Evaluation Summary protocol.

when it comes to the interaction facet, some di.erences become apparent.


The dif.culty with this approach is that if the node is a bridge, its bridge listening port will not be immediately known to the relay.

the relay can attempt to extend cally poll the relays to measure their failure rates, a dishonest client cannot easily fake a STABLE rating.


the policy manager is only concerned with the policy used to manage standalone pieces of content.


The work presented in [21] is one of the most sophisticated approaches reported so far.

its focus is on the verification of correctness properties, though it generates an instantiation of the model as part of its process.


PDA) that have several capability constraints like processor speed, memory size, power consumption, etc.

it is versatile enough to be configurable by users.


Consequently,both strategies computed timeoutsbelow3s, which resulted in restarts of those transmissions whose underlying TCP connections stalled during connection setup.

the stalled connections also reached the destination, albeit some time later.


First, to enable .ne-grain concurrency, ConcurrentHashMap maintains a separate array of Java lock objects where each protects a set of slots in the bucket array.

our system automatically provides word-level contention management to get very similar .ne-grain concurrency without user effort.


This is certainly true if the function argument is an atomic value such as an integer.

for compound values such as lists or trees the look-up time is no longer negligible.


CONTEXTUAL INQUIRY At this point, the research focus shifted to what would be a worthwhile use of the Cybeflink within its then current limitations and within the physical and cultural environments of the study participants.

some Phase 2 and 3 experiments had to be continued to maintain the relationship with participants and their carers.


RELATED WORK Research covering the specific research area dealt with in this work seems limited, especially when it comes to empirically grounded work.


This implies that Java s safety guarantees are not a major factor in performance for this program.

we do see that Java is indeed slower than C and suspect that this is due to the overall performance degradation from the sum total of all of Java s overheads, including ones we were unable to study in greater detail: for example the Henderson frames used for accurate stack scanning, sync-points, procedure call overheads, etc.


The early identification and separation of aspects and base abstractions crosscut by them helps to avoid costly refactorings at later stages such as design and code.

if not handled effectively, the aspect identification task can become a bottleneck requiring a significant effort due to the large amount of, often poorly structured or imprecise, information available to a requirements engineer.


To ensure that JML errors that occur in T or C cannot be discarded by F , the statement could be transformed according to the following pattern:  try { try { try T catch C } catch (JMLError j) { ... // set flag, store j } finally F } finally { ... // if flag set, rethrow j } This ensures that whatever happens, F will be executed.

if execution of T or C gave rise to a JML error j, this error will be stored, and the last finally clause ensures that the complete statement ends with abruptly because of the JML error j.


Compilation of query expressions Query expressions are provided to enable programmers to succinctly write data processing expressions in a SQL-style syntax.


For instance, SCSI controllers and drivers are optimized to reduce the number of interrupts on the receive path, and to impose very little overhead on the send path [23].

this requires offtoading storage related pro- ccssing to customized hardware on the storage controller this approach still requires going through the ker- nel and incurs relatively high CPU overheads.


After applying any LSAP algorithm, we get the assignment of all |T| tasks.

some tasks are assigned to dummy slots that do not exist in reality.


This is what makes it possible to change the bracketing structure.

they play no direct role when making a transition: that is the sole responsibility of the transition function, as before.


It helps when languages offer sophisticated modularization constructs.

with respect to concurrency, other language features like single-assignment are of greater importance.


Server-side self-healing is a well-established discipline and has resulted in substantial cost reductions for data centers.

self-healing on the client side has not been so well-studied.


The OMII installer takes care of deploying AHE services, Postgres database management system, WSRF::Lite plus supporting Perl modules in to a Tomcat container, making installation relatively easy.

a number of users have reported problems with deploying AHE using the OMII installer, due to the relatively limited number of Linux distributions it supports.


The concept of Dependency Injection (DI) is aimed at mitigating the issue of hard-coded references.

current implementations of DI are intrusive in ways that component developers need to foresee future use cases.


Using Clairvoyant, developers can connect to a remote sensor node and issue standard debugging commands as well as some sensor network speci.c ones.

clairvoyant s model of remote access and control is still developer-centric and requires interactive debugging.


Automated static analysis tools can detect some of these mistakes early in the software process.

these tools tend to generate a significant number of false positive alerts.


All the cooperative threads share one stack, tive threads Using the shared-stack may cause the extensive memory copy overhead whenever context switches occur.

the reduced number of context switches and fully deterministic preemption points can alleviate this overhead.


We .nd that YouTube videos have noticeable di.erences compared with traditional videos, making it di.cult to use conventional strategies, such as peerto-peer, to reduce the server workload.

the video correlation presented in YouTube opens new opportunities.


In the Push model, service providers automatically announce the services they provide by sending advertisements.

neither model correctly address the constraints of pervasive computing.


The other approach by H¨ ahnle and Schaefer [26] veri.es features in isolation and than the whole product line similarly to variability encoding.

they assume that features have to adhere to behavioral subtyping, which reduces the applicability [60] and is not assumed in our approach.


Our intention is to demonstrate the advantages of the proposed techniques in their relatively pure forms.6 The performance impact in systems that are hybrids of the schemes with which our techniques are being compared (e.g., a generational system with a copying young generation and mark-sweep-compact old generation) may be smaller.

we believe that the mark-andsweep old generation can also bene.t from object co-allocation.


This took somewhat less than two hours, and even if the approach were very routine this does not fully account for think time to understand intermediate results.

mature tools could make the process less cumbersome than applying a generic tool like GenSet as we have done here.


GPP at work (left) Sample code, (right) Computations Removed vs Assertions Placed Note that to prune the backslices, a WAR memory dependence cognizance is exploited.

this aliasing information may sometimes be easily deduced at the compiler level (especially stack based communication, spill code, callee save and restore memory operations, and absolute address based memory operations).


[*] Type variable S is invariant, but the types: -Byte in Map on 11:9(11:22) -Integer in Map<Integer, Byte> on 11:9(11:13) are not the same type.

replacing Byte on 11:22 with Integer may solve the type conflict.


Re-executing test3 on P2 results in a failure.

not all the changes in the to-be-applied set are considered failure-inducing.


Vaarandi s algorithm is based on the assumption that description words appear more frequently than variable words in system log.


Consequently, our derived transfer functions should be broadly useful, and we believe that our approach can be straightforwardly applied to more programming languages, byte codes, and assembly languages.

it is not clear how to generalize our work to additional abstract domains.


With a much higher temporal locality, long-term caching can have a high hit ratio greater than 85% with caching 10% content.

it may take months to years and a huge amount of storage to achieve such an improvement, for which peer-to-peer techniques can be much e.ective.


The explicit rounding that requires a memory access after most computations does not allow an e.ective register allocation.

when the SSE2 extensions are enabled, the speedup is above average.


In [9], a type-class parametrisation mechanism is proposed to support polytypic extension.

this paper discusses context parametrisation.


An inherent dif.culty with type systems is that programmers have to annotate their code and this puts varying degree of overhead on them.

the type systems do provide guidance on what properties to analyze and infer in order to guarantee other properties like ownership.


If simulation model change or original system .aw elimination is required then the entire process can be performed again to obtain a new formal encoding to verify.

given the .at structure of the simulation traces and encoding methodology suggested by us, an automated translator from simulation traces to formalisms can be easily developed.


Normally grid, the user would also input an estimate of the execution time.

for our energy aware scheduling, the hardware prediction model is employed for predicting the resource behaviour.


This acceptance window is smaller than the initial o.set errors and initially falsely rejectsbeaconsfrom some co-operative nodes.

bymodifyingthebeaconcontention mechanism adverse e.ects of these false rejections can be mitigated.


The set applAll(G,c,m,c¯), formally de.ned in Figure 6, contains all methods of c (either directly declared or inherited) named m whose parameter types are supertypes of ¯c in G (note that for calculating this set all ancestors of c are needed).

in general we cannot be sure that this set actually contains all the applicable methods, since there could exist some m in c for which we do not have in G the type assumptions stating that the parameter types are supertypes of ¯c.


Pre-and post-conditions can formalize an individual method s contract very precisely.


Praktromat [16] provides basic automatic testing of submissions and allows students to review each other s programming projects.

praktomat only provides a text dump of the entire programming project submission.


My initial objective was merely to eliminate the distinction between run-time and compile-time code.

eliminating that distinction also eliminates the distinction between types and objects, and between classes and instances.


Application performance monitoring tools like AppDynamics, or ExtraHop visualize a landscape similar to our landscape-level perspective of ExplorViz.

as far as we know, those visualizations are limited to visualizing nodes and applications.


Thus latencies induced by seeking and rotating of hard disk are eliminated.

because most operations in the trace are read and read frequently files are stored in hard disk in PB-PDC, the reduction of its I/O access time is not as much as our scheme.


The JSR-282 Expert Group has responded to the requests from implementers, application developers and researchers to remove some of the limitations of version 1.0.2 and to add some much-memory model outlined here, and the introduction of needed new features.

we are also mindful a heap-only subset we hope will address some of the of the need for efficiency, particularly in the area on concerns.


Anne Gérodolle France Telecom Orange Labs R&D 38240 Meylan.

france anne.gerodolle@orange-ftgroup.com  while the home network becomes a reality, only few and isolated device islands show some real networked collaboration.


Note that fields in read-only objects may be viewed as a spe- cial case of read-only in practice fields.

because it can be proved that they are read only, cJVM uses a different mechanism to handle them in order to reduce the overhead.


Note how 1 + 1 is evaluated only once, and its result (2) is shared.


The input domain also evaluates the existence of the process instance, process and the event log where the auditTrailEntry element belongs (lines 22 to 30).

the enforce domain (lines 32 to 59) creates an instance of the Event metaclass (line 38) according to Rule R2.


We are aware that the indicator we chose as an inverse approximation of the abstraction level, the number of lines of code, is not scienti.cally established and may be subject to discussion.

we think it is a reasonable approximation in our case because all the candidate languages we use have a similar syntax, inherited from the C programming language.


Both of these approaches use a specialized view to show the program elements related to the current task and place the burden on the programmer to declare the task-specific program elements.

naCIN captures these program elements implicitly, reducing the programmer s effort.


This strongly limits the applicability of all testing solutions that are based on project speci.cations such as modelbased and conformance testing techniques.

the web portal of BusyBox provides a section that describes all the features and the functionalities offered by BusyBox in a structured way.


A speci.cation with many con.rmations and several violations resulting from a missing transition in a particular state is likely to be correct, but must be extended with the missing transition.

a speci.cation with various violations is likely to be the result of an incidental call sequence in the initially analyzed program execution and therefore should be discarded.


The advantage with IR is that it stays within the current room.

iR also requires line-of-sight between the IrDA port on the phone and the beacon.


At the same time complementary e.orts are underway to create so-called mirrorworlds large-scale environments that are essentially detailed computer-models of our three-dimensional real world.

these mirror worlds are for the most part static (for example theyinclude buildings and trees).


In application to type switching, this indicates that we can expect case analysis on the dynamic type of a single argument much more often than on dynamic types of two or more arguments.

this does not mean that pattern matching in general re.ects the same trend, as additional arguments are often introduced into the Match statement to check some relational properties.


Similarly, sets of CDCs containing if BEtA.rthen esin Vand if Etesthen A.rBin Vhave similar problems.

we believe that policy speci.cations relying on these kinds of CDCs are ill-formed and should not be considered in the implementation of actual security systems.


Thus traffic from i to j is proportional to the product of the (excess) concentrations as is the case in gravity models.

in the simplest version of the model there is no analogue for Gij in (2), but we can express the probability in (5) as:  G OAi(t) Pij(t) -~-Z Gi/~Ak(t) k~ k~S sin Ic (9) we use this special form of gravity model, only to determine the destinations.


Chain matrix multiplication The chain matrix multiplication problem also involves computing a triangle of values, since in the de.nition of chain1 i j we have the invariant that i j.

the order in which this triangle is built is different to the de.nition of triangle1.


During the initial stages of Ananta, we assumed that there can never be two replicas claiming to be primary at the same time.

we encountered issues where this assumption was not true.


Static ordering performance is not Benchmark Default OOR Overhead Heap size jess 4.39 4.43 0.84% 15MB 20MB 25MB 30MB 35MB 40MB 45MB 50MB 1.6 jack 5.79 5.82 0.57% 3.8 raytrace 4.63 4.61 -0.59% 1.5 3.6 mtrt 4.95 4.99 0.7% 3.4 1.4 javac 12.83 12.70 -1.05% compress 8.56 8.54 -0.2% 3.21.3    Normalized GC TimeNormalized Mutator L2 MissesNormalized Mutator Time Normalized Time GC Time (sec) Mutator L2 Misses (10^6) Mutator Time (sec) Time (sec) pseudojbb 13.39 13.43 0.36% 3 1.2 db 18.88 18.88 -0.03% 2.8 antlr 0.94 0.91 -2.9% 1.1 2.6 gcold 1.21 1.23 1.49% 1 2.4 hsqldb 160.56 158.46 -1.3% ipsixql 41.62 42.43 1.93% Heap size relative to minimum heap size jython 37.71 37.16 -1.44% (a) Total Time ps-fun 129.24 128.04 -1.03% Heap size mean -0.19% 15MB 20MB 25MB 30MB 35MB 40MB 45MB 50MB 1.5 Table 2: OOR System Overhead  always consistent across architectures.

oOR consistently attains essentially the same performance as the best static order across these platforms.


Its role in web user experience becomes increasingly important.

cSS .les tend to be designed from a result-driven point of view, without much attention devoted to the CSS .le structure as long as it produces the desired results.


JastAdd provides a very constrained form of static AOP where only inter-type declarations and method execution interception are supported.

additional modularisation mechanisms from the compiler construction community are supported in the form of demand-driven evaluation and attribute grammars.


Using edge-coverage as their criterion for reduction, and starting with randomly selected subsets of the test suites, they achieve a reduction in test suite size of between 87% and 95%.

after manually injecting between 7 and 41 faults into the programs, they report a signi.cant decrease in the fault detection capability of the reduced suites, in many cases by up to 100%.


In addition to aforementioned REFINE and TXL, notable examples include TAWK [7], Inject/J [6], the IP environment [10], and the Refactoring Browser Rewrite Engine [9].

these tools are intended for expert use on large and complex tasks.


Most memory de-duplication research has considered consolidating only duplicate pages.

the Di.erence Engine [13] introduced the idea that similar pages could also be consolidated.


In our scenario of dynamic software adaptation for IoMT, ensuring that only the adaptation engineer or the system itself have the ability to drive a software adaptation will avoid unauthorized component deployments, such as viruses, on the MNs.

at the current stage of our research, we are not concerned with security requirements.


The schedctl implementation achieves the next best performance because it is able to notify the OS about which threads hold locks.

enabling schedctl for a lock holder does not always prevent it from being preempted, and when preemptions do occur it still suffers the same weakness as the other spinlocks.


They show that data spreading can provide both performance and power bene.ts, if the working set .ts in the aggregate cache space.

data spreading does not provide bene.tiftheworkingsetistoolargeorthe programdoesnothavea repetitiveaccess pattern.Inter-core prefetching removes thesetwo limitationsbyprefetchingdataintothenext cache.


This is due main because QVT tools have still low robustness and its use is not widely disseminated.

aTL has a framework widely used by an increasing and enthusiast community, with full support to model operations, where, in an integrated way, one can specify and instantiate metamodels as well as specify and execute transformations on them.


It is well-known that minimizing address space size in WSN message packets can obtain signi.cant energy savings by reducing message sizes, since each bit of transmission is known to consume energy similar to 800 instructions [22].

wSNs are ad hoc precisely in the sense that positions and densities of nodes in space are unpredictable, so minimal address space is an environmental property, where minimality may need to be determined in situ.


Some electronic notebooks, such as ipad, force users to write information only once, in the right place, and to use structured meta-data to annotate their data.

from the user s perspective, such restrictions waste their time and is one of the main reasons that many users cited for rejecting such digital notebooks.


a form of dynamic library support for the design tools.

and with more difficulty, additional modelling elements could be added to our modelling languages representing dynamically selected services.


This is a form of product versioning [9], where there is one global version space for the whole Web project, while in .le-based versioning systems such as CVS [38] or RCS [56], each .le has its own version history.

the Fluid version model operates at a much .ner internal granularity the versioned slot level to effectively store, retrieve, compare, and construct versions.


In principle, RBMM should be able to release memory in relatively small chunks, resulting in a .atter memory usage pro.le.

there will always be programs exhibiting behaviours that favour garbage collection.


R2: Some participants had problems remembering the functions of less frequently used Wii-Remote buttons, especially when these changed their functions dependent on the current state of the program.

software buttons can easily display contextsensitive descriptions such that user can directly recall the current function.


5, we can compute bounds on hi(ts) simply by using (6) and (7) from Lemma 5.2.

we then do not use any information from the events c and d. In the ideal case of maximum drift diversity between nodes Ni and Nk (i.e.


The inheritance structures among classes are almost identical in both packages.

despite the surface similarities, the internal details of the implementations differ greatly.


Second, the system is unable to estimate the range to the shooter for one-sided shots.

bearing information is far more valuable than range as the latter can be usually determined by the trained eye based on the terrain given an accurate bearing estimate.


The study of how developer interactions align with the structure of the technical work being carried out, has gained considerable attention of late, inspired by the socio-technical design theory from organizational literature [26].

the relation between talk and work, and how it in.uences ownership and performance of tasks at the individual level is far from a settled question.


A symbolic grammar G. for SimpleCalc replaces the calc concrete productions for letters and numbers with symbolic placeholders: Letters l ::= a Numbers n ::= ß This is a simple renaming change where a and ß are symbolic constants.

with the change, the number of strings of a certain length that can be generated by the grammar reduces signi.cantly.


The compiler should turn o. our scheme for such programs.

the presence of heap data is not rare in embedded benchmarks a survey of the MIBench embedded benchmark suite [13] shows that 17 out of the 29 benchmarks in that suite have heap data.


Despite, in the extended TS2PC4RS, the client performs the role of the transaction manager (TM), we could also use a TM apart as described in the references [1, 23], i. e., the client would ask TM to create a transaction that would be identi.ed by the timestamp returned to the client.

some considerations should be taken to assure that the TM meets the business goal of the client appropriately.


Although we have lots of well-developed tools to help with the graphic design, such as the Adobe Flash Professional development environment [1], these tools are useful to create complicated graphics.

we are not easily able to use common software engineering approaches or design pattern techniques with these tools to improve the e.ciency and reusability of multimedia applications.


It is an open question how to de.ne security for provenance.Someprevious work(starting with [8,31])has considered access control and other security issues for provenanceinformation,butdoes notformalize securitypolicies orprovecorrectnessofimplementations.Chong[14]setsout initial attempts atde.nitionsfor securitypropertiesfor systems in which both data and provenance may be con.dential; this workisformulatedin terms ofdetailed operational traces, but seems adaptable to other forms of provenance.

there are manyissuesthatneedfurther study, such asprivacy and auditin thepresence ofprovenance.


RESTful web services are simpler to understand and implement than those which adhere to the WS-*.

many of the non-functional requirements in web services are not yet addressed, such as security, reliability and control of transactions.


Another possible solution would be to let the SOP class be an observer [15] of persons and companies that is noti.ed whenever an account is exchanged.

it is easy to see that this would result in a design that is even more complicated than the previous ones.


TECA s judgment Saturn s judgment Final judgment 1 Safe * Safe 2 Unsafe Safe Safe 3 Unsafe Unsafe Unsafe 4 Unsafe No judgment Unsafe This is the case which is expected to add precision while retaining soundness.

due to this case, in theory, there is a possibility that Saturn may be reporting a false negative due to its unsound behavior and can lead to unsoundness in our approach.


Coping with these problems at the hardware level has the advantage that software does not need to be aware of them.

such solutions often involve specialized hardware circuitry, making these solutions infeasible in commercial-o.-the-shelf (COTS) systems.


As an example, computation statement given in P rocess3 of Figure 5 is (45-55) cycles.

in our MAG representation, this is expressed with two separate computation statements (15-20) cycles and (30-35) cycles with a data packet (dp4) in between.


c) potentially involves Java serialization since service invocations could ship complex Java types as arguments.

the verbs and objects used in the communication between the client and the service are solely de.ned by the service through the service interface.


Thus, hardcoded and fully specified applications are not a good match for pervasive context.

some level of specification is needed to guide runtime adaptations and autonomic actions.


Fortunately, there exists an easy solution to this problem we can require that each un-annotated binding in rule BIND gets its well, quite similarly to C# or Java.

such a choice would reject many Haskell 98 programs, and hence we did not adopt it in this paper.


In this survey, 35% of respondents stated that agile most closely reflects their development process.

34% indicated that they continue to use either an iterative or waterfall process as their primary software development method.


m (Treeaa kv) brancha kvlr = ina (Branch k v l r)  The leafa and brancha smart constructors can be used to build up annotated binary search trees for an arbitrary annotation type a.

since the annotation type is associated with a monadic context, we now have to build our example tree in monadic style: myTreea :: In a (TreeF Int Int) m .


Data Chunking: In a conventional cloud environment the storage node is mounted on the local .le system of the EC2 VM and accessed directly.

our experiments show S3 is unable to saturate even a small EC2 machine instance,achieving a throughputbetween10MB/s to20MB/s for .le transfer, compared to the EC2 s peak capacity of around 30MB/s.


ponent, the .rst time we discover an outgoing message, we have to explore the effects of this message on the other components, which can be expensive.

as we keep exploring this component, we discover that it sends the same message again in a different execution, and we can thus safely skip the expensive exploration of the other components under this same message.


AC( p) = true In the example of Figure 8, ECC ensures that the path A,L1,L3(t),never_A(t),L2,L3(t + 1), never_A(t + 1) will be activatedat  least once withA=true andA=false.

thiscriterion still not ensuresthe fault detection (input sequences(true, true) and (false, false) meet ECC but do not detect the replacedoperator).


Scanning of each host can produce the vulnerabilities present in the network.

patching or removing all vulnerable software is not always feasible for network administrators, and is not enough to remove the effects of combining multiple vulnerabilities.


The granularity can be a compressed edge, which includes multiple edges from the original graph.

automaDeD keeps the original graph and the compressed graph in memory.


Garbage collectors can determine this, for example by stopping a thread and inspecting its registers and stack.

in the absence of GC, the implementation itself must deal with this tricky problem.


We will continue our description of the method under the simplifying assumption that d= 1 and we have a single search variable xs.

the above naive approach is wasteful in a number of ways.


Results: (1) Use of RP was found to be more efficient and effective than CP.

cP is preferred when advanced planning objectives and constraints exist.


In conclusion, Policy 2 will satisfy all of the speci.ed properties and thus is the better choice for the ABLS system.

we have not discussed guarantees on the correctness of polling results which may or may not be important.


This observation has to be kept in mind when analyzing the data.

we .nd that there is no correlation between structural change or churn and defects at a high level of granularity.


The access to the scheduler must be performed in critical section, and under the protection of a lock.

this lock can be taken for only very few instructions if the other shared objects have their own locks, which allows for greater parallelism.


The only reason to prefer the non-linear model is that it is more similar to the log-log model (see [18]) which probably provides the best interpretation of the Sogeti data set.

the non-linear model is the only valid significant model for the dataset published by Cuadrado-Gallego et al.


It is conceivable that to specify the lexical precedence relation > requires an understanding of LR parsing and the parse table for the grammar being de.ned.

this is not the case, as the lexical precedence relation speci.es a precedence for all contexts (parse states).


If all the objects accessed in .r-1 are also in .r, i.e., pn accesses them also in fr, then .r = .r-1er.

the application of er may have the undesirable e.ect (from the perspective of an adversary) of making pr shorter than pr-1: pn may read the information written by per and avoid accessing some other objects that were previously in pr-1.


In some branches of knowledge, the participant exercises little or no in.uence on the outcome of the experiment.

it is known that in software engineering participants are key players in.uencing both positively and negatively the results of the experiment.


Such software can dramatically improve the productivity of software development, allowing massive reuse of software components across the planet.

without new software architectures, methodologies and systematic approaches towards the development of such software, the gap between web development and software engineering will only grow wider.


Once we clarified these questions we typically feel confident to design and implement even the most complex systems.


As an illustrative example, suppose u and v are adjacent, and say u is assigned the unique node name 1 and v is assigned the unique node name 5.

u may call its link to v port 200 and v may call its link to u port 1080, where these numbers have no relation to 1 and 5.


for i in 0..(2*n-1) for i in 0..(n-1) data[i] = if even(i) data[2*i] = fst(...) then fst(...) data[2*i+1] = snd(...) else snd(...) When working with Pull arrays, the loop structures to the left in the examples above are obtained.


The atomic domain is amenable to formal specification.

we posit that the composition of several atomic domains, and "glue" components can be used to realize [he advantages of the domain concept.


With respect to VMs, currently there is no survey available discussing intermediate language design.

several aspects thereof are discussed separately.


For example, the words worked for may precede a company name in natural language.

for the data validation problem that concerns programmers, these contextual cues are not available or not useful.


Financial Services In the financial services industry, the factors that influenced most project success were: Complete and accurate requirements from project start  Good schedule estimates  Enough time for requirements elicitation  Well-defined project scope  Rewarding staff for working long hours Identifying risk before the start of the project was a factor that most successful projects fulfilled in the financial services industry.

since 40% of failed projects also identified risks before project start, it was not possible to state that risk identification was related to project success.


A milestone and release plan has been decided from a functional point of view.

thinking in terms architecture and build hierarchy has implicitly impacted on the plan.


The Java language has no type-inference.

eclipse, industry-wide IDE for Java actually performs that kind of Copyright is held by the author/owner(s).


On the Java compilers used in this experiment, such a virtual dispatch would typically be eliminated using inline caching, and hence the speedups TSI and TSO would be comparable.

for the Controller experiment, how often the context changes depends on the simulation parameters.


These constraints can be used to generate executable code [7, 24] that tests if the SUT satis.es those conditions using automatically generated input test data [1, 6].

pBT [15] approaches implement algorithms to generate test cases from properties [11].


Pruning of executions does not affect feasibility of the runs, but may reduce the number of runs predicted.

we show that in practice no additional errors were found without pruning.


The downside of this is that it diminishes HeapMD s ability to detect bugs, because the bugs need to affect the stability of a global heap metric.

as the experiments in the next section show, programs include several systemic bugs, that are repeated often enough to affect global heap metrics.


Using classical compositional approaches, a legal ordering can be speci.ed globally [5][2].

every other feature must be known in detail as it probably wraps the desired fragment as well.


Instead of event E we label the edge with the name of the production.

the tests on additional buffers that are not part of the generalized goal state analysis, but have to be fulfilled to allow the production to become part of the conflict set, are noted as condition C. we chose to not use brackets but to code this by color and an italic font type.


However, click-counts are often unreliable since they are heavily in.uenced by GUI layout choices and, even more important, by the level of expertise of users.

to estimate userefforts, we measure the complexity of the mapping speci.cation by means of an information-theoretic technique.


Input via stylus rather than keyboard make it easy for the user to hold the device while interacting with it.


For a web application that is backed by a database, using the verbatim DOM would cause WEBMATE to explore the whole database.

as a testing tool we would like WEBMATE to maximize coverage of the application while visiting as few states as possible.


We have also considered the ISO/IEC 12119 standard as possible candidate for our work.

we found some drawbacks that drove us to prefer the ISO/IEC 9126-1 catalogue: 1) lack of balance in the standard (user interface is a clear example); 2) it seems incomplete at some points (e.g., adaptation to user needs); 3) there are not metrics in the proposed requirements; 4) not only non-technical but also technical attributes are considered, but all of them are put together without clear differentiation.


The continuous self-balancing involved with the tree hurts performance (as will be seen later in the performance evaluations).

the trie-based design bene.ts from good cache locality, and does not have to be balanced while maintaining a constant lookup cost.


These collectors perform well because young objects tend to die at a higher rate than old ones.

these collectors do not examine object lifetimes with respect to any particular program or allocation site.


Number of AOP mechanisms and faults in iBATIS.

iBATIS release Pointcuts Advices ITDs Faults 01 97 94 79 23 01.3 121 118 86 9 01.5 244 240 238 13 02 244 238 237 38  while performing such an analysis based in internal properties of the systems, we should take into account concernspecific characteristics.


UDC (Utility Data Center) of HP [10], autonomic computing of IBM [12], Oracle 10g, Japanese Business Grid pro ject [14] are examples.

since their resource sharing is limited within a data center, they do not address the problems regarding distributed resources.


Constraints are equivalent to what we call consolidation axioms and our approach to implement these axioms is also based on design patterns.

these axioms represent only a subset of the knowledge that must be made explicit at the ontological level.


our approach also applies to situations where the observed erroneous value is not an output value.


Tiling has received a lot of attention in the compiler community [9, 14, 20, 33, 35 37, 44].

the majority of work only addresses tiling of perfectly nested loops.


It not only requires the instructor to be a relative expert in STL and run-time veri.cation, but also requires careful observation of traces where the fault is known to be present and not present, and a number of iterations of trial and error.

instructors can easily come up with a set of reference controllers: a set C+ of positive-labeled controllers that are all known to exhibit the faulty behavior, and a set C- of negative-labeled controllers that are all known to not exhibit the faulty behavior.


Different implementations of this abstract framework may have distinct metametamodels.

the uniformity of this approach alone is limited to the MDE Technical Space.


That is, boolean is not consistent with number.


NETSHM [7] is a sensor network software system for structural health monitoring applications.

we did a broad study of existing sensor network applications and proposed a method of identifying classes of applications for specialized language development.


The systems selects one of the generated SQL strings whenever they access a database.

aspectual-Store allows dynamically changing an SQL string.


In an email triage study by Pierce et al., moving from displaying no preview of an email messages body to displaying one line of previewimproved the accuracyof participants attempting to determine the purpose of messages from 51% to 80% [18].

the addition of more lines resulted in diminishing returns; using .ve lines of preview only improved accuracy to 88%.


Path-based analysis offers high precision and is therefore widely adopted in program optimization and test case generation.

in general, symbolic execution based on path constraint solving faces many intractable problems, including: .


On one hand, the code maintainer has to understand the existing abstractions in the code, and has to understand the constraints in the code for how abstractions can be combined.

the code maintainer has to be able to alter the language of the code, alter its abstractions, reform its abstractions, and create new rules for their combination.


Typechecking for OCaml lambda code or bytecode would have signi.cantly eased development.

using OCaml lambda-code binding for plumbing type variable representations, and myname data, has meant that much of our implementation is orthogonal to internal details of the existing compiler.


There were also many other studies on the migration strategy for a variety of application cases, concerning the issues of where and when a VM should be migrated [14, 28, 31, 33].

few studies are available on the issue of which VM should be the best candidate for cost-efficient migration.


His approach is similar to our approach using genetic algorithms.

he does not need to deal with real-time constraints or fragmentation as we discuss later.


This requires a language with expressive modularization constructs.

it is even more essential to have good tools to support refactoring and remodularization when necessary.


Committing the transaction at this point will publish both the to-space object contents and the reference values that point to the to-space location of the object, completing the transplantation.

there is a window between the time the object is marked for transplantation and the point in the transaction where each member of the referrer set has been protected by being written to within the transaction.


Existing solutions to these two problems require that a performance model for an application is known.

constructing such models is a complex task.


For example, race detection could be used on a production system to provide fail-stop behavior for races, and the delay has no effect because speculative output is not released until the commit phase completes.

for debugging, developers may want to recover the program s state at the time of the access rather than at the end of the epoch.


With the recent availability of GPU libraries for matlab, it has become possible to easily exploit GPGPUs as coprocessors.

this requires changing the code by carefully declaring variables that would live on the GPU, breaking the simplicity of the matlab programming model.


Motivated by dependency provenance, an earlier technical report [10] presented a model of traced evaluation for NRC and proved elementary properties such as .delity.

it did not investigate slicing techniques, and used nondeterministic label generation instead of our deterministic scheme; our deterministic approach greatly simpli.es several aspects of the system, particularly for slicing.


Recently there has been growing interest in the automatic generation of functions from user-provided speci.cations [14, 15, 2], mainly consisting of a type and a set of input-output examples.

the function generation research above is not directly applicable to the generation of generic functions due to their different nature: the approach of Koopman and Plasmeijer [15] does not seem to be able to generate higher-order functions, which is essential for generating generic functions, while Djinn [2] and Katayama s MagicHaskeller [14] generate polymorphic functions but not generic functions.


With regard to SL(ori-scale), since it adopts the PFS only to store checkpoint .les and uses all the 1 million processes/cores to perform the execution, the checkpoint/recovery overheads would be higher than those in multilevel model.

the failure rates would also be fairly high because of too many cores being used simultaneously, which will cause an extremely large amount of roll-back loss.


In the case of eqlist, the reason of the speedup is that the eq function builds the dictionary of equality on lists in each recursive call.

the same type witness argument for lists is passed to the recursive call.


Input non-determinism PULSE provides deterministic scheduling.

in order for tests to be repeatable we also need the external functions to behave consistently across repeated runs.


Therefore, additional accumulations do not add large amounts of new code to the persistent cache.

accumulation largely bene.ts Oracle.As traces from more inputs are accumulated (increasing set number), performance improves with the exception of the Start phase.


Consequently, the rules learned and evaluated may re.ect good practices as well as bad practices.

we believe that competent programmers make more good transactions than bad transactions; and thus, there is more good than bad to learn from history.


Modern architectures often utilize eventbased communication which enables loosely-coupled interactions between components and leads to improved system scalability.

the loose coupling of components makes it challenging to model such architectures in order to predict their quality properties, e.g., performance and reliability, at system design time.


Thus, this approach can only be adopted when there is an underlying business model to the application.

decentralized designs need no large infrastructure expenditures.


This is a welcome step to replace heuristics with (some) rigor in the messy scenarios of limited knowledge and computational power, as we .nd them in the real world.

game theory for steganography is in its infancy, and there are substantial obstacles to be overcome, such as: Open Problem 21 Find equilibria for practical covers, and transfer insights of game-theoretic solutions from current toy models to the real world.


Their system, remarkably, is also able to move processes across heterogeneous architectures.

the transformation introduces a machine-dependent overhead of 1.7-9.6%.


The details are explained in Section 4.2.

such a reduction of the required amount of memory for the right nodes would then make the total left node storage requirement dominate the total storage requirement.


We already observed [4] how the Business Process Model and Notation (BPMN), the Object Management Group (OMG) standard notation for modeling a service choreography, mostly refers to the functional aspects of a choreography, but does not support the speci.cation of QoS properties.

we claim that a choreography description should also postulate the expected QoS to be guaranteed at the choreography level among the interacting participants playing the choreography roles.


Fa¸cade and Combined Command have very similar results.

it is also possible to notice that while for some cases the di.erences are very clear, for others the di.erences are minimal or the execution time of Command is even shorter than with the other solutions.


Semantically, the recording construction does not affect the language recognized; i.e.

: L()= L(R) at runtime, matching produces a side-effect in that a substring matched by the regular expression R is recorded, the result of which can subsequently be dereferenced via the identi.er x.


Informing the developer that an automated annotation has been made is not as critical as a warning or request for annotation.

the automated annotation could be in error and should still be examined by the developer.


Indeed, a digital hardware component is always .nite state and its interface to the rest of the world is simply a set of pins (booleans).

de.ning exactly what the interface of a software component (say a C program) is already challenging (the .ow of control between functions can be hard to determine, functions may take unbounded data structures as inputs, side-e.ects through global variables are possible and sometimes hard to predict, etc.


This use of three di.erent languages makes using, extending and modifying the toolkit harder in the context of a Java based compilation system.

the PMAS uses Java as the single language for all its purposes.


Dynamic taint analysis for sequential programs is straightforward, and ef.cient implementations have been proposed in prior work[25,4,33,5,47].

dynamic taint analysisfor multithreaded programs on multi-core platforms remains a challenge.


After hour 13, it gradually prefers Europe because of decreasing temperature (and increasing temperature in the West Coast).

cAM loads the West Coast data center to maximum capacity until hour 13; this difference in behavior is due exactly to CAM s ability to migrate batches of jobs as explained above.


For example, the meta pointcut for the pattern type callsTo uses AspectJ s call, target and cflow pointcuts, and uses the execs helper pointcut (see bottom of Table 1); whereas the pattern type argSameObj uses dflow to specify that the argument of the .rst method call is the same object as the argument of the second call; and before uses the Tracematches notation to de.ne the order in which method calls occur.

current pointcut languages do not provide enough expressiveness and we needed to create a new primitive pointcut, namely returnTypes, used in the pointcut for the pattern type retTypes.


A lot of work in the .eld of optimization selection uses machine learning methods, which can give results for the performance goals, but give little or no insight on why a particular optimization or a combination of optimizations performs well.


In clinical interviews, most students in both groups were able to give solutions to known problems.

the control students tended to give solutions in terms of code statements and used general terms incorrectly.


On the one hand, capturing information s structure explicitly makes it more concrete, unambiguous and terse.

free-form contents have the bene.t of not being subject to structural constraints, which is important during exploratory work.


It is thus a process in its running environment.

this distinction is not very important so in the remaining of the paper we use interchangeably the terms p-thread, thread and process to roughly express the same thing.


In the steady state of long-running jobs, each job always receives exactly its allocated number of computers.

whenever a new job starts up or a job that had a small number of ready tasks Nj < LM/KJ submits a new batch of tasks, there is a period of unfairness while tasks from blocked jobs run to completion.


KLM, CMN-GOMS, CPM-GOMS) is mainly suitable for modelling the optimal behaviour (skilled behaviour) of users.

models developed using cognitive architectures consider the uncertainty of human behaviour in detail but have not been widely adopted for simulating HCI.


Business users were not willing to supply the requested specifications because they perceived the questionnaire as being to technical.

unstructured and informal collection of requirements by the IS management was considered to be appropriate.


This is reminiscent of the decomposition and join in the relational databases.

there are still Mealy peers whose set of conversations is not prepone and projection-join closure of any regular language.


In earlier work we proposed a process for deriving architectural models from requirements [4][15] .

these proposals handle only the structural view of the architectural design, lacking any behavioral speci.cation of the system-to-be.


There are many known algorithms for converting a program into SSA form [1, 5, 13, 15].

the problem becomes more dif.cult when we consider indirect de.nitions through pointers.


There are numerous algorithms that can be used to perform this task [8], including well known approaches such as hierarchical clustering [14], spherical K-means [7], and model-based probabilistic clustering.

the quality of the generated clusters is highly sensitive to initial parameter configurations, which means that performance may differ from one clustering to another, and there are no guarantees that any individual clustering is an optimal one.


Differences of 20% or so are usually meaningless in this table.

differences on the order of a factor of 5 or 10 are quite meaningful we placed asterisks in Table 2 to indicate those formats for which the differences between the results produced by ANNE and those by LEARNPADS were very signi.cant.


In the ideal setting, this function will return a normal tree v because t values are the same as those of type t , the tree v will contain no digests.

the prover will return a value (h, vP ), where h is the digest of vP .


It is relatively simple to extract code samples from NL sentences, since code samples have many code names while NL sentences do not.

since API documentations have many sentences with code names, the difference between code samples and NL sentences sometime may not be apparent.


Using the annotations, feature combinations with no interactions are discovered and can be neglected.

this point must be evaluated with larger case studies in the near future to support the assumption.


In another case, CloneCloud will decide to execute the application locally if the mobile device is currently disconnected to the Cloud.

it is possible that shortly after that decision the connection is resumed.


Thus, M × R takes a total of 780 minutes.

madLINQ s second multiplication is only 9.5 minutes.


In most instances of domain-speci.c transformation systems (e.g., [1, 4, 8, 15, 17, 25, 29]), the initial program is written in a domain-speci.c, high-level language where the semantics needed to drive the optimizations are explicit in the language.

in our work the computational solver is written in a traditional language (C).


This is even well supported by object-oriented languages, since classes already form such categories and there is an easily observable relation between an object and its class, and vice versa.

the categorization offered by the class structure of the program is not always the best .t for the comprehension task at hand.


The use of preconditions and postconditions as a formal mechanism for documenting code and as a focus for proof of correctness is well known.

we usually think of such conditions as being written by the programmer who knows what is going on in the code.


The scienti.c literature is rich with techniques and tools, most of which use static approaches to reverse engineering class models from the code [19, 4, 6, 10, 13, 9].

a class model contains some dynamic constraints whose implementation is hard to be statically veri.ed.


Adequate analyses, like model checking, can then assure that the speci.cation has been correctly written (i.e., the required feature will actually be executed when it is required).

the use of contexts naturally allows to exclude features (e.g., if the machine is Canadian, cappuccino is not served), rendering in such a way the Excludes-relation.


We notice that the parallelized SPEC benchmarks consume more memory especially when7 threads are used (20%-80%).

the parallel versions of the other 5 programs consume less than 7% extra memory regardless of the number of parallel threads.


If explicitly nonorthogonal approaches were shown to be too cumbersome to use, then the .rst order approximation of orthogonal concerns would be reasonable.

we have shown that the additional complexity created by nonorthogonal concerns can be mitigated by multiple-aspect modeling approaches and interacting simulator architectures.


In particular, if region deallocation introduces dangling pointers, then none of these pointers is dereferenced in the remainder of the computation.

when combining region inference and reference tracing garbage collection, a stronger property is needed that guarantees the absence of dangling pointers during evaluation.


An Aggregate is managed by an Aggregate Manager, which has roughly the same function as a Eucalyptus Cluster Controller.

aggregates can be hierarchical, which means that Aggregates can contain other Aggregates as well as Components.


An alternative function call redirection implementation can use LD PRELOAD, an environment variable that speci.es dynamic libraries (commonly referred to as dynamic shared objects (DSO)) to be loaded into an application s address space early atload time, so that the systemdynamic linkerlooks up thede.nitionsfor unresolved symbols(e.g., externally declared functions).

that implementation works only with shared objects, thus limiting its applicability.


5.2 Inferring likely wrong entities |E| The term P1 (P2/(1 - P2))kE can be used to calculate the likelihood that a subset of entities is the cause.

its computation for all possible sets of entities can be impractical.


The NiagaraCQ system allows the user to specify an action to be performed on the query results.

such actions must be expressed as low-level system calls such as the "MailTo" UNIX command.


Bounding staleness in TACT has similar effects.

as motivated earlier, staleness alone does not fully capture application-speci.c consistency requirements.


Therefore, we have ensured that we get performance improvements for the large benchmarks and do not cause overhead for the small benchmarks.

we fail to improve performance for canneal.


The data can be transferred through a software controlled cache which maintains correctness and exploits reuse among references, especially when complicated aliasing or data dependence exists.

the software controlled cache introduces the extra overhead of cache lookup.


With the objectoriented syntax required to write even a simple program, it is not practical to write imperative code in Java and then transition the students to an object-oriented style.

it is practical to write imperative code segments in C#, so we examined C# in more detail.


For 330.art_m, array flattening or structure peeling could improve performance by 20% and 200%, respectively in Table 2 (a).

the integration of these two optimizations could improve the performance of 330.art_m by 400%.


This analysis should be relatively easy to add either by retro.t or as a post-pass, and may in any case be available in the next release of the tool.

its lack currently inhibits constructive analysis of the resulting data.


For example, in the libec package, the implementation of native method generateECKeyPair throws java.security.KeyException.

the method s Java signature does not declare any exception.


Assume .rst, that the heap does not change at all (which is not correct) and traverse the heap concurrently with the program activity.

the heap is modi.ed by the program threads and we cannot ignore it.


RELATED WORK 7.1 Composing Aspect Extensions Several authors point out the expressiveness drawback in using a single general-purpose AOP language, and emphasize the usefulness of combining modular domain-speci.c aspect extensions [12, 13, 21, 49, 39, 31].

the problem of composition has not received a thorough study.


Both of them successfully extracts SIMD parallelism from various sources, but only for regular accesses that are contiguous or interleaved with static power-of-2 strides.

our method balances inter-and intra-iteration parallelism according to the data reorganization costs even in the presence of arbitrary stride memory references and dynamically decided alignments.


However, to create life-like human head, animators spend approximately 7 months from facial geometry/performance scanning to .nal compositing and use very expensive instruments.

we have developed the Future Cast System (FCS) which can automatically generate subjects CG face models and create the .lm that the generated face models are embedded into a pre-created CG .lm using comparatively low cost equipments.


Limitations and extensions Bit .elds In our formalization, we did not specify the size unit, so that sizes and offsets can be expressed in bits instead of bytes.

this may not be enough to fully implement bit .elds, as they require speci.c alignment constraints.


Fortunately, we can ensure the secrecy and integrity of low-level packets over Net by using some of the techniques described in [2], which discusses the secure implementation of the typed 1-calculus.

besides the secrecy and integrity of packets over Net, correct implementations of ambient calculi (including SA) must carefully devise the runtime representation of the SA s capabilities.


4.2 Enforcing Hygienic Method Invocation Our hygienic semantics for MixGen formulates method invocation as a downward search from the static type of the receiver, allowing method overriding in a mixin instantiation only when the method is included in the bounding type of the superclass.

this search is more elaborate than the standard dynamic dispatching mechanism employed in the runtime systems for mainstream OO languages (Java, C#,and C++) which e.ectively searches up the class hierarchy from the class type ofthe receiver.12 we can e.ciently 12 The method table in each class object reduces this search to a table lookup.


As described in Section 3, the main change in this release was the introduction of reader groups.

the scalability difference between R13B02-1 and R14B is unlikely to be caused by reader groups alone.


In this paper, data transfer between tasks is not directly considered, as we assume data uploading and downloading is part of each task and tasks communicate temporary results through a central storage.


Here we hoped the Sparc would use the spare CPUs to good effect.

the single-threaded concurrent collector could not keep up with the mutators and the benchmark suffered numerous 12-second full-GC pauses.


For those software manufacturers, introducing analysis patterns and business patterns on different abstract levels, they not only share experience of modeling among productions and projects, but also simplify complexity of models and improve qualify of applications.

there is large number of enterprises willing to build integrated framework for applications including legacy systems, customized components etc.


In [19], the authors propose four (4) requirements that a framework for modeling variability in SPL should have to support product derivation.

the product derivation phase in SPL depends on how properly the previous phases are done.


ing the type variable name G (x)from the name of x.

this does not work in practice, where type variables are represented by heap-allocated union-.nd elements to facilitate uni.cation.


John K. Estell The Card Game Assignment (CS1-CS2) Who hasn t written a card game?

for most of us teaching programming courses, our code was written back in the days of command line input and text-only output.


Therefore a larger T reduces the probability of collisions and allows nodes to evaluate more potential parents.

larger T values lead to longer delays until the HEARTBEAT messages propagate throughout the tree.


In general, this feature helps to reject improper string contents at compile time and thus avoid runtime errors.

note that in order to support a fully dynamic creation of types, DEEPJAVA allows any dynamic string content in the de.nition of a dynamic type.


Each semantic artifact has its own advantages, and so we can use each one to bring out different intuition and explore separate aspects of computation.

if we refer to multiple semantics of a language, we need to be sure that they all agree.


CS accepts all jobs (no knowledge of deadlines) but fails to ful.ll the SLA for over 15% of jobs (still non-zero when running on a fraction of the load).

rayon ful.lls 100% of the SLAs it accepts (more on rejection later).


Parallelism bugs leading to non-determinism may still exist even when testing fails to .nd any determinism violations.

in our experiments we successfully distinguished the known harmful races from the benign ones in only a small number of trials.


For example, a simpli.ed system-level model for a single-robot RoboArch system variant is depicted in Figure 5.

annotating each transition in a system-level model is feasible only when the annotations are automatically obtainable by monitoring an existing system.


They are similar to AOX in that programmers are not required to use the complicated pointcut designator of the conventional AOP languages.

we have found that these approaches have a weak point as well; they do not work for an artifact that is augmented by other meta-language, such as a C source file decorated with the macro definitions.


For example, for V5-F2 under RankCP-best, only the top two nodes must be examined to .nd the faulty node, and under RankCP-worst and RankCP-median, only 15 and 4 nodes must be examined, respectively, to .nd the fault.

for some versions RankCP was not e.ective a large number of nodes must be examined.


For the core J9 VM and native libraries this decision worked reasonably well, because the code was already vectoring through a port library layer and thus we could make the name space and API changes in a central location.

all user written native methods (native methods not in java.


The slowdownfallsfrom1.076x to 1.0x as the secondary thread partition rises from zero to seven immediate registers.

in both CAN Send cases, the available idle timeintheprimary threadis short enough that coroutine call time must be minimized, so only a few registers can be swapped.


For simplicity, exceptions, which are rarely thrown during initialization anyway, have been ignored in this paper.

exceptions can be supported by providing a postcondition for each exceptional exit path in the effect clause.


5.1 Available Documented Constraints First of all, the availability of documented constraints would signi.cantly facilitate the testing process.

the fact that there is a set of documented constraints does not imply that one need not search for additional constraints.


The main benefits obtained with the adoption of a modular architecture in the DTV scenario are: 1) new extensions can be easily created, meeting market needs; 2) products can be customized through the addition of new bundles; 3) middleware implementations can be automatically updated to fix bugs; 4) third-party software can be efficiently integrated with the middleware.

an increase in the footprint and a processing overhead are likely to occur.


Those states and classes (if renamed) could have different application.

in DSM, usually the state models are either .xed for each type (in which case, they are taken care of by the code generator) or are generated based on context.


In this paper, we do not allow the type system to derive (non-trivial) liveness properties by itself.

when liveness information is introduced by an oracle (e.g.


designers of interactive systems often fail to account for, leverage, or design in anticipation of these ascriptive capacities of users.


The performance benefits offered by library OS designs did not overcome the need for legacy com-patibility.

the need for security and independ-ent system isolation has increased since the 1990s due to the rise of the Internet.


A typical approach is to calculate the average of those coverage values averaged over all the r runs: 1 k(c) avg(P ) = .

n.(c) c.P in this case, all the CUTs have the same weight.


We discuss this limitation as a threat to validity in Section 4.3.

the enormous size of thedata set(Table2) amor 8 The identi.cation of patterns that might be considered disciplined was an iterative process.


A motherboard can provide a HTX slot to easily build a larger NUMA system.

only a small number of motherboards is available on the market that provide a HTX slot.


This combinatorial object is fundamental in developing interaction tests when all factors have equal numbers of levels.

software systems are typically not composed of components (factors) where each has exactly the same number of options (levels).


data processors and CPmax be the number of all CPs, desolver) can be used to find a solution.

since the primary objective is rate-optimal, we need to iteratively solve the MCRO noted by Pmax, PmaxWe redefine 0-1 variables .. in.. .


Whereas, in OO-H (also in OOHDM and WebML), the navigation models are driven by the process models.

this difference in approach doesn t restrict us to adopt a common straightforward translation from BPM-SV to their process models.


in many special cases there is a unique quiescent state and thus for these cases time is linear.


For instance, the IDE could show the developer if a given variable, .eld, or object belongs to the slice at a given point in time.

we will work on re.ning the dependency model to give the user more .ne-grained control about which statements to include in a slice.


Mobile Augmented Reality Service deployers can do anything inside the speci.cation of the VRML97.

we believe some kinds of constraints to the VRML description helps the seamless integration of Vidgets interaction.


This facet makes decentralised composition, necessary for some distribution patterns such as peer-to-peer, hard to achieve.

the mediation or interaction logic, can be modeled centrally, and subsequently deployed to participants, provided that the runtime infrastructure of the participants supports enactment of the interaction logic[16].


Also, a Ball-Larus-like solution a direction taken by almost all path pro.ling tools  cannot yield the optimally compact path numbering.

we still are left with the following questions: Is there an e.cient algorithm which yield the optimal path numbering for Pertinent Path Pro.ling?


In this case, reversing their execution order would cause a harmful program behavior and thus it is a use-after-free violation.

even if two events contain use-free races, it is possible for the racy events to be commutative for two reasons.


For instance, video streaming transmits data pieces according to the time sequence of the video, so the transmission sequence of the pieces is .xed.

3D streaming transmits data 1http://www.worldofwarcraft.com 2http://www.secondlife.com based on 3D objects viewable to the user, different viewing angles or distances thus would produce individually different transmission sequences.


Therefore, when having several subaspects of IncludeStrategy, the order in which the strategies are added to the set is not relevant.

in some situations the de.nition of aspect precedences is essential.


javaScript has become a victim of its own success and is used way beyond its possibilities, leading to increased code complexity.


For example, to obtain a well-behaved language with substitution and subject reduction, theymust annotate the single cut rule of sequent calculus as three different typing rules, and add anothertyping rule (app)with little proof-theoretic motivation.

every typing rule wegavein Section 3.1was eithera direct annotationof a logical rule in Section 2.2, or else internalized one of the cut or identity principles.


A standard call would now perform the calculation of the RAID 6 syndromes inside the kernel and would jump to step 7 of the control .ow in Figure 1.

barracuda forwards the call from the RAID 6 driver inside the kernel to an user space daemon, which again forwards the call to the Hardware accelerator in step 4.


Since anticipatory scheduling can minimize the disk I/O switch cost during concurrent application execution, it diminishes the performance bene.t of competitiveprefetching.

anticipatory scheduling may not be e.ective when: 1) applications exhibit alternating sequential accesspatterns(asinBSD diff, the microbenchmark Two-Rand-0, and index searching);2)substantialprocessingtime existsbetween consecutivesequential requestsfromthesameprocess(as  0 IBM disk Seagate disk RAID0 Storage devices Figure11:Normalizedinverseof throughput fortwo server-style concurrent applications on three di.erent storage devices.


5.2 Inverting After performing a translation, it often happens that the source information is lost.

if we had a schema mapping which does the inverse data exchange, we could restore the original source data or something relatively close to it.


In particular, TWIF tries to .nd the optimal instruction sequence only in a single top-down pass by using a modi.ed Aho-Johnson s algorithm [1] based on dynamic programming.

vPO can invoke the instruction selection pass iteratively during the optimization process as the GNU compiler does.


For instance, many users with download bandwidths greater than 3.5 Mbps are likely on university and corporate networks and therefore have much higher upload bandwidths than the 768 kbps assumed here.

a benign peer-assisted VoD system may not want to fully exploit the available bandwidth of the high capacity users, as doing so might deter their participation.


For instance, an architect can decide to design the middle tier of a 3-tier application to be stateless such that middle tier components can scale, i.e., safely be replicated and loadbalanced.

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


Initially, the target table contains nulls, implying that no area may be compacted into another area.

whenever a thread compacts an area into itself (or similarly into another area), it updates the values of the compacted area entry (or the target area entry, if di.erent) in the target table to point to the beginning of the remaining free space in the area.


The subtlety of the changes in the evolution of knowledge, as well as the distribution of the processing in a parallel architecture, cater for greater robustness in the process of learning, with good performance even when considering noisy or missing information [17].

in trained neural networks, the learned knowledge encoded in the large set of numerical weights in the network structure cannot be understood or explained by an external entity [2].


Given a dynamic component model like OSGi and a suitable adaptation and validation mechanism, it seems feasible and straightforward to come up with software components supporting Plug and Play.

what appears like a trivial integration of existing mech-anisms at a first glance, reveals a number of complex issues when the requirements for software PnP are examined more closely: We identified three categories of challenges that have to be tackled to enable fully functional PnP for software components.


Consequently, the technology provides the potential of integrating the method engineer role into the project team s day-to-day work.


Our conservative tests (bruteforce or chordal-based)are more costly than the simple tests of Briggs and of George.

by using them only when the quick tests fail and with additional implementation strategies, our .nal algorithmisless than2× slower than theiterated register coalescing ofAppel and George.


In practice, the incremental testing and releasing are highly unlikely to negatively a.ect a large number of users if the process is carefully administered.

such incremental releasing essentially includes end users as part of the development team as testers, and enables the development of complex, reliable, and high-quality software yet keeps the core engineering team surprisingly small and well-communicating.


More recently, aspects have been seen as a way of maintaining the higher layer of abstraction of patterns [11].

the vast majority of developers and software engineers sees patterns from the level of UML diagrams.


In practice, we usually only measure the last-level cache because it dominates the total cache size.

on the M2070 GPU, the sum of the L1 + register.les (2.7 MB) is larger than the L2 (512 KB).


the components of a point) used in the domain and array library is int.

a program may require an index space that exceeds the bounds of the int type (generally 32 bits on most modern platforms).


The experiment results are plotted in Figure 5, which exhibits exactly the same trend as in Figure 4.

by comparing these two .gures, we can notice that the Sequential and Sub-Order algorithms perform even better in the Zipf-distribution cases, as compared to the uniform-distribution case.


Subsequently, the information gained from checking the arguments .lls in boxes back in the context type.

during the .rst matching step, we must be careful to match type variables exclusively with the invariant parts of the context type.


Because of the lack of such a framework software developers tend to ignore implementing exception handling.

to address this problem, Java s exception-handling mechanisms were designed such that they support the software developers in implementing the exceptions-handling functionality in an easy and elegant manner.4 our study results show that Java s design was perceived as a force by most of the participants what indicates that the software developers were not willing to handle exceptions but the language imposed compulsions to handle exceptions.


Nevertheless, it is worth noting that the time performance of GA+SVM is slightly lower than the other benchmarks (although similar to SMV-Grid).

we realized a tool that automatically extracts the necessary data from software releases and allows project managers to exploit GA+SVM and evaluate the obtained predictions in terms of Accuracy, Precision, Recall, and F-measures.


BASIC ABSTRACT CONSTRUCTS A programming language consists of a collection of concrete constructs, each of which has a particular concrete syntax and semantics.

the relationship between concrete syntax and semantics depends on the language.


It is found that the analytical results well match with the simulated one.

as data rate increases, the control frames could be ignored, as a result of which the analytical and simulated results are extremely accurate at the higher data rate.


Most of the previous work on reducing power and energy consumption in DSP processors has focused on hardware solutions to the problem.

embedded systems designers frequently have no control over the hardware aspects of the pre-designed processors with which they work and so, software-based power and/or energy minimization techniques play a useful role in meeting design constraints.


Such server-side applications are basically a product line using runtime variability mechanisms.

their approach currently just analyzes dangling references.


5.3 Problems with cxspinlocks Allowing a critical section to be protected by both locks and transactions brings the concurrency of transactions to code which previously would have been incompatible, such as critical regions that occasionally perform I/O.

this cooperation also reintroduces some of the problems that transactions are intended to solve.


From the results, we also saw that Skype mechanisms tackle very efficiently packet loss of 0-10%.

packet loss rates over 15% because serious problems to the delivered quality of the input video used in the experiments above.


When the application servers .nish migration, the communications between the web server and the application servers no longer need to traverse the slow path.

it becomes necessary for the application servers to communicate with the database server over the slow path.


Then, test cases are derived and executed for modules which achieve the highest priority.

no detailed technique for how to derive test cases according to prioritization of risks is presented.


When vectorizing an outer-loop which carries a reduction, the above two properties apply and need to be checked.

if a reduction is carried by an inner-loop, these properties are not required for outer-loop vectorization: a nested recurrence in the inner-loop will continue to execute sequentially in the same order, operating on vectors instead of scalar elements, producing a vector of results feeding internal live-out uses without further reducing it to a scalar after the loop.


The business unit closest to the release data contributes and shapes the project most.

stating that modules will not support arbitrary variability and adherence to the reference architecture is obliging for all products makes people aware that they need to bring their stakes to the table simultaneously.


We as- P sume that ec : C1 -[t¯/a¯JC2 is an evidence constructing function.

note that the context only provides evidence for eC1.the instantiation site requires evidence e[t¯/a¯lC2.


A standard user design principle is to prefer widgets that offer a fixed set of options to the user over text fields that provide freeform input in order to minimize user work and to minimize the need to provide input validation.

students in the HCI course became particularly cognizant of the importance of avoiding textual input fields on mobile devices when they experienced first-hand the difficulty of using the small keyboards on cell phone devices.


Such labels are unnecessary if instruction selection is separated from register allocation and if the IR has already fully determined the value types of edges in the expression DAG.

we show in Section 3 that the problem remains NP-complete even without labels.


This is because we can use a much smaller number of threads and assign multiple dot products to one thread for load balancing.

the GPU applications exploit .negrained parallelism and thus it is dif.cult to achieve load balancing if inter-thread communication is eliminated.


This way of freeing regions was introduced by Wang and Appel to circumvent problems linked to atiasing of regions, In their followup paper [25], Wang and Appel suggest to cir- cumvent the problem of runtime type information using a mix of monomorphization and defunctionalization (a form of closure con- version due to Tolmach [20] which reduces the language to a mono- morphic first-order calculus).

this approach suffers from several major drawbacks: It can introduce a significant code size increase and forces the use of separate specialized GC and copy functions for each type appearing in the program.


Also, some middleware is aware of quality of service (QoS) [6] and resource consumption can also be considered a QoS.


The LIGD, PolyLib, EMGM, RepLib, Spine, and Smash libraries support abstraction over type constructors.

polyLib, and Spine only support abstraction over type constructors of kind * .


Single-block traces will not suffer from such duplication.

in Figure 5(b), there is only one offtrace branch for A, while in Figure 5(a), there are two off-trace branches for A.


There is overlap with the optimizations we have proposed as example applications of our dependency graphs: caching can hide the cost of redundant queries and prefetching effectively saves roundtrips to the database by eliminating the latency of correctly predicted queries.

while automatic techniques will work well in many typical situations, they have a limited view of the program and will not by themselves achieve acceptable levels of performance in every situation.


To reduce the network overhead needed for replication, the administrator can opt to deploy agents on a subset of the nodes in the data centers.

this can increase the load on these agents since more library modules will rely on each agent for receiving and sending updates.


The hash table query code is hot, so it is rarely sampled.

each individual data item is cold, since the table is large.


In general, to serialize a function value requires that one must also serialize its free variables.

the types of these free variables are unrelated to the type of the function value, so it is entirely unclear how to serialize them.


User-de.ned container classes complicate matters further.

scholia readily handles those container classes.


The computation times for the implication and mutex graphs are similar for Fge-BDD.

the mutex graph computation for Fge-CNF takes signi.cantly longer for large models 3.5 times longer for the Linux kernel.


This fault is not evident if all messages are received and processed in the correct order.

if a velocity or proximity message is not received the robot may not be able to avoid colliding with the wall.


Using Observational Pilot Studies to Test and Improve Lab Packages Manoel Mendonça, Daniela Cruzes, Josemeire Dias Computer Networks Research Group (NUPERC), Salvador University (UNIFACS) Rua Ponciano de Oliveira, 126 Salvador, BA 41950275, Brazil +557133304627 (daniela, mgmn, meire@unifacs.br) ABSTRACT Controlled experiments are a key approach to evaluate and evolve our understanding of software engineering technologies.

defining and running a controlled experiment is a difficult and errorprone task.


Suppose we would like to rename n to k. If we apply this transformation by using Eclipse 3.7, it will show a warning 1 The JRRT version from May 18th, 2010  message.

we can apply this transformation by using JRRTv1.


Fabro andValduriez[6] alsotackled theproblem of metamodel matching using a similarity .ooding approach, thus allowing no matcher combination.

their similarity algorithm can be applied sequentially, but without any weight or parameters.


Note though, that improving connectivity by increasing Kr, comes on the account of increasing the average node degree.

as can be seen in Figure 6(b), increasing Kr from 0 to 1, results in only a small increase in the average node degree (from ~7 to ~13).


We just need to collect request information of all neighbors within more hops and then apply MaxSer.

it take more time to exchange messages among nodes.


This implies that the QoS-aware discovery among thousands of web services may be a very tough challenge.

our algorithm is specific to limited QoS attributes.