Recently Schierl et al. gave an abstract specification of a single file system: UBIFS [32].

the field oss pid table holds the per-process information tracked by the operating system.


Traditionally, the storage system had been a SQL database system [48], which is convenient for the developer [34].

with the emergence of large Web applications in the past decade, the SQL database became a scalability bottleneck.


Since HTM relies on hardware (CPU) to do concurrency control for local transactions, which is hard to be aborted and rolled back by software.

to preserve serializability among conflicting transactions on multiple nodes, we design a 2PL-like protocol to coordinate accesses to the same database records from local and remote worker threads.


In doing so, P3 may need to dirty the journal and metadata, and will be marked as a proxy for {P1, P2} (the tag is inherited from the page it is writing back).

p1 and P2 are considered responsible when P3 dirties other pages, and the tag of these pages will be marked as such.


Note that tasks using direct I/O will not benefit from Duet because they bypass the page cache.

the maintenance tasks that we have examined do not use direct I/O.


It does not require tasks to specify their pending work to Duet a-priori.

a task can change the work it performs while it is running, without informing Duet.


Our work focuses on long running (large) tasks, whose data may not fit in caches.

our approach aims to make the best use of the current cached data, by modifying the order in which tasks process data.


Note that we target real graphs with very high level of node heterogeneity, e.g. small-world, powerlaw or highly clustered graphs, which leads to small candidate size in most cases.

the computational complexity of our algorithm is low in real graphs.


Row 3 shows how AuDroid resolves the secrecy violations relative to the market apps by using the user approval mechanism.

whenever a market app uses the microphone, the device owner is notified and can approve or deny the access.


Currently, such operating systems only control access to the microphone, allowing authorized apps to access the microphone at any time, even when a privileged app may be using the speaker or the user may be speaking a sensitive pass-code to the device.

current mobile operating systems fail in enforcing information flow control through the microphone and speaker, resulting in putting the users data confidentiality and device integrity at risk.


Furthermore, it may be useful to explore their expectations of how the world should operate and how this might affect their ICT use [63], as it has been implied that at least some differences exist between the younger and older generations of users [31, 64].

in the current paper we examine how young people are engaging with the Internet and what that implies for ICT design for youth.


Although in our data the youth were not very eager content creators, related activities were still observable.

the existing research indicates content creation as an essential aspect to be offered to the youth.


The kernel already checks the text section for errors with a checksum before booting.

we assume that read-only code is covered by other mechanisms, such as periodic error checking [30].


First, at line 4, Dcurr is not set to the DOM snapshot; instead, Dcurr is built incrementally by adding XPaths to it for the referenced UI elements, one at a time.

dcurr corresponds to the DOM induced by the test steps in the current candidate subroutine.


For instance, many test methods may be added, each tagged with the TestMethod attribute, so that the test framework can automatically discover them.

in summary, the reviews we chose have: between 2 and 5 non-trivial partitions (median 2), between 2 and 13 changed files (median 5), between 7 and 52 diff-regions (median 25), and between 1 and 8 trivial partitions (median 2).


It is important to note that analyzing changesets is quite different than analyzing the history of a source repository.

changesets do not provide full information: we do not have the full set of project files, nor the compiler options used to actually compile the code.


The control and treatment groups had similar average years of programming experience (7.2 years and 7.4 years, respectively), but the control group had overall more experience with VCS (5.8 years) than the treatment group (3.8 years).

we also tested these hypotheses using two other analyses, to serve as checks.


Since these edits are likely to have been performed close together in time, users may be able to easily select them together in the timeline.

if not, we believe the compile errors would catch these kinds of problems and users would be able to perform the remaining backtracking steps to complete what they wanted to achieve.


It would be much more convenient for her if there was at least a semiautomatic way of restoring the desired code from Fig. 3b while keeping the subsequent desired edits from Fig. 3d.


Existing qualifier inference tools operate in batch mode.

they take the source code as input, analyze it, and insert all the qualifiers at once.


Qualifiers were a new feature of Java by the time of our study.

we trained the participants about the qualifiers.


As shown in Figure 6, RECONTEST provides an advantage with long execution traces where, due to the interleaving explosion problem, concurrency testing becomes an expensive activity.

it is inadequate for concurrent programs to only cover the changes of the sequential logic and forego their ramifications in the interleaving space.


Most PTAs also re-execute the program to exercise the retained interleavings.

RECONTEST efficiently characterizes the delta of interleaving space at memory access level.


As we described in Section III-B3, we distinguish four kinds of program constructs: classes, methods, variables, and comments.

to exploit all of this structural information, we perform a separate search for each type of terms.


Fortunately, variability-aware refactoring has a mostly local effect on source code.

in our subject systems, RENAMING IDENTIFIER, EXTRACT FUNCTION, and INLINE FUNCTION usually affected only a few configuration options, which enabled exhaustive testing of all variants.


The extraction process is implemented as a breadth-first search (BFS) variant, where all the recorded (visited) methods will be skipped.

all the logging methods are excluded in this process.


The weekly status meetings provided a lot of information about the developers and the product.

they provided only the perspective of the meeting participants.


When performing checks that require small bounds, such as the satisfiability checks, bvzot is only occasionally more efficient than the other tools.

as the models and bounds5 grow in size, bvzot demonstrates its strengths.


However, due to undecidability of FOL, an automated theorem prover is not guaranteed to come up with a solution every time, and sometimes it may time-out without providing a conclusive result.

actions that have loops in them are hardest to check automatically.


This is similar to our approach at a high level.

we do static analysis of a particular condition that allows us to use a completely alternate definition of a loop, whereas [8] iteratively abstracts and subsequently reduces the model in order to infer and enhance atomicity rules without altering the validity of the given invariants.


Users not as engaged with the method will have less motivation to successfully implement an assert, and open source developers appear to follow this trend.

one issue to note is that many methods have been changed only by a single developer, and therefore these methods have complete ownership (= 1.0).


In 91 cases this was true, and in none of the observed error cases was the estimate extremely different from the actual size.

this estimate is an appropriate measure for roughly distinguishing between different sized functions.


At the BB level, PRES reproduces all of the bugs within 10 tries.

in this section, we propose our solutions for the challenges mentioned in Section II.


Via observing the results, we found that the n-gram model tends to collect APIs including project-specific ones (noises) due to the strict order of n-grams.

its suggestion accuracy is affected more by noises.


The API elements in a usage do not always have a specific required order, e.g., the instantiations of the Scanner and FileWriter objects.

n-gram requires a total order among APIs.


In the example, the number of loop iterations is controlled by the value of register edi that holds symbolic data (instructions at 0x6116174c and 0x6116174d).

the value of eax in crash instruction is indirectly controlled by the symbolic input data in edi.


CARAMEL could have easily followed developers style and generated the same fixes, if WALA was able to provide the line number of the RI.

in practice, CARAMEL focuses only on RIs that (1) have a single output location, (2) either write a constant (similar to Figure 4(a)) or perform the &= or |= operations (similar to Figure 4(b)), which effectively correspond to's being constants false or true, respectively, and (3) have an output location that is not written to in the loop with other values except S.


Fourth, fixing performance bugs, which manifest for some inputs, may slow down other code, for some other inputs, and developers must decide which of these slowdowns the slowdown caused by the performance bug for some inputs, or the slowdown caused by the fix for some other inputs is preferable.

fixing performance bugs has benefits, i.e., it speeds up code.


Imagine the situation where m tests fail due to a certain fault f.

even if pfii contains only a single potential fault indicator, pfii established this way may include redundant statements that are executed by ti but not all failing test cases that have executed the corresponding fault of pfii.


In practice, deriving a complete fault indicator for a certain fault can also be difficult.

note any subset of the statements included in the complete fault indicator for a certain fault f can be used to indicate the execution of f for failing tests to a large extent.


Phase 1: Identifying the suspiciousness score for each failing test's opinion on the potential fault indicator.

newtestset contains a subset of Ts such that each of them has executed rfi or has not executed any real fault indicators yet its opinion on the potential fault indicator includes a child of rfi.


Code review usefulness is negatively correlated with the size of a code review.

the more files there are in a single review, the lower the overall rate of useful feedback.


In addition, CQ is a general unit which can be reused in other products of LGE.

it is important to detect bugs in CQ if any.


This illegal transition was made by the two consecutive events auto-cook and function-L at the same main loop iteration on (menu,def ault) state.

the error occurs when a user presses the auto-cook button then immediately turns the function dial counter-clockwise when the oven is in the menu mode.


In general, the data shown in Fig. 8 supports the observation that association rules have a relative short lifetime (as suspected in Section VI.B).

the number of required association rules is high, indicating that false test alarms can manifest in many different ways, but still be consistent over time.


Please note that a failing test step may not cause the test case to terminate immediately.

each executed test case may report more than one test step failure each of which may relate to a code defect or a false test alarm.


Besides precision and recall, we were interested in the number of association rules required to achieve the high precision as discussed in the previous section.

we wanted to know whether the number of association rules is rather constant—no new rules must be learned over time—or whether constant learning of new rules is required.


