Fundamental Approaches to Software Engineering 19th International Conference FASE 2016 Held as Part of the European Joint Conferences on Theory and Practice of Software ETAPS 2016 Eindhoven The Netherlands April 2 8 2016 Proceedings 1st Edition by Perdita Stevens, Andrzej Wąsowski 3642288722 9783642288722

Fundamental Approaches to Software Engineering 19th International Conference FASE 2016 Held as Part of the European Joint Conferences on Theory and Practice of Software ETAPS 2016 Eindhoven The Netherlands April 2 8 2016 Proceedings 1st Edition by Perdita Stevens, Andrzej Wąsowski – Ebook PDF Instant Download/DeliveryISBN:  3642288722, 9783642288722 

Full download Fundamental Approaches to Software Engineering 19th International Conference FASE 2016 Held as Part of the European Joint Conferences on Theory and Practice of Software ETAPS 2016 Eindhoven The Netherlands April 2 8 2016 Proceedings 1st Edition after payment.

Product details:

ISBN-10 :  3642288722 

ISBN-13 : 9783642288722

Author:  Perdita Stevens, Andrzej Wąsowski

This book constitutes the refereed proceedings of the 15th International Conference on Fundamental Approaches to Software Engineering, FASE 2012, held in Tallinn, Estonia, in March/April 2012, as part of ETAPS 2012, the European Joint Conferences on Theory and Practice of Software. The 33 full papers presented together with one full length invited talk were carefully reviewed and slected from 134 submissions. The papers are organized in topical sections on software architecture and components, services, verification and monitoring, intermodelling and model transformations, modelling and adaptation, product lines and feature-oriented programming, development process, verification and synthesis, testing and maintenance, and slicing and refactoring.

Fundamental Approaches to Software Engineering 19th International Conference FASE 2016 Held as Part of the European Joint Conferences on Theory and Practice of Software ETAPS 2016 Eindhoven The Netherlands April 2 8 2016 Proceedings 1st Table of contents:

1. Distributed Process Discovery and Conformance Checking
2. Introduction
3. Distributed Process Mining: An Overview
4. Process Discovery and Conformance Checking
5. Distributing Event Logs and Process Models
6. Representation of Event Logs and Process Models
7. Multisets
8. Event Logs
9. Procedural Models
10. Declarative Models
11. Measuring Conformance
12. Example: Horizontal Distribution Using Passages
13. Passages in Graphs
14. Distributed Conformance Checking Using Passages
15. Distributed Process Discovery Using Passages
16. Conclusion
17. References
18. Software Architecture and Components
19. Model-Driven Techniques to Enhance Architectural Languages Interoperability
20. Introduction
21. Interoperability via Pivot Languages
22. The Extension Mechanisms
23. Extension Operators
24. Identification of transformation paths
25. Case Study and Discussion
26. Putting the approach in practice
27. Discussion
28. Related work
29. Conclusion and Future Work
30. References
31. Moving from Specifications to Contracts in Component-Based Design
32. Introduction
33. Specification Theories
34. Building a Contract Framework
35. Contracts and Their Semantics
36. Refinement of Contracts
37. Composition of Contracts
38. Modal Contracts
39. Conclusion, Related Work, and Future Work
40. References
41. The SynchAADL2Maude Tool
42. Introduction
43. Background: Real-Time Maude and Synchronous AADL
44. Using the SynchAADL2Maude Tool
45. References
46. Services
47. Consistency of Service Composition
48. Introduction
49. Asynchronous Relational Nets
50. Trace-Based Models of Behaviour
51. Asynchronous Relational Nets
52. Consistency
53. Progress-Enabled ARNs
54. Safe ARNs
55. Interface Specifications for Safe ARNs
56. Interfaces and Orchestrations
57. A Logic of Safety Properties
58. Ensuring Delivery/Publication-Enabledness
59. Concluding Remarks
60. References
61. Stable Availability under Denial of Service Attacks through Formal Patterns
62. Introduction
63. Prerequisites
64. Rewriting Logic and Maude
65. Statistical Model Checking of Quantitative Properties
66. Stable Availability
67. Formal Patterns
68. The Meta-object Pattern
69. The ASV DoS Protection Meta-object Pattern
70. The Server Replicator Meta-object
71. Stable Availability under Denial of Service Attacks through Formal Patterns
72. ASV+SR Meta-object Composition Pattern
73. Statistical Model Checking Analysis
74. Related Work and Concluding Remarks
75. References
76. Loose Programming with PROPHETS
77. Introduction
78. Modeling the Domain
79. Process Synthesis
80. Conclusion
81. References
82. Verification and Monitoring
83. Schedule Insensitivity Reduction
84. Introduction
85. Motivation
86. System Model
87. Schedule Insensitivity Reduction
88. Deducing Schedule Insensitivity
89. Enhancing Symbolic Model Checking via Schedule Insensitivity
90. Implementation and Experimental Results
91. References
92. Adaptive Task Automata: A Framework for Verifying Adaptive Embedded Systems
93. Introduction
94. Preliminaries: Task Automata
95. Adaptive Task Automata
96. Encoding of the Adaptive Task Automata
97. Encoding the Predicate sched()
98. Encoding the Fixed Priority Scheduler
99. Variable Bounding
100. Examples
101. Admission Control – A Synthetic Example
102. Smartphone Task Management Example
103. Conclusion
104. References
105. Verified Resource Guarantees for Heap Manipulating Programs
106. Introduction
107. The Framework: Verification of Resource Guarantees
108. Inference of Resource Guarantees
109. Verification by Symbolic Execution
110. Upper Bounds for Heap Manipulating Programs
111. Path-Length Analysis
112. Cyclicity Analysis
113. Sharing Analysis
114. Verification of Path-Length Assertions
115. Heap Representation
116. Predicates for Structural Heap Properties
117. Field Update Independence
118. Path-Length Axiomatization
119. Experimental Results
120. Conclusions and Related Work
121. References
122. An Operational Decision Support Framework for Monitoring Business Constraints
123. Introduction
124. Declare
125. Mobucon Architecture
126. General Architecture
127. Mobucon Skeleton
128. Exchanged Data and Business Constraints States
129. Mobucon Clients
130. Mobucon LTL
131. Modeling and Implementation
132. Approach
133. Mobucon EC
134. Modeling
135. Reasoner Implementation
136. Case Study
137. Discussion and Conclusion
138. References
139. Intermodelling and Model Transformations
140. Intermodeling, Queries, and Kleisli Categories
141. Introduction
142. Running Example
143. Intermodeling and Kleisli Mappings
144. From Informal to Formal Mappings
145. Model Merging: A Sample Multi-mapping Scenario
146. The Kleisli Construction
147. A Sketch of the Formal Framework
148. Model Translation, Traceability and Fibrations
149. Query Mechanism via Monads and Fibrations
150. Related Work
151. Conclusion
152. References
153. Concurrent Model Synchronization with Conflict Resolution Based on Triple Graph Grammars
154. Introduction
155. Concurrent Model Synchronization Framework
156. Basic Model Synchronization Framework
157. Semi-automated Conflict Detection and Resolution
158. Concurrent Model Synchronization with Conflict Resolution
159. Correctness and Compatibility
160. Related Work
161. Conclusion and Future Work
162. References
163. Recursive Checkonly QVT-R Transformations with General when and where Clauses via the Modal Mu Calcu
164. Introduction
165. Background
166. QVT-R
167. Modal Mu Calculus
168. Connecting QVT-R and Modal Mu Calculus
169. The Transition System
170. The Mu Calculus Formula
171. Correctness of the Translation w.r.t. the Original QVT-R Game
172. Top Relation Challenges
173. Extending the QVT-R Game
174. Complex when and where Clauses
175. Recursive Transformations
176. Examples and Consequences
177. Expressiveness
178. Conclusion
179. References
180. Graph Transforming Java Data
181. Introduction
182. Related Work
183. Roadmap
184. Graphs and Annotations
185. Graphs and Type Graphs
186. Definition of Node Types
187. Definition of Edge Types
188. Definition of Attributes
189. Definition of Manipulation Methods
190. Invasiveness
191. Transformation Language
192. Rule Structure
193. Match Blocks
194. Update Blocks
195. Sequence Blocks
196. Semantics
197. Experience and Evaluation
198. Using the rdt in JamaicaVM
199. Evaluation
200. Future Work
201. References
202. Modelling and Adaptation
203. Language Independent Refinement Using Partial Modeling
204. Introduction
205. Adding Partiality to Modeling Languages
206. Combining and Applying Partiality Types
207. Formalizing Partiality
208. Tool Support and Preliminary Evaluation
209. Related Work
210. Conclusion and Future Work
211. References
212. A Conceptual Framework for Adaptation
213. Introduction
214. When is a Software Component Adaptive?
215. Architectures, Patterns and Reference Models for Adaptivity
216. Adaptivity in Various Computational Paradigms
217. A Formal Model for our Framework
218. Conclusion and Future Developments
219. References
220. Product Lines and Feature-Oriented Programming
221. Applying Design by Contract to Feature-Oriented Programming
222. Introduction
223. Background
224. Contracts for Feature-Oriented Programming
225. Refinement of Invariants
226. Comparison
227. Evaluation
228. Related Work
229. Conclusion
230. References
231. Integration Testing of Software Product Lines Using Compositional Symbolic Execution
232. Introduction
233. Background
234. Symbolic Execution
235. Symbolic Method Summary
236. Dependence-Driven Compositional Analysis
237. Relating SPL Models to Implementations
238. Calculating Feature Interactions
239. Composing Feature Summaries
240. Complexity and Optimization of Summary Composition
241. Case Study
242. Objects of Analysis
243. Method and Metrics
244. Results
245. Conclusions and Future Work
246. References
247. Combining Related Products into Product Lines
248. Introduction
249. Preliminaries
250. Model Merging
251. Product Line Refactoring
252. Correctness of Product Line Refactoring
253. Related Work
254. Conclusion and Future Work
255. References
256. Development Process
257. Tracing Your Maintenance Work – A Cross-Project Validation of an Automated Classification Dictiona
258. Introduction
259. Automated Classification Approach
260. Classification Rules
261. Categorization Tool – Subcat
262. Generation of a Cross-Project Valid Dictionary
263. Criteria and Selection of Open Source Projects
264. Populating the Dictionary
265. Evaluation of the Dictionary
266. Inter-rater Agreement
267. Conducting the Evaluation
268. Interpretation of the Evaluation
269. Related Work
270. Conclusion
271. Discussion
272. Future Work
273. References
274. Cohesive and Isolated Development with Branches
275. Introduction
276. Theory
277. Methodology
278. Evaluation
279. Rapid DVC Adoption
280. Cohesion
281. Coupling and Interruptions
282. Threats to Validity
283. Related Work
284. Conclusion and Future Work
285. References
286. Making Software Integration Really Continuous
287. Introduction
288. Problem
289. Solution
290. Tracking Changes
291. Background Merging
292. Conflict Detection
293. Reporting Conflicts
294. Evaluation
295. Related Work
296. Conclusion and Future Work
297. References
298. Extracting Widget Descriptions from GUIs
299. Introduction
300. Design Principles of GUIs
301. Extraction of Widget Descriptions
302. Empirical Evaluation
303. Related Work
304. Conclusions
305. References
306. Verification and Synthesis
307. Language-Theoretic Abstraction Refinement
308. Introduction
309. From Safety Verification to Language Emptiness
310. Preliminaries
311. From Programs to Context Free Languages
312. The Abstraction-Refinement Procedure
313. CEGAR Loop
314. The Regular Approximator mkreg
315. The Counterexample Generator gencx
316. Experiments
317. Recursive Multi-threaded Programs
318. Bluetooth Drivers
319. Conclusion
320. References
321. Learning from Vacuously Satisfiable Scenario-Based Specifications
322. Introduction
323. Motivating Example
324. Background
325. Triggered Scenarios
326. Fluent Linear Temporal Logic
327. Modal Transition Systems
328. Approach
329. Checking Vacuity of Triggered Scenarios
330. Learning Triggered Scenarios
331. Case Studies
332. Philips Television Set Configuration
333. Air Traffic Control System
334. Discussion and Related Work
335. Conclusion and Future Work
336. References
337. Explanations for Regular Expressions
338. Introduction
339. Deficiencies of Regular Expressions
340. Explanation Representations and Their Computation
341. Structural Analysis and Decomposition
342. Format Analysis
343. User-Directed Intent Analysis
344. Combined Explanations
345. Evaluation
346. Evaluating the Explanation Notation Using Cognitive Dimensions
347. Applicability of Explanations
348. Threats to Validity
349. Related Work
350. Conclusions
351. References
352. Testing and Maintenance
353. On the Danger of Coverage Directed Test Case Generation
354. Introduction
355. Related Work
356. Study
357. Experimental Setup Overview
358. Mutant Generation
359. Test Data Generation
360. Test Suite Reduction
361. Computing Fault Finding
362. Results and Analysis
363. Statistical Analysis
364. Evaluation of RQ1 and RQ2
365. Discussion
366. Threats to Validity
367. Conclusion and Future Work
368. References
369. Reduction of Test Suites Using Mutation
370. Introduction
371. Related Work
372. Test Suite Reduction Using Mutation
373. Example
374. “A Motivational Example”
375. Experiments
376. Experiment 1: Benchmark Programs
377. Experiment 2: Industrial Programs
378. Conclusions and Future Work
379. References
380. Model-Based Filtering of Combinatorial Test Suites
381. Introduction
382. An Illustrative Case Study
383. Basic Tobias Test Patterns
384. New Tobias Constructs
385. The Incremental Unfolding and Filtering Process
386. Standard Unfolding and Filtering Process
387. Incremental Unfolding and Filtering Process
388. Some Experimental Results
389. Related Work
390. Conclusion and Perspectives
391. References
392. A New Design Defects Classification: Marrying Detection and Correction
393. Introduction
394. Problem Statement
395. Defects Classification Using Genetic Programming
396. Overview
397. Design Defects Classification Using Genetic Programming
398. Validation
399. Research Questions
400. Setting
401. Results
402. Discussions
403. Related Work
404. Conclusion
405. References
406. Slicing and Refactoring
407. Fine Slicing
408. Introduction
409. Fine Slicing
410. Extract Computation
411. A Theory of Fine Slicing
412. Extract Computation
413. Discussion
414. Implementation
415. Evaluation
416. Related Work
417. Future Work
418. References
419. System Dependence Graphs in Sequential Erlang
420. Introduction
421. Related Work
422. Preliminaries
423. Erlang Dependence Graphs
424. Control Edges
425. Data Edges
426. Input/Output Edges
427. Summary Edges
428. Slicing Erlang Specifications
429. Conclusions and Future Work
430. References
431. A Domain-Specific Language for Scripting Refactorings in Erlang
432. Introduction
433. Erlang, Wrangler and Its Template-Based API
434. Terminology
435. Rationale
436. A Framework for Scripting Composite Refactorings
437. Refactoring Command Generators
438. The Domain-Specific Language
439. Tracking of Entity Names
440. Examples
441. Implementation
442. Related Work
443. Conclusions and Future Work
444. References

People also search for Fundamental Approaches to Software Engineering 19th International Conference FASE 2016 Held as Part of the European Joint Conferences on Theory and Practice of Software ETAPS 2016 Eindhoven The Netherlands April 2 8 2016 Proceedings 1st:

international conference on fundamental approaches to software engineering
    
international conference on fundamental approaches to software engineering 2025
    
fundamental approaches to software engineering 2025
    
fundamental approaches to software engineering 2024
    
what are the fundamental approaches to project management

Tags: Fundamental Approaches, Software Engineering, International Conference, Joint Conferences, Perdita Stevens, Andrzej Wąsowski