While they have historically used metrics related to the overall failure numbers in this analysis, the classification models shown in this paper indicate that test instability often occurs in blocks of time.

when attempting to identify troublesome tests, it is useful to look not only at total failures, but also the recency of failures within a given window of time.


Different classification models yield varying levels of prediction accuracy depending on the data set and the input parameters chosen [16].

we also need to examine various classification algorithms, such as decision tree models and Bayesian models.


WFD 2 SPF was also used to provide higher-level communication abstractions for the SPF.

we introduced three communication primitives: one for sending broadcast messages, one for sending unicast messages, and an RPC-friendly primitive for sending a message and waiting for its response.


This is an abstract class that contains the logic that is common to group owners and regular group members.

it contains methods to connect and disconnect, to perform messaging, and to respond to incoming messages.


The recently committed changes may be buggy but have not been detected and fixed yet.

we apply our prediction models on the changes of the proprietary software made in the last year.


We have identified the following main reasons.

the time period of the test set is often short, e.g., a few days or months.


If a project's BTS is well maintained and linked, we consider changes whose commit messages contain a bug report ID bug-fixing changes.

a line that is deleted or changed by a bug-fixing change is a faulty line.


This limits the possibility for more developers to participate in the field trial.

the feedback from the developers may not be representative.


First, in practice, we prefer to predict as soon as changes are committed so that we can examine them to identify bugs earlier.


The overall result of this study is the definition of a metric to aid stakeholders in deciding on whether the dependencies of a system should be updated.

the contributions of this paper are: The definition of several metrics to quantify dependency freshness at the component-level, including their advantages and disadvantages.


These criteria are even more essential in a context whereby the safety-critical system under analysis is being developed in an incremental manner and that formal proof is used as a means to ensure non-regression.

any counterexample generated from a failed proof attempt can also be simulated on the model for debugging purposes.


These tables show that only 6 root spaces are needed to cover 89% of the Bug2 space, and 7 root spaces can cover 92% of the Change10 space, meaning that both error-prone and change-prone files are highly architecturally connected.

we observe that the first two DRSpaces are the same for both Bug2 and Change10, and cover up to 76% and 79% of the most error and change prone files respectively.


RQ3: Is it possible to quantify the return on investment of removing architecture debts?

is it possible to determine the penalty incurred by the debts and the expected benefits if the debts are removed, and compare this with the costs of refactoring?


Since any given file (class) may participate in many relationships with other files, this may result in the same file appearing in multiple DRSpaces.

we calculated two measures of the size of each DRSpace: the raw size, in terms of number of files, and a normalized size.


We are not aware of any other tools that can detect those files, together with their visualizable architecture issues.

this is, to our knowledge, the first time that the penalty associated with technical debt, the cost of refactoring to remove that debt, and the expected benefits of removing the debt have been quantified based on hard data project-specific empirical evidence.


The goal of this work is to shift developers toward more effective program comprehension and maintenance habits by providing an approach that fosters structural code navigation.

nC then represents the sum of all structured navigation in Visual Studio and in Prodet.


Software Engineering educators are expected to provide students with hands-on learning activities that challenge them to solve authentic (i.e., real or very close to real world) problems by applying the relevant Software Engineering concepts and principles.

there is an increasing realization and focus on problem based and experienced based teaching and learning in Software Engineering education of different phases of Software Engineering such as Requirement Engineering, Design, Implementation, and Testing.


While not statistically significant, nor surprising, students reported that the Scrum practices were slightly less suited to working in a distributed team than in a local one and that the process conformance was slightly poorer when the teams were distributed.

in the interviews they stated the opposite: several students mentioned that in distributed teams they were actually following the agreed practices a bit better than in the collocated teams, e.g., communicating right away in Flowdock when working on tasks or having problems, instead of waiting for the next face-to-face meeting, which did happen when working in a local team.


The PO created user stories with less dependencies over time, as shown in Table VII.

i think I like the international team, a lot better.


However, even though they have been taught software engineering (SE) principles (both in SCC.230 and SCC.330), because these have been taught through practice, the students are not always able to explicitly articulate their learning goals in terms of SE principles.

we more focus on individual attainment of software engineering principles as well as system implementation techniques in SCC.331.


To cater for this, we propose that we integrate components from the Contextual Design participatory design method [20].

the Contextual Design method utilises the notion of a Cultural Model that provides an analytical capability for showing the cultural or political forces in the organisation.


We observe that the patch applied in the onCreate method (Patch2) avoids the crash, whereas the patch applied in the getWorldList method (Patch1) continues throwing the exception.

the store learns that Patch1 is not effective and automatically discards it.


We then produce clusters of similar (code, specification) pairs.

we will use the similarity measures for finding similar code, code with similar usages, and code with same/similar specifications.


In short, there is a need for a new class of safety certification/assurance techniques that are continually assessing and evolving the safety reasoning, concurrently with the system, to provide through-life safety assurance.

safety assurance is provided not only during initial development and deployment, but also at runtime based on operational data.


Moreover, we found that participants verbally described operations in terms of code fragments, e.g., move this conditional statement, yet version control tools required them to think in terms of lines.

he edits the autogenerated commit message (Figure 1C) to better reflect his intent, by clicking and then typing the new message.


In the first step, we remove markup from the HTML files and preprocess the resulting text files to account for the unique characteristics of software documentation not found in other texts, such as the systematic use of incomplete sentences and the presence of code terms.

we prefix sentences that start with a verb in present tense, third person singular, such as returns or computes , with the word this to ensure correct parsing of partial sentences, such as Returns the next page number .


Abstract Developers have to work with ever-present designtime uncertainty, i.e., uncertainty about selecting among alternative design decisions.

existing tools do not support working in the presence of uncertainty, forcing developers to either make provisional, premature decisions, or to avoid using the tools altogether until uncertainty is resolved.


A detailed discussion of these annotations is beyond the scope of this paper.

tesMa takes as input a set of design documents of an application under test.


Multi-version projects are better choices as they have several programs whose sizes increase gradually, making it more obvious to observe the 2In this work, the cost of selective mutation testing refers to the time of compiling and executing every selected mutants against each test case.

more selected mutants means larger cost.


Linear relationship may mean that the cost for applying selective mutation testing changes greatly as the program size increases.

though selective mutation testing does not use all the mutants, the number of selected mutants used in selective mutation testing for large programs may still be large, which is still expensive to run every selected mutants against the test cases.


At one end of the scale, specified oracles can be generated from formal specifications [3], and are effective in identifying failures, but de.ning and maintaining such specifications is demanding and consequently such specifications are very rare.

a number of different cluster counts were explored based on a percentage of the number of subject program test cases (1%, 5%, 10%, 15%, 20% and 25%).


The trend is for the failure density of the clusters to increase in line with the number of clusters (with the exception of the aforementioned version 3 in NanoXML).

in some cases, as the number of clusters increases the failure intensity peaks and then begins to drop (although not substantially) as the clusters are forced to fragment.


There has been much research into methods on how to explore and test a GUI [14], [8], [3], [10], [4].

little research has been done on the effect of test case length in regards to GUI tests.


As well, it is possible that one fault causes more than one type of exception to be thrown.

figure 3 shows the EPC for each application.


As in the AIM-adaptive scenario AIM completely re-instruments the AUT for each experiment, there are no unnecessary (or disabled) probes introducing additional overhead.

the AIMadaptive scenario provides the most accurate prediction results with relative prediction errors between 0.01% and 3.5%.


Therefore, a parallel unit test usually has no assert statements - as the decision whether a parallelization bug exists cannot be cast by an assert statement, but by an external testing tool.

most generation approaches for parallel unit tests omit any assert statements - conventional bugs may still be found using conventional unit tests.


The level of obtrusiveness is an appropriate dimension to position different research strategies on, as it indicates the level of involvement of participants in a study or the level of involvement that a researcher has in creating the study setting.

the term simulation in this context refers to the artificially created setting in which the experiment or the observed behavior takes place.


Field studies, as they are defined here, are unobtrusive.

they do not include any deliberate modification of the environment in which the research is conducted.


The answers the participants provided to the open-ended questions in all eight areas related mostly to the human and collaborative aspects of their activities.

we included in our analysis of the open questions the responses obtained in the context of all eight areas.


Results of mediation analysis showed that value congruence was a mediating factor between candidate success factors and project success in this model.

full mediation existed between transformational leadership and project success, and partial mediation existed between degree of agility and project success.


LSI requires defining the number of topics that should be extracted.

the pure Jaccard performed better for comparing tasks of different developers.


Most tools resort to approximation to overcome these obstacles and it sometimes leads to incorrect results.

tool effectiveness needs to be evaluated.


Measure element is a term used in the ISO/IEC 25000 series of system and software product quality standards for describing anti-patterns that can be aggregated to form a measure of a particular quality characteristic such as Reliability, Security, or Maintainability.

each type of defect, weakness or antipattern, can be treated as a measure element included in a measure focused on a specific quality characteristic.


Several evaluating metrics on software reliability are available and effectively assess the performance of SRGMs from the different profiles of model attributes.

these metrics only evaluate one profile of model attributes and cannot comprehensively evaluate the complete profile of model attributes.


Objectively speaking, perfect fault detection models to the extent can effectively assess the software reliability in software testing.

in DS5, parameters are estimated by using time t = 1 to t = 10 weeks.


Especially, in modern large software systems, detected complex faults and failures are harder to isolate, reproduce and remove compared with detected simple faults and failures.

the fault detection rate presents the irregular fluctuation over time in the software testing process.


Among all models, the proposed model has the lowest fitting and predictive SSE and BIAS values.

the proposed model has much better performance than other models.


The Verification and Validation (V&V) of this access control policy is thus a crucial activity in the design of the SIS.

the access control policy should prevent insiders attacks where legitimate users of the system abuse of their privileges to gain access to forbidden information.


Specifically, each interaction must be analyzed to determine if it is a problem; if so, then a patch must be designed, implemented, and tested.

a measure of the number of ways in which features in a product line can interact would tell the developer more about the amount of effort needed to integrate features than a simple interaction-existence check provides.


This modularization strategy, from both the game-template architecture and the code derivation perspectives, has substantially eased the evolution of the first version of PhyDSLinto PhyDSL-2.

when we introduced the camera management and on-screen control features into PhyDSL-2, we found that (i) changes were limited to one game-template architecture component, (ii) language changes were progressively made from the impacted intermediate model, to the domain-specific language, thus modifying fewer M2M and M2T transformations, and (iii) developers experienced less severe cognitive challenges while executing maintenance tasks.


Moreover, the heuristics are based on the assumption that the source code contribution originates from the same person which changes the issue status to resolved.

this assumption does not always hold and depends on the specific project.


The reason is that human instructions did not include a clear description of how to show the Advanced panel option in the menu, but the CRASHDROID report included the step (change from the basic to the Hex panel) that activates the option in the menu: I swiped right on the top half of the screen: I touched the Hex button...I touched the Advanced panel menu option.

the qualitative and quantitative results suggest that CRASHDROID reports are as effective natural language descriptions as those produced by developers in this context.


They focus on visualizing coverage information, and dependencies between tests to help test engineers understanding relations between test cases.

they do not focus on clone relationships between tests.


First, we propose that triggers and actions are the only nonderivative concern roles.

the other roles, including initializers, data, and connectors, can be derived if the triggers and actions are known, yet triggers and actions cannot (in the general case) be derived from the other roles.


The developer could set a breakpoint in the code and observe which of the multiple implementations are invoked at run time, but this usually gives just a narrow selection of all possible invocations.

unless she sees all possible invocations occurring at that particular place in source code, she will not be able to fully understand the behavior of the basicDisplayBox message.


Makefiles generated using CMake and QMake were easy to identify because they must be generated manually.

makefiles generated with Automake posed a challenge.


Other features such as special targets, continuations, and recipe command flags ( @ , - , and + ) are used by most.

there are two flavours of variables: recursively expanded, which are evaluated as they are needed (i.e., when a reference is read), and simply expanded, which are evaluated when they are defined.


For the first experiment, each subject had a single session.


Our subjects were only made up of students.


Those facts indicated that reorderings by the proposed technique did not make the results of keyword-based code searches worse.

we consider that reorderings by the proposed technique worked well especially when many keywords are found by the keyword-based code search.


Seahawk [5] is another Eclipse plugin that integrates Stack-Overflow into the IDE.

seahawk automatically creates queries from the active context in the IDE, presents a ranked and interactive list of results, lets users import code snippets in discussions through drag & drop.


Existing approaches to find a solution to an exception mainly suffer from several limitations.

none of them recommend both code snippets and relevant programmers discussions together.


If each design model or code conforms to Archface in 2), Fp is also satisfied in the model and code.

the verification of Fp results in modular interface checking.


more than 33 000 changes between two consecutive releases 4.1.3 and 4.2.1 as shown later), careful analysis of the impact of these changes on different modeling tools supporting these solutions is required before their implementation [6].

these kinds of analysis would not be feasible for the automotive software designers without the tool support.


The distcheck tool is also being used to schedule package rebuilds within Debian in a way that is aware of unsatisfiable build-time dependencies (as opposed to deploy-time dependencies, which are the main concern of this paper).

no build will be scheduled by the wanna-build scheduler, unless distcheck can show that the build-time dependencies of a given source package are currently satisfiable in the origin repository.


They found different coupling patterns in projects with different development style.

in test-driven projects there is a strong coupling between production and test code, while other projects have a weaker coupling between testing and development.


Additionally, the destination of these incidents is a Text editor in more than 65% of the incidents and is a Java editor in 11% of the incidents.

the interaction between the C language and other editor types is minimal because of the nature of the C language itself which is primarily used to develop standalone applications that do not require text to be moved across different editor types.


The elementary patterns are composed of a single C&P interaction involving one or more files.

complex patterns are composed of two or more C&P incidents involving more than two files.


The technical dependencies that exist between projects define the structure of the ecosystem [2].

identifying technical dependencies between software projects is a useful way to identify ecosystems.


At the same time, there is a relative scarcity of empirical data about the nature of architectural change.

the largest versions of these systems range between 150KSLOC and 800KSLOC.


On the other hand, in order to meaningfully compare two concern-based architectures as required for our study, we needed a shared topic model for their recovery.

for each subject system, we created a topic model by using all available versions of the system as the input to MALLET.


As a result, the architectural gap between version 0.1.0 and 1.0.0 is expected to be very large, yielding a low a2aMa jor value.

changes between the last minor version and the subsequent major version that is derived from it (i.e., for the version pair (0.20.0,1.0.0)) are comparatively small, resulting in a relatively high a2aMinMa j value.


In addition, we have attempted to cover most important risk factors related to an issue causing a project delay.

we acknowledge that the set of risk factors identified in this paper are by no means comprehensive to encompass all aspects of software projects.


The main reason for using NB is to obtain the probability that a issue will be delayed as we need to determine a likelihood of the risk.

studies that aim to measure the degree of uncertainty naturally apply NB to build models (e.g., [37, 38]).


First, they are trained to predict the best answer from any lists based on certain metrics.

they are not expected to explain why none of the answers would be chosen as a solution.


To answer RQ1, we analyze 3,956 unresolved questions from Stack Overflow using four different aspects lexical, semantic, user behaviour and popularity.

we compare the unresolved questions with resolved questions from data gathering step (Section II) using those aspects, and attempt to determine if there exist any noticeable differences between them.


Moreover, previous research has shown how the users with a high reputation are more effective in providing successful answers [1],[3].

we include the social reputation of the answerer as a control factor in our model.


In the context of ecosystem, the platform provider may want to design its APIs simple enough to encourage niche creation.

an API providing higher level of penetrability to the platform would be more appropriate to more established partner companies who prefer to have more understanding and control of the platform.


The goal in this work is to understand whether the meta-model of ABRE-QM enables a definition of quality in this context.

by extracting this abstract information, we were able to keep impacts on e.g. implementing a use case only if the impact was really specific to this activity and not due to a generalized one of the above.


Similarly we can split up activities to further understand which activities are affected in what way.

a pure analysis of the process model description is not sufficient, but a more liberal interpretation is required.


However, a pure analysis of the process model description is not sufficient, but a more liberal interpretation is required.

a static (idealized) description of a process is not sufficient as the obtained quality factors (and their practical value) highly depend on the person deriving it, especially regarding the expertise in the field and, since definitions are vague, experiences how the activities are carried out in practice.


We have described the experience made at SEAC, where we introduced a new, agile development process, targeting several issues of an ongoing re-engineering project.

we focused on the derivation of the implementation and of the test cases from the normative requirements, so as to ensure alignment between the testing goals and the expected system behaviours expressed in the requirements documents.


The configuration of LSI, which depends on the underlying dataset, greatly influences the accuracy of the results.

one of the key challenges in applying LSI-based methods is finding an appropriate configuration producing accurate results.


However, the work focuses on understanding the inner mechanisms of LSI and does not consider the accuracy of the results.

the accuracy is in the center of our work, since it improves the applicability of LSI in requirements tracing.


We believe that addressing all of these requirements is essential for the creation of a robust utility network model which can support the requirements of modern utilities.

another category of dense features is associated with substations.


Several new programming environments have been introduced recently, in order to address these issues.

the OpenACC programming standard has been designed to ease the software development process for codes targeted for heterogeneous machines, helping to achieve code and performance portability.


It expedites model modification and enhancement; it also enables environmental model reconfiguration, reuse and reassembly.

they contribute organic carbon throughout the soil profile in the form of labile root exudates and decomposing root material, and strongly influence ecosystem CO2 and CH4fluxes through respiration, rhizosphere oxygenation, and passive transport (e.g. [4]).


Based on the results from the previous step, we have a clear understanding of the software structure and data dependency (inflow and outflow) of any specific scientific function within environmental models.

for any given scientific function, the information on software structure and data dependency can be used to generate code segments for test module initialization (if necessary), and input/output.


While GAs may provide acceptable performance, other algorithms may be better at exploiting the particular structure of a testing problem: the focus on GAs may be limiting our creativity as researchers in finding much better .ts between the testing problem and the search algorithm.

gAs can scale poorly to high-dimensional problems and scalability is sensitive to the representation of the problem (see, for example, [4]).


This has been exemplified in recent work [15].

it has been shown that it is the combination of soft and hard constraints that allows for a very popular CIT-test generation algorithm, based on simulatedannealing, to scale to real-world problems.


The results show that the use of EAs is suitable in many cases.

it can be outperformed by simpler search techniques.


To automate the test data generation process, we have considered that our System Under Test (SUT) is like a gray/semi-transparent box in where the internal structure is partially known.

we can design test cases through the exposed interfaces and conduct a code coverage analysis from the general structure of our target SUT.


This identification is based on the computation of the differences between the FM before the evolution and the evolved one.

it relies on a syntactic difference diff operator that takes two FMs as input and computes their differences [19].


TABLE II describes the edits that can be performed on cross-tree constraints, whether Boolean or non-Boolean ones, e.g., constraints on the number of instances of a given feature [16].

this architecture is able to handle the evolution of FMs extended with both attributes and cardinalities.


Also, design-time analysis, as it is presented here, is an exploratory approach compared to run-time analysis.

the questions that arise while conducting this method would not otherwise come to light if the focus had only been on the run-time analysis of the self-adaptive system.


In the next section, an application of the method on a self-adaptive system is presented using hypothetical data.

the quantified NFRs, P(NFRi), P(NFRID), risks associated with each NFR, the outcome attributes, their weights, values, and the percentage effectiveness of each design decision in mitigating the risk are all inspired by empirical data provided by a prototype of the case study.


Calculating surprise values for the river depths greater than 1.53 m yields a negative surprise value.

as the magnitude of surprise matters the most, the sign is ignored.


Perfect knowledge, sound judgement, and a consensus of opinion among the considered stakeholders are not realistic to assume.

the Software Engineering literature provides pragmatic solutions and systematic approaches that, if adopted, can minimize the effect of this problem.


For this paper, we use the definitions of test plans and test cases as defined by the IEEE [29].

a test case comprises an expected value and the conditions necessary for execution.


Lastly, the total number of executed test cases were recorded to provide a measure of the overall impact of run-time testing to an SAS.

we demonstrate that Proteus significantly reduces the amount of executed test cases per testing cycle by ensuring that only relevant test cases are executed, as shown in Figure 7.


Video streaming is an attractive mechanism for technology transfer at a reduced cost (both time and money) per viewer - particularly for companies with multiple locations (including within the same city, campus, or building).

using video effectively is a challenge when it comes to audience interaction since the medium is much more limiting than a live lecture.


On the basis of a successful alignment of expectations and pre-study, the industrial PhD project proved in our case to be a good instrument for bringing the technology safely from TRL 5 to TRL 7, that is, through the valley of death.

there are still challenges and risks: The strong involvement of a company hiring the PhD candidate and typically paying two thirds of the salary gives a risk of the company not being able (or willing to) complete the project.


This could make industry partners more likely to leave a research project before its completion.

bridging from TRL level 5, validating the technology in relevant environment, to level 7, the point where industrial partners can convincingly see the developed technologies being applied in practice, requires often much more investment of the industrial partners.


As a result, many potentially useful research results lie fallow, to be reinvented sometimes by practitioners but, typically, in a more limited and, hence, less useful form that is imposed by the specific technology and problem on hand.

shunned by industry, many researchers do indeed turn to investigating problems that are of little or no practical relevance, which, nevertheless, allows them to publish and thus maintain or enhance their academic standings.


The topmost node is a choice between four alternatives: The leftmost subtree checks whether the robot is in one of its home locations.

finally, we discuss some aspects of the overall process of continuous collaboration, a development pattern based on using feedback gained from the running system to continuously adapt and improve a system's operation throughout its life cycle (subsection D).


Each node created during the development process can be formally described using the formal system model described above.

the intention of this paper is to propose an extension of the formal system model, which on the one hand allows to capture uncertainty factors that are inherent in the context of a CPS, while on the other hand it should support all modeling concepts of the initial model such as composition and refinement.


Such a strategy defines the membership function of a property according to the observed history of a channel.

the property adapts to the location of a component.


Context-aware systems are characterized by their ability to interact with their external environment by monitoring information over sensors, or by controlling system states over actuators.

it might be beneficial if the VPP could dynamically reconfigure its specification.


In this paper, we illustrate the use of the mKAOS language and its associated tool by modeling the missions of a Flood Monitoring SoS.

we argue that missions require additional information that cannot be represented through traditional requirements approaches, e.g., the interactions among constituent systems that lead to the emergent behaviors of an SoS.


Evaluation Results We only consider the results of 17 high-level recovery modules, because the extraction of meta data has an impact on high-level recovery modules.

our approach consists of an active repository that is steadily analyzed to recover traceability information.


The architecture needs to support this way of working and there are significant architectural implications.

continuous deployment, split testing and data collection need to be an integral part of the architecture.


Search Provide support for search functionality Claims Assessor should be able to search for the claims record to be processed.

the manual identification and classification took approximately 7.5 hours of each person s time.


For SCJ Level 1, we will mainly test the performance of this protocol as the paper has a clear description of its behavior under partitioned systems.

the test cases are either Level 1 or Level 2 application programs.


In addition, a dependency analysis facility is supported by the icecap tool chain to check whether all the referenced Java classes are provided by the SCJ RTE.

before compiling a Java program, dependency analysis is performed to ensure all the referenced classes are supported, and then only the components being used in the libraries will be included in the compilation and the final executable file.


A restricted version of no heap real-time threads is also provided in order to support a thread-based concurrency model.

one disadvantage of this approach is that the new structure has to rely on an underlying RTOS for scheduling purpose, which makes the HVM more difficult to port to a standalone environment.


The iOS application goes a step further and makes all of the data available for of.ine browsing.

node b and node c are removed in separate mutations.


In this paper, we present the design of TouchDevelop’s cloud back-end and how it simplifies the creation, maintenance and publication of apps.

we believe that for beginning app authors, fully featured version control systems together with app store publication models are too complex.


In the case of existing back-ends, the model of the to-be-developed application is implicit in the back-end API/resource schema.

finally, the WL++ codegeneration engine is endowed with a number of code templates and external libraries, which it refines based on the application model to produce the application code.


Since the bring-your-own-device (BYOD) trend is continuing to grow, mobile devices can proliferate in a company at an exponential rate.

metaXA is calling for an infrastructure that can dynamically and automatically scale up according to the growing number of mobile devices.


Within the terminology of FDPS, the interaction between particles in the gravitational N-body problem is of the “longrange” type.

we need to specify the function to calculate interactions for both the ordinary particles and superparticles.


FDPS provides the former part and the users write the latter.

in simulations with a large number of particles N, NJ,i and NS,i are many orders of magnitude smaller than N.


For gravity calculations, we used highly-optimized kernel developed using SIMD builtin functions on both platforms.

for fluid calculations, we used the optimized kernel on the K computer, but do not on Cray XC30.


Our code using FDPS seems to be 4 times slower than GreeM.

this is due to the difference of the algorithms used.


The user program first uses the functions of FDPS to do the interaction calculation, and then updates the physical data of particles, and repeats this loop until the end of simulation.

the user of FDPS does not have to write complex code for parallelization.


Likewise, modern build systems only recompile compilation units whose source code has changed.

during active development using Puffin, only the files that are modified must be recompiled.


These numbers have been normalized based the Original version of LULESH 2.0.

a time of 1.08 means that the All Features version ran 8% slower than the Original version of LULESH 2.0 for the test with problem size of 20.


Liszt supports both CPU- and GPU-based parallelism, but does not support incremental adoption.

entire applications must be written in Liszt to use Liszt.


Since all elements in LULESH 2.0 are hexahedrons, each element has eight corners.

each element is affiliated with eight nodes.


The reason is that significant pieces of HPC knowledge are indeed not prior knowledge, but highly dependent on a particular execution instance of a program running on a given environment.

it is impossible to prepare a static, prebuilt, all-you-need knowledge base for HPC.


We provide results demonstrating significant reduction in GPU overhead, allowing tasks where speedups over the CPU version were previously unattainable to now outperform their CPU counterparts.

doing so means only a fraction of the large fixed sized array is allocated.


A naively tiled code could perform that 8 times, requiring 64 total gets.

an optimized tiling scheme for the same 8 steps would only require 27 get operations.


To address these problems, we developed an automated compiler support based on the latest advances in polyhedral frameworks (e.g., [5, 36]) to greatly reduce the human design effort currently required to create effectively synthesizable specification of designs using HLS tools.

we developed compiler support for source-to-source transformations to optimize critical resources such as memory bandwidth to off-chip memory and on-chip buffer capacity [27].


Standard tiling does not impose any constraint on tile sizes along spatial dimensions as a function of the time tile size.

standard tiles may be compacted to a much smaller size to compensate for the larger tile sizes required by split-tiled dimensions.


Further, even once a defect has been detected and isolated, the creation of a small-scale reproducer can require precise understanding of the nature of the problem to preserve the salient characteristics.

problems must often be largely resolved at-scale before a proper small-scale reproducer can be crafted.


The jump at 90% in the Y axis is due to one TCP timeout across both request and reply which is hard to avoid and is budgeted for (Figure 2).

the network and compute budgets are in line with [5, 42, 44] and [39], respectively.


As we can see, the times spent on calculating the throughput of an application under ISPS and SPS are similar and much shorter than the time needed for solving the ILP problem to find the application throughput under PS and the time spent on finding the maximum achievable throughput of the application, i.e., the throughput under STS.

our approach outperforms PS and STS in terms of time required to calculate the throughput of an application.


We assume that the ownship has the capability to perfectly estimate the geometrical configuration of the encounter, i.e., the relative position of the intruder, as well as the speed and direction of both aircraft; in practice such information is provided by different sensors as well as communication data exchanged between aircraft.

we discard all sources of noise and uncertainty related to the state estimation.


An important avenue of future work is to incorporate into the analysis the effects of numerical errors resulting from floating point calculations in the control code.

aCSL utilizes the keywords requires and ensures to specify the preconditions and postconditions; the verification goal is to prove that postconditions are satisfied upon return if preconditions were satisfied when the function call occurred.


Unlike HDD, as flash memory stores and retrieves data by controlling electron movements, it has no seeking operations.

there are fundamental questions that may be raised; that is "what constrains the performance of SSD?"


If we copy a large file to a distributed file system, it will take a long time to copy the data to the target cluster compared to updating the directory.

if many nodes copy large files to the same directory, then the amount of delay due to the concurrent directory update becomes relatively small compared to the amount of time to copy the file’s data.


In this case, TryBlocks can be retried locally and failures are detected and corrected locally without any group-wise synchronization.

a majority of data parallel applications need synchronization of some sort and any fault-tolerant API needs certain levels of synchronization.


To get an optimized I/O throughput on two-level storage, we use 1 MB request size for MapReduce applications and 4 MB I/O buffer between Tachyon and OrangeFS.

this function is similar to the memory mountain that characterizes the capabilities of memory system.


The twolevel storage can provide higher read and write throughput with limited number of compute nodes.

running Hadoop with the two-level storage may provide a better performance solution for big data analytics on traditional HPC infrastructures.


we use a single 10 GB file on RAMdisk in order to saturate the high bandwidth on the memory device.


Nonetheless, the use of C++ data structures did present problems.

in order to avoid errors for both the PGI and Cray compilers, class data members used within parallel regions needed to be copied-in to the local scope.


As a result, some OpenACC compilers will succeed to automatically infer the range of array elements accessed within the parallel loops.

for such compilers the data pragmas could be omitted to simplify the OpenACC parallel implementation.


When the MACC compiler encounters this clause, it generates reduction code at the same time as child kernel generation.

the reduced variables must be returned to the parent kernel, using global memory to achieve this communication.


As illustrated in section 2.1, a MONC timestep is made up of a number of functionality groups and each group must run sequentially, i.e. the results from one group must be known before proceeding to the next group.

it would not be efficient for us to port the entirety of the MONC dynamical core onto the GPU as the CPU would sit idle whilst the GPU is executing this aspect of the model.


These processes are not available until the job is finished.

the processes in other worker programs and master program can continue.


As of LLVM 3.6, LLVM IR supports a distinct property to prevent this merging [22], but OpenARC's LLVM backend currently targets LLVM 3.2.

in other cases, the fault injection could cause the count to change, or it could cause the application to crash before reporting the count.


A FITL desert never has an entry portal and or an entry intrinsic.

as in figure 4, the entry portals for FITL domains and FITL regions are always FITL deserts.


First, like our source-level fault injector, our FITL-based fault injector improves usability by supporting source-level pragmas.

our FITL-based fault injector makes it easier to configure resilience studies and understand their results than when using lower-level fault injectors directly.


Space limitations prevent us from including more details on the locality analysis and optimization.

for example, each array and variable can be either remote or local, and remote data operations can be expressed as just an assignment statement (e.g data = remoteData; in Figure 1).


In order to enable existing LLVM optimizations to apply to communication in PGAS programs, a PGAS programming language front-end needs to generate LLVM IR with the address space feature.

the PGAS LLVM IR needs to include global pointers, which are an alternative way of representing a pointer to possibly remote memory and are recognizable by LLVM as pointer types, instead of the typical structure representation of wide pointers that include at least a node number and a local address.


The VFCache lookup could also have been merged with the call operation.

virtual function targets and their references are relatively few in number, frequently reused, and rarely updated.


To fully use the VFCache, the processor must be able to identify which memory loads are, in fact, loading from a virtual function table suitable for caching with this new hardware structure.

traditional ISAs make no special accommodations for virtual function tables.


A typical log message consists of timestamp, hostname, priority, facility, and an unstructured text message.

more information may be extracted from the text.


In Excel, the Date/Time format specifies date and time to high precision, but the specification lacks information about time zones, thus it is not possible to convert time stamps between zones (e.g., local to UTC), nor is it possible to handle DST offsets.

using Excel as the storage format in large research projects requires maintenance of metadata for every data set containing time stamp values.


The data management module organizes necessary geospatial data for trigger modeling.

each project corresponds to a project configuration file, where the information about the raster data such as topographic and fuel model data is stored.


the 1 h, 10 h, and 100 h dead fuel moisture were set to 6%, and the live fuel moisture for wood and herbaceous fuel types were both set to 65%.


Moreover, as the size of the corpus increases, the number of nonzero elements in the co-occurrence matrix does not necessarily increase at the same pace.

in some scenarios the product of the variety of different words and possible contexts would still exceed memory of a single machine.


Unfortunately, Go toolchain uses lightweight threads with minimal stacks that can grow dynamically with support of the Go runtime and external C libraries generally can't work on Go stack.

a cgo function call requires switching of thread's stacks, which adds substantial performance overhead.


Any software that is not compiled with the AVX option will NOT use this instruction set and will be limited to performing SSE-type floating point instructions (and hence restricted to two flops per cycle).

all are built with icc’s O3 level of optimization, AVX support, and icc’s ipo (inter-procedural optimization within and across source files).


Existing resource discovery approaches for IoT usually rely upon a single repository responsible for storing resource descriptions [3].

a centralized mechanism reveals several well-known drawbacks.


Social software allows quick access to information and easy means of networking.

its laden with barriers such as redundancy with regard to other systems, a loss of control over one s data and knowledge, and its also somewhat time-consuming.


As pointed out by the focus group, enabling tools and structures for citizen involvement in service design processes must be developed, be they instruments allowing programming or piecing together concrete e-services, or ways for citizens to communicate their e-service proposals to the Public Sector Bodies or third-party developers, helping them to realize and implement their drafts.

as we see it, the challenge does not lie that much in making citizens willing to participate in the extended CSLC, but to offer them the possibilities to do so.


In related work, concepts for context-aware workflows have been developed [3, 28] and proved to be applicable in practice.

they suffer from the drawback that modelling context-aware workflows needs exponentially many activities and branches to handle all the possible context values and combinations.


The aim of GoI project is to mathematically understand dynamical process of cut-elimination.

via Curry-Howard correspondence, GoI project aims to mathematically understand dynamical process of program execution.


However, in our case, the interpretation must be at a higher level: in the context of the application domain.

we must explain what the program does in terms of the domain concepts.


In order to overcome the technological barrier, we have proposed an interaction mechanism based on physical objects (combining mobile devices and NFC Technology) and sensors (Bluetooth LE technology) to adapt the task (depending on the user's location) and provide non-intrusive interaction.

the task adapts to user depending on the room.


Smart-homes are residences equipped with innovative technologies: sensors, wired and wireless networks, actuators and intelligent systems.

in many cases, their human-machine interfaces are very difficult to use, especially for people with limitations, since voice-based devices, gesture commands in vision-based interfaces are artificial, unfamiliar, and easily forgotten.


This includes functions such as: environment control, care in the home and communication with the world around them.

the system is capable of gathering: environmental parameters (temperature, luminosity, etc.) and security parameters (opening/closing of windows and doors, communication to/from family, friends, or medical staff, and even commands to devices such as on/off, up/down, etc.).


The OF-MMT home SDN domain controller is not able to compute such an inter-domain path, since it does not have the location information outside of its own controlled domain.

the SDN domain controller needs to communicate, through east/westbound interface, with the neighbouring SDN domain controllers to compute and setup network path towards CN.


Performance improves without cutoff on all runtime systems (Figure 1) since that provides suf.cient parallelism for our machine (Figure 11a).

we generalize load balance to include tasks and display work deviation per-grain.


In this paper, we present language extensions for distributing pipelines and a new compiler backend that generates distributed code.

the contributions of this paper are: A Halide language extension for distributing image processing pipelines, requiring programmers to write only approximately 10 new lines of code.


Consequently, there is more to UX than ever as the skills related to UX work have differentiated, new tools became available, and new ways of working, such as data-driven design, suggested.

in addition to these elementary digital design skills, future would probably show demand for skills in data analytics and evidence-based design.


In previous work, the operating system or specialized hardware takes sole responsibility for power and energy efficiency.

nRG-Loops enable applications to manage their own power and energy, resulting in more control for programmers and potentially more aggressive tradeoffs and therefore greater effciency.


In addition, a number of supplementary patterns were identified that should be documented in the future.

developers may not trust your motivation as a company.


It focuses on the need to facilitate users to find the knowledge they need by better linking it to business processes and the related context.

the reuse of knowledge can be facilitated, as well as its flows in the organisation.


Developers can use meta data (like annotations) to change some behavior of Scaffolding code generators, see lines 3 and 4 of Listing 5.

in Scenario 1, the necessary widgets were completely unpredictable.


The automatically generated diverse replicas use the hardware differently, such that the same hardware fault leads to different consequences during their execution.


how much the diversity technique affects the performance depends on the used method.


Hafiz et al. inspected the architecture of mail transfer agents.

they compared the architecture of qmail in terms of an efficient security pattern usage in contrast to send mail [Hafiz et al. 2004].


we only considered the first 100 results presented at each search page due to increasing number of unfitting publications after 100 results.


Applications are accessed from a Browser, which has a Cache and interacts with the application through a Proxy Server.

threat patterns are useful for developers because once they determine that a possible attack can happen in the environment, the pattern will indicate what security mechanisms are needed as countermeasures.


They may include misconfiguration exploits.

this section describes the solution of the attacker s problem, i.e., how the attack can reach its objectives and the expected results of the attack.


After the modules are executed, the integrity violation can be located in any subsystem and may be hard to find.

the execution of the malicious module should be prevented in the first place.


One of the challenges in large systems design is to recognize that it is the same entity or quantity (people usually know it, but tools don t), and to be able to reconcile the different characteristics and behaviors that may be assigned to it from different viewpoints.

we are also able to create similar guidelines for modelling that enable at least manual reconciliation of the contents of models in different subdomains.


In addition, the use of Time Series to evaluate the refactoring solutions is another reason of the higher execution time.

we can consider that an average of less than 25 minutes of difference between the execution time of our algorithm and existing work is not an issue especially that refactoring is not a real-time problem.


If the model well fits the data, the residuals of the model behave as an independent identically distributed sequence with a mean of zero and a variance of one.

the residual sequence should correspond to a white noise; otherwise, the model needs to be improved.


The processing instances are build on top of the Amazon Elastic Compute Cloud web service that provides scalable on-demand usage-based pay as you go compute capacity.

a platform for model storage using de facto standards.


For improving I/O performance in the virtualization environment, the minimum function of I/O stack, like merging, is necessary as the occasion demands.

using virtio to eliminate I/O scheduler of the guest also has negative impacts on I/O performance.


It only stacks I/O requests in the virtqueue in the order of arrival.

sorting is an unnecessary process and merely overhead for sequential write.


In work [6], a method for increasing I/O performance in virtualized environment by controlling block address in inode table in filesystem is proposed.

the work aimed only to improve random access performance and does not mention sequential I/O throughput, HDD zones, and Hadoop performance.


Even before finishing, their load was not high.

i/O utilization is not high at most times and CPU utilization is less than I/O utilization in Figure 4.


Of the 24 ratings of LondonTube, 21 exceeded the corresponding average rating of traditional tools; 2 ratings tied the corresponding average rating for traditional tools, and only 1 was lower.

londonTube ratings exceeding traditional ratings outnumbered LondonTube ratings beneath traditional ratings by a ratio of 21-to-1 (Table 3).


Patients can self-manage their drug use behavior by participating in self-help support groups [15, 18], such as Narcotics Anonymous (NA) [7], or through contact with experts and individuals with similar experience, such as the online forums on Reddit [9].

many patients might still suffer from mild withdrawal symptoms in the early phase of this treatment stage and probably experience periods of relapse.


C Viewport Stabilization: we can make sure that when switching between versions a node will always have the exact same position in the viewport, represented here by the boxes around the nodes.

the exceptional high standard error bars for the timeline condition in Task 3 and 6 can be explained by the different search strategies.


Usually, the same grouping mechanism is used for namespaces, classes, methods, loops, etc.

we can approximate a rough syntax tree by only parsing code based on this grouping mechanism.


On the other hand, gaining performance at the expense of high energy consumption might not be practical for the system under design.

metrics combining energy and performance have been proposed.


The EASE-DMF program takes a stone soup approach to funding in that each participant gains capabilities by providing a combination of funding and their own software capabilities to the soup.

we would like to thank the Army Modeling and Simulation Office, the Army Research Lab Simulation and Training Technology Center, and the US Army Corps of Engineers Institute for Systems Engineering Research for their support of this program.


Because of the path explosion problem, full path-sensitive detection may cost greatly in analysis.

partial path-sensitive detection are often applied in practical.


Our approach focuses on extracting user-specified web controls which act and appear the same as the one in the original context.

web controls that are designed for desktop devices may not fit mobile screens of vary sizes well.


As records generated by different people may refer to the same entity, we need to deduplicate the record in entity resolution -Attribute: An entity is described by a set of attributes.

further, we need to calculate the entropy of the entity's attribute.


Several of these companies have made substantial investments in the area of telehealth and many of them find that the public customers should just buy their solutions and get on with the job of providing telehealth services3 .


We used insights obtained from our first analysis to select the next incidents for analysis.

after the first incident analysis we became cognisant of the different modalities in which data assets are prevalent in organisations, namely (see Fig.  6(a)): data at rest (i.e., ‘inactive’ data stored in databases, file servers, archives, etc. that is not accessed or changed frequently), data in use (i.e., ‘active’ data processed by applications and held in computer memory, CPU caches/registers, or operational tables in databases) and data in motion (i.e., data in transit in the form of packets transported by communication protocols and data traversing the network, temporarily residing in memory buffers to be forwarded).


The ideal outcome for a mutation reduction strategy is to find the minimum set of mutants that can represent the complete set of mutants.

our results suggest that the variance of individual samples is rather low, and the situation improves quite a bit with larger projects  — e.g. the variance of commons-math1 is just 0.397%.


Of course, one can still point out that random sampling is subject to the vagaries of chance, as one can get arbitrarily good or bad samples.

our results suggest that the variance of individual samples is rather low, and the situation improves quite a bit with larger projects — e.g. the variance of commons-math1 is just 0.397%.


In comparison with previous work [53, 54] our analysis is backed by theory and compares random sampling to the limit of selection.

the results from our study are applicable to techniques such as clustering using static analysis, and even improved strata sampling techniques.


Portability requirements demand the system to be represented in a way that it .ts a specified environment, as for example the requirement The system shall run on platform X .

furthermore, they found that at the pro ject level, NFRs are not taken into consideration during product planning (and are thereby not included as hard requirements in the projects) and they conclude that the realization of NFRs is a reactive rather than proactive effort.


Our results suggest that most non-functional requirements are not non-functional as they describe behavior of a system.

we argue that many so-called NFRs can be handled similarly to functional requirements.


Furthermore, such real issue reports cannot be labeled by non-domain experts due to the lack of domain knowledge.

it is very difficult for us to obtain a large-scale real dataset with high-quality labels.


An issue report also includes a time stamp recording the time at which the report was received.

the issue report data can be treated as multi-dimensional, time series data.


Existing work in the area of energy-aware programming (e.g., [42, 60]) matches practitioners' focus on idle time by allowing computation to be degraded or delayed to save energy.

to use such features effectively, practitioners must understand the energy impacts of their code, which given their lack of intuition (see Section 3.4), may be infeasible.


From a distributed systems theoretic standpoint, mitigating the results of asynchrony is impossible [42].

integrators and contributors should agree on minimal communication protocols that increase each other's awareness and rendezvous points for mandatory information exchange.


we share the experimental data with the participants using an online survey platform, which forces the participants (1) to perform tasks in the desired order and (2) to fill in the questionnaires.

participants only got access to the final questionnaire after they had handed in their tasks, as well as they could not perform the second task without finishing the first one.


Having said this, ICFP papers analyzing human factors generally do not follow scienti.c conventions used in empirical disciplines.

null hypothesis H0-5: Experience level, defined by the position an individual has within an academic pipeline or professional status, has no impact on developer performance under any condition.


Further, given that our replication packet is trivial to port to other languages, our study simplifies the process of conducting such experiments for the community by providing a first baseline that can be adapted and tested under new conditions.

the reader should keep in mind that no single experiment on non-trivial ideas can tell us the whole truth, which is one reason why the broader programming language wars [49] have been so difficult to evaluate.


The code samples did not show any way to do this other than the [&] so that participants would not be confused and delayed.

our code samples can be considered generous for the lambda group, as we asked participants to use lambdas in only simple ways.


These handlers are indirectly called through event propagation mechanisms of JavaScript, where a single event can trigger multiple handlers of the ancestors of the target element [43].

we capture propagated handlers and their relations with the original events.


Second, lists are more widely used than other collections such as maps or sets (Gson: 60%, K-9 Mail: 57%, Apache Commons Math: 56%, XStream: 50%, Apache Commons Con.guration: 53%, Stock Exchange Trading Simulator: 57%).

the energy contribution from lists is probably higher than that from other collections.


The dedicated site page stated that the issue (breach) had been resolved, Yes.

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


In a nutshell, the Tuckman model says that teams fight several conflicts before they start performing.

team performance curves should show a certain behavior after the initial team setup, team reconfiguration, and over time.


To evaluate to which degree the implementation fulfills the requirements defined in Sec. 1, we performed a survey with
the students and measurements of the system’s performance.

not all questions share the same number of answers.


One student only gave positive feedback, but graded the system with poor.

we cannot rule out that students misunderstood the way they should score the system, leading to wrong marks.


These enable non-expertprogrammers to build and maintain polished expert-like solutions, leveraging their domain expertise to express and compute with complex models.

this flexibility presents a challenge for usage validation.


Indeed, the customer has to agree on what software they are paying for.

it is also well recognized that often the customer is not clear on their real requirements [35]; it is the responsibility of the requirements engineer to help identify, clarify, and agree upon the actual requirements with the customer.


Ethics describes a generally accepted set of moral principles, and addresses any intentional action that impacts negatively or positively the lives and values of others [21].

ethics provides moral guidance through principles; morals describe the goodness or badness of actions; values describe what an individual or a group thinks is valuable or important [18, 1].


By doing so, we are likely to incur a lock-in effect as we get tied in third-party software valuechains .

there was a desire of mapping progress rather than anxiety incidents, for example by highlighting lack of interactions as a sign of progress in anxiety reduction.


When there is a need to update the local data through multiple asynchronous requests and it is required that all them succeed, an error on a single call can lead to having incorrect information shown to the user.

developers need to explicitly implement proper recovery mechanisms, a task that most of times is complex and highly error prone, leading to tangled code and harder maintenance, especially in an asynchronous environment.


In code-centric development, one has to rely on manual code inspection for enforcing such policies - an error prone and time- and effort-intensive endeavor.

in model-driven approach, such policies can be enforced either at model validation time or at model creation time itself.


the architectural layers are wired together by middleware infrastructure that supports message passing in a variety of protocols such as synchronous, asynchronous, publishsubscribe etc.

developing a distributed application demands wide-ranging expertise in distributed computing architectures and technology platforms.


A change in design decision, say, switching over to update-intensive behaviour needs only the database layer model to be transformed using a different model-to-text transformer.

correct and consistent implementation of this change would be a huge challenge for code-centric approach.


The total time spent modeling ranges from approximately 9 to 30 man hours, not counting the time spent by the researchers conducting the workshops.

much of the time was spent on the type of discussions that many of the participants considered the most prominent benefit of the workshops.


As a system prototype, we have implemented a design tool which enables users to gather up every day objects and reassemble them to another functional shape with taking advantages of both analog and digital fabrication.

the system calculates the optimized positional relationship among objects, and generates joint objects to bond the objects together in order to achieve a certain shape.


The researchers focused on situations where both parties interacted.

they aimed to observe explicit or implicit negotiations of how security should be treated in software development and of who was to be responsible for taking on security-related tasks given their particular role in the team.


In consequence, the observations we make in experimental settings are only valid within those settings.

the validity of the theories we build is strongly dependent on the contexts which are difficult to define because of the complex human, economical, technological, and cultural factors involved [14].


To address this problem, a best practice-programming guide has been published by the OWASP foundation [9] to inform developers to match encoders to web contexts.

there is no systematic way to test whether encoder functions are used correctly.


According to Moore [16], organizations often prefer to learn through the experiences of other organizations that belong to the same industry.

organizations that are considering adopting DevOps can also benefit from a study that identifies the names of organizations that have adopted DevOps and are using software practices to integrate security.


The analysis of Internet artifacts and the survey indicated that, software practitioners find automated deployment to be beneficial to system's security.

both the analysis of artifacts and survey revealed a security concern related to automated deployment if the DevOps organization uses improper automated deployment tools, or overlooks the need of security practices in the desire to deploy software rapidly.


We used the setup shown in Figure 7 to measure the energy consumption of an app on the mobile device.

we used a Monsoon Power Monitor [37] to supply the mobile device with a steady voltage of 4.2 Volts and to measure its power consumption.


However, due to space restrictions, it would be impractical to discuss the design (& its re-factorings) for all of these 214 commits.

we choose only 6 important commits (referred to as commits a to f), by observing a plot of changes (both GUI, as well as, source code), as shown in Figure 10.


This project was active for a period of approximately two years, in which duration it saw 214 commits.

due to space restrictions, it would be impractical to discuss the design (& its re-factorings) for all of these 214 commits.


Essentially, any resource acquired during the execution of an app must be released before that app ceases to execute.

since real-life apps have many potential exit locations, ensuring resource releases at all such exit locations may be challenging (specially for apps with many GUI screens).


Another threat to validity to this work may arise due to the choice of subject programs.

dynodroid uses a publicly-available, Android tool Hierarchy Viewer [11], to obtain the UI layout of an app.


The performance optimization of these complex stencils on current many-core architectures is full of significance.

it is difficult and challenging to improve the performance of complex stencils on GPUs.


The original routing algorithm simply returns any shortest path between the two cores.

abstract cost functions may lead to poor or infeasible solutions.


Our approach to generating candidates is to expose this inherent tradeoff, using candidates of many different sizes then choosing the smallest canary from among the candidates that is similar enough to the full input according to one of the metrics described in Â§4.1.4.

we assume only that the application developer provides a well-defined accuracy calculation function.


The GC assumes the heap is contiguous, so the original blocks of these instances cannot remain empty.

since a block's size is calculated from the class of the object within it, a block cannot remain an instance of the class as the class is now bigger than the block containing it, and traversing such a block would break the heap structure.


Together with test engineers from our industrial partner, we defined one cost measure, i.e., Time Difference (TD), which represents difference in period between a time budget and execution cost for a solution, and three effectiveness measures: Mean Priority (MPR), Mean Probability (MPO) and Mean Consequence (MC).

in our context, each test case has four attributes: time, priority, probability, and consequence.


It may be tempting to think that it could have some efficiency benefit to let different writes (of different access patterns) operate on different views of an object.

for GPU, there are no such needs in practice.


The model eliminates the possibility of dangling pointers and races, and ensures memory safety.

this suggests that it is possible to have a fast GC implementation that also benefits from its implementation language's safety guarantees.


This is because GPUfs gread calls are blocking and use busy wait in GPU, wasting GPU resources due to the lack of an I/O preemption mechanism in GPUs.

we employ opportunistic batching, which relies on the high rate of gread requests from the GPU, and naturally enables accumulating several requests while the previous batch is being transferred.


These algorithms use special locality-preserving hash functions, which map neighboring objects in high dimensional space into approximately neighboring objects in the low dimensional space.

neighboring objects in the data set are likely to have the same hash key and therefore placed in the same bucket in a hash table.


Todays all-flash storage arrays exhibit excellent I/O throughput, latency, storage density, and energy efficiency.

besides measuring the RBER, they also use the page program time and the PEC to build a linear model to predict the error rate of blocks.


Before writing data, the target location must be erased, an operation that can only be performed at block granularity.

the data-placement unit draws freshly erased blocks from one of the Free Block Queues (FBQ) into the destage buffers, and separate destage buffers are maintained for each data stream.


In our prototype we implement coalesced threadblock-wide function calls, which are invoked by all the threads in a threadblock at the same point in the program, with the same arguments.

multiple buffers are required to implement double buffering, and computations must be broken down to work on small tiles that fit into smaller buffers.


They must be mapped into GPU address space in order to be accessible from the GPU.

the cudaHostRegister() call, which is used to map CPU physical memory into the GPU address space, does not support MMIO pages.


Kitten distinguished itself from their prior LWKs by providing a more complete Linux-compatible user environment.

with the ever growing appetite for full Unix/POSIX feature compatibility from the application side, it has become increasingly difficult to support all these features without compromising the primary goal of LWK performance.


The maximum and minimum thresholds in Figure 14 are not expected to be exceeded.

in the authors' proposition, two formal specifications (one written in algebraic notation and another using a synchronized transition system) describing the system are compared to each other, to help to understand and debug the informal requirements.


The approach is rather meant to validate certain system functionality with respect to the requirements.

to check whether certain scenarios executed on the real system can be found in the state space of the formal model, which may indicate that the system implements the requirements as expected.


A special treatment is required to handle function calls in a device statement.

a function must be compiled for the accelerator in order to make it accessible inside of a parallel region.


Scalar variables are implicitly private for an executing thread and need not be specified in a private clause in contrast to the presented OpenMP solution.

the accessed matrices and their associated memory pointers must be passed in a present clause to omit a memory exchange at region entry.


2, where 20 tags are recorded with 40% sampling probability.

one of them is to allow users to check the number of tags in an arbitrary tag flow passing through a distributed RFID system.


Quality drivers are the organizational motivations to invest in QM and when satisfied provide direct value to the organizational business objectives.

5) Little guidance and assessment to automation whether process automation or automated execution.


Because we lack type class constraints in the language (and equality constraints over existentially-bound variables can easily be normalized away), we simply omit perdata-constructor constraints.

typecase also performs runtime tests on type representations, and enables deconstructing type representations into their component parts for example, splitting a function type into a input type and output type.


Realizing such a contract relies on detecting calls to captured functions during the extent of a call to a closure.

such proxies wrap carriers of contracts and intercept events as needed.


Finally, while the original work on functional ornaments used a reflective universe, we use type classes as an open-ended and extensible meta-programming framework.

users are able to extend the framework at will, unlike the clients of a fixed reflective universe.


The third implementation is designed for the case of vertices with potentially many incoming edges.

we focus on the dynamics of parallel computations in general, which includes async-finish and also other parallelism abstractions.


Sideways composition provides a technique to avoid some of the limitations of static, single inheritance object-oriented systems where multi-dimensional composition of behavior is desirable.

context-oriented programming applies sideways composition to improve modularity.


The interaction layer is in charge of gathering information from the system's surrounding environment.

information coming from the physical environment (e.g., geographical localisation), the user (e.g., user preferences), or the system's computing platform (i.e., hardware and software conditions, such as the battery status).


Functional Hazard Analysis is the approach that is close to the approach presented below [13].

it does take a set of known functions as its starting point.


A proof certificate is similar to a proof object, but it can avoid recording all the needed information or encode it at a different level of detail.

a proof certificate may be non syntax directed, in the sense that multiple rules can be tried according to the same certificate, triggering backtracking if needed.


We observe that the tactics and tacticals that can be implemented in our system go beyond the LCF ones because we inherit full-backtracking from λProlog.

our tactics are naturally non-deterministic, i.e. they can have multiple solutions (that are enumerated via backtracking).


This difference makes our approach actually create new functions and insert function calls to those newly created functions in the source code.

in the previous techniques for on-chip memory management [33, 14] the created partitions are still part of the existing function; branches at partition boundaries need to be modified to maintain the original control flow even when the partitions are loaded to nonconsecutive memory ranges.


New tunneling protocols are being proposed on a daily basis.

a method specialized in a particular protocol will soon be out of date.


Through playtesting it was determined that of the implemented methods, map stations were the most effective in giving an overview of the game state.

in future iterations other methods of giving situation awareness will be tested.


We interpret this figure just like Figure 4.

clearly, a smartphone may be in a variety of states, but for our purposes we are effectively treating a screen event as a state.


Next, our analysis considers the battery level of the phone when a state transition takes place.

at the moment a transition was recorded by our software, we also noted the battery level at that moment.


World of Riders is intended to target casual players of both genders and various age groups who share attitudes of healthy lifestyle and regular exercising.

given the scope of the present project, it was addressed the audience who generally support the idea that regular exercising has a positive effect on their health, but in reality experience hard times in maintaining their level of motivation and engagement in performing such physical activities on a regular basis.


We will not detail all changes here, we just mention what we had to customize: variable declaration syntax in Xbase is different from Java so we customized the corresponding grammar rule; moreover, Xbase does not support several variable declarations in a single statement as in Java.

we must handle possible additional variable declarations in Jbase.


Finally, Xtext provides complete support for typical Java build tools, like Maven and Gradle.

xtext DSLs also automatically support these build tools.


As we showed in the examples of Section 4, it is straightforward with Jbase to introduce Java expressions and statements into an Xtext DSL.

we believe that Jbase is a valuable tool also for extending Java.


Users inspect the suggested annotation sets for soundness and can ask AUTOBAHN to automatically patch their program sources.

the data also shows that AUTOBAHN annotations outperform the hand annotations for gcSimulator: the geometric mean of gcSimulator running times when optimized by AUTOBAHN is 58.6% of the bare runtime, compared to a geometric mean of 64.8% of bare for the hand-optimized version.


They rely on a CPS-like interpretation of sessiontypes in terms of one-shot (or linear) channels, which they can implement using Scala's Future type.

unlike many presentations of session types, but inspired by their logical connections, our session types represent closing of channels explicitly.


One important aspect of a modern language runtime is warmup performance.

how the performance of the language runtime evolves after initialization and during justin-time compilation.


It is remarkable that despite this, we can still observe speedups up to a factor 10.

although non reproducible, we consider these measurements much more important in practice, since they are real life usages of the optimizer.


A fundamental challenge then is coming up with a probabilistic model of code which is both general and precise.

building such model is a difficult problem and one which has recently attracted the attention of researchers from several areas.


GRANDET always incurs less than 0.2ms latency, smaller than the standard deviation of latency for each case.

we modeled the usage data of Cumulus-Clips according to YouTube [51], where a billion users upload 300 hours of video per minute [40] and an average video has four minutes [14, 42].


Thus, given that the number of rewrite operations for STT-MRAM is a perfectly feasible number for main memory or CPU cache, STT-MRAM has the potential of serving as the main memory of computer systems like DRAM does today.

one disadvantage of STT-MRAM is that the write energy will be 102 times larger than that of DRAM.


We propose that the hypervisor layer, located between guest-OS software and physical hardware, is most suitable for implementing page placement optimization.

existing hypervisors designed for DRAM-only memory architecture, do not have any support for hybrid memory systems; there is no mechanism to allocate guest pages from DRAM and NVM pages and dynamically optimize page mappings.


In particular, the partitions from one iteration to the next are quite similar, thus, our smart partitioning assignment has significant benefits.

rUBiS reveals that as soon as the workload and data design becomes slightly more complex, the generated graphs and resulting partitions differ a lot from one iteration to the next.


Finally, in each iteration, we determine requests and objects that can be pruned.

we ignore requests and objects that have fading popularity and we ignore requests that have too high drift rate to benefit from caching.


New policies are sent to the load-balancer and the object caches whenever needed.

in order to not miss these situations, we trigger a new reconfiguration after a certain, fairly long time, even if the degradation threshold has not been reached.


Although a request type might access two objects, not every call will access these two objects.

we use as edge weight the sum of both objects access frequencies caused by requests that access both objects.


In addition, they use several optimizations to enhance the quality of the produced partitions.

they produce partitions with different content every time, and therefore, there is less overlap with the current object distribution.


This value is the total number of movements invoked by placing SSi at SLOTj .

orion not only improves performance up to 1.61 times speedup but also resource & energy efficiency, with up to 62.5% memory resource saving, and 6.7% energy reduction over the highly optimized code generated by nvcc (Section 4).


For example, the snippet might wait on a signal from a different thread to continue the execution.

[7] focuses on mining examples from unit tests claiming that this is a good source of examples as they are concise, relevant and trustworthy.


We thus argue that RPython is a more friendly VM development platform for novices than Slang/VMMaker.

many optimizations and platform interfaces can be developed using high-level RPython application programming interfaces (APIs).


Building on existing work by speculative designers and artists, this project opens opportunities for further research in HCI.

further research is needed to understand the role of interactive objects in helping the audience understand complex issues and create alternative narratives about the future.


The goal of this project is to demonstrate how speculative design and social media can be used in public discourse and suggest new avenues for research at the intersection of speculative design and HCI.

it is far from the completely dystopian and authoritarian future George Orwell portrayed in 1984.


Dewey also defined an experience as a balance between doing and undergoing [9].

experience is not something we receive passively but participate in the construction of it.


The overall goal of the workshop was to create a shared understanding of UX, provoke discussion and encourage rethinking and reflection, engage the employees to the design cultural change, co-create guidelines for empowerment, and ideate possible ways to implement them into the design process.

a participatory workshop was conducted in order to prepare the employees to accept this still quite unfamiliar and sometimes confusing methodology of UX that was only slightly familiar to them.


Yet, age-associated cognitive changes are not irreversible and can be improved with adequate training [I].

cognitive stimulation is a component of "active aging", a term was adopted by the World Health Organization (WHO) to promote a better quality of life and improved autonomy and independence of older people.


As a result, directly modifying a package declaration itself is currently not possible in PEoPL.

we wanted to show that PEoPL can indeed handle all DeltaJ operations, and thus left the product line as is (cf. [33]).


To ensure isolation of the different actors, objects that are transmitted over a mailbox have to implement the Message interface and are passed by copy.

there exist extensions to Kilim's type system to enable zero-copy message passing [10].


However, we found in experiences that also these people and their skill profiles are influenced by the overall ecosystem context.

we summarize further roles in this section with their commonly desired skills.


The results of the proof-of-concept empirical study, i.e., which of the afore-mentioned mappings have been identified in the explored games, are outlined in Table I.

the class diagram created for this mapping consists of an abstract Game class whose member function gameloop plays the role of the template method and defines the structure of the al-gorithm that implements the game loop.


In this experiment, we plan to implement an BCI (Brain Computer Interaction) interface, where the user will be able to change the from an avatar to another by measuring his/her brain activity.

if the User relaxes, her/his brain activity is in low level and its avatar morphs to a more gentle or friendly avatar, if the User is in alert, his/her brain activity is in high level and its avatar morphs to a more intimidating or hostile avatar.


For example, all the building should contain the fireproofing rating property.

and it is difficult for the domain experts who are not proficient in computer programming to write code for automatic checking.