The C standard formalized in Coq

values hide internal details of the memory such as permissions, padding and object representations. They are therefore used in the external interface of the memory model and throughout the operational semantics. Memory trees, abstract values and bits with permissions can be converted into each other. These conversions are used to define operations internal to the memory model. However, none of these conversions are bijective because different information is materialized in these three data types: Abstract values Memory trees Bits with permissions Permissions X X Padding always E X Variants of union X X Mathematical values Xvalues Memory trees Bits with permissions Permissions X X Padding always E X Variants of union X X Mathematical values X This table indicates that abstract values and sequences of bits are complementary. Memory trees are a middle ground, and therefore suitable to describe both the lowlevel and high-level aspects of the C memory.

[1]  Saul A. Kripke,et al.  Semantical Analysis of Intuitionistic Logic I , 1965 .

[2]  Robert W. Floyd,et al.  Assigning meaning to programs , 1967 .

[3]  de Ng Dick Bruijn Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem , 1972 .

[4]  Edsger W. Dijkstra,et al.  Guarded commands, nondeterminacy and formal derivation of programs , 1975, Commun. ACM.

[5]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[6]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[7]  Matthias Felleisen,et al.  A Syntactic Theory of Sequential Control , 1987, Theor. Comput. Sci..

[8]  Thierry Coquand,et al.  The Calculus of Constructions , 1988, Inf. Comput..

[9]  Thierry Coquand,et al.  Inductively defined types , 1988, Conference on Computer Logic.

[10]  Christine Paulin-Mohring,et al.  Extracting ω's programs from proofs in the calculus of constructions , 1989, POPL '89.

[11]  Philip Wadler,et al.  How to make ad-hoc polymorphism less ad hoc , 1989, POPL '89.

[12]  Eugenio Moggi,et al.  Computational lambda-calculus and monads , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[13]  Philip Wadler,et al.  Comprehending monads , 1990, Mathematical Structures in Computer Science.

[14]  Yuri Gurevich,et al.  The Semantics of the C Programming Language , 1992, CSL.

[15]  Dennis Ritchie,et al.  The development of the C language , 1993, HOPL-II.

[16]  de Ng Dick Bruijn,et al.  Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem , 1972 .

[17]  Jonathan G. Rossie,et al.  An algebraic semantics of subobjects , 1995, OOPSLA.

[18]  Phillip J. Windley,et al.  Inference Rules for Programming Languages with Side Effects in Expressions , 1996, TPHOLs.

[19]  Robert Pollack,et al.  How to Believe a Machine-Checked Proof , 1997 .

[20]  Michael Norrish C formalised in HOL , 1998 .

[21]  Michael Norrish,et al.  Deterministic Expressions in C , 1999, ESOP.

[22]  Hiroshi Nakano,et al.  A modality for recursion , 2000, Proceedings Fifteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.99CB36332).

[23]  Nikolaos Papaspyrou,et al.  A Formal Semantics for the C Programming Language , 2000 .

[24]  David Delahaye,et al.  A Tactic Language for the System Coq , 2000, LPAR.

[25]  Christine Paulin-Mohring,et al.  The coq proof assistant reference manual , 2000 .

[26]  Peter W. O'Hearn,et al.  Local Reasoning about Programs that Alter Data Structures , 2001, CSL.

[27]  David von Oheimb Hoare logic for Java in Isabelle/HOL , 2001, Concurr. Comput. Pract. Exp..

[28]  Andrew W. Appel,et al.  An indexed model of recursive types for foundational proof-carrying code , 2001, TOPL.

[29]  George C. Necula,et al.  CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs , 2002, CC.

[30]  David J. Pym,et al.  The semantics and proof theory of the logic of bunched implications , 2002, Applied logic series.

[31]  Tobias Nipkow,et al.  Hoare Logic for NanoJava: Auxiliary Variables, Side Effects, and Virtual Methods Revisited , 2002, FME.

[32]  Edsger W. Dijkstra,et al.  Cooperating sequential processes , 2002 .

[33]  Bart Jacobs,et al.  Java Program Verification at Nijmegen: Developments and Perspective , 2003, ISSS.

[34]  Anthony C. J. Fox,et al.  Formal Specification and Verification of ARM6 , 2003, TPHOLs.

[35]  Patrick Cousot,et al.  A static analyzer for large safety-critical software , 2003, PLDI '03.

[36]  John Tang Boyland,et al.  Checking Interference with Fractional Permissions , 2003, SAS.

[37]  Tobias Nipkow,et al.  Certifying Machine Code Safety: Shallow Versus Deep Embedding , 2004, TPHOLs.

[38]  Lionel Mamane,et al.  Interactive mathematical documents: creation and presentation , 2004 .

[39]  Peter W. O'Hearn,et al.  Resources, Concurrency and Local Reasoning , 2004, CONCUR.

[40]  Pierre Letouzey,et al.  Programmation fonctionnelle certifiée : L'extraction de programmes dans l'assistant Coq. (Certified functional programming : Program extraction within Coq proof assistant) , 2004 .

[41]  Tobias Nipkow,et al.  A machine-checked model for a Java-like language, virtual machine, and compiler , 2006, TOPL.

[42]  Thomas Bäck,et al.  Mixed-integer evolution strategies for parameter optimization and their applications to medical image analysis , 2005 .

[43]  Lars Birkedal,et al.  BI Hyperdoctrines and Higher-Order Separation Logic , 2005, ESOP.

[44]  B. Lijnse,et al.  TOP to the rescue. Task-oriented programming for incident response applications , 2005 .

[45]  Tim K. Cocx,et al.  Metrics and visualisation for crime analysis and genomics , 2005 .

[46]  Peter W. O'Hearn,et al.  Symbolic Execution with Separation Logic , 2005, APLAS.

[47]  Benjamin C. Pierce,et al.  Mechanized Metatheory for the Masses: The PoplMark Challenge , 2005, TPHOLs.

[48]  R.S.S. O'Connor,et al.  Incompleteness & completeness : formalizing logic and analysis in type theory , 2005 .

[49]  Peter W. O'Hearn,et al.  Permission accounting in separation logic , 2005, POPL '05.

[50]  Xavier Leroy,et al.  Formal certification of a compiler back-end or: programming a compiler with a proof assistant , 2006, POPL '06.

[51]  Michael Norrish A formal semantics for c , 2007 .

[52]  Andrew W. Appel,et al.  Separation Logic for Small-Step cminor , 2007, TPHOLs.

[53]  Benjamin Grégoire,et al.  The MOBIUS Proof Carrying Code Infrastructure , 2008, FMCO.

[54]  Andrew W. Appel,et al.  A very modal model of a modern, major, general type system , 2007, POPL '07.

[55]  van Mpwj Michiel Osch Model-based testing of hybrid systems , 2007 .

[56]  Peter W. O'Hearn,et al.  Local Action and Abstract Separation Logic , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[57]  Michael Norrish,et al.  Types, bytes, and separation logic , 2007, POPL '07.

[58]  Tom Ridge,et al.  Ott: effective tool support for the working semanticist , 2007, ICFP '07.

[59]  M. D. Berg,et al.  Optimal Geometric Data Structures , 2007 .

[60]  Reiner Hähnle,et al.  KeY-C: A Tool for Verification of C Programs , 2007, CADE.

[61]  Farhad Arbab,et al.  Model Checking of Component Connectors , 2007, 31st Annual International Computer Software and Applications Conference (COMPSAC 2007).

[62]  Thomas A. Henzinger,et al.  The software model checker Blast , 2007, International Journal on Software Tools for Technology Transfer.

[63]  Matthieu Sozeau,et al.  First-Class Type Classes , 2008, TPHOLs.

[64]  Andrew W. Appel,et al.  Multimodal Separation Logic for Reasoning About Operational Semantics , 2008, MFPS.

[65]  Michael Norrish,et al.  A Brief Overview of HOL4 , 2008, TPHOLs.

[66]  Andrew W. Appel,et al.  Oracle semantics , 2008 .

[67]  Xavier Leroy,et al.  Formal Verification of a C-like Memory Model and Its Uses for Verifying Program Transformations , 2008, Journal of Automated Reasoning.

[68]  Frank Piessens,et al.  The VeriFast program verifier , 2008 .

[69]  Andrew W. Appel,et al.  Oracle Semantics for Concurrent Separation Logic , 2008, ESOP.

[70]  Tobias Nipkow,et al.  The Isabelle Framework , 2008, TPHOLs.

[71]  Scw Bas Ploeger,et al.  Improved verification methods for concurrent systems , 2009 .

[72]  Michael Norrish,et al.  seL4: formal verification of an OS kernel , 2009, SOSP '09.

[73]  Hasan Sözer,et al.  Architecting Fault-Tolerant Software Systems , 2009 .

[74]  Hugo Jonker,et al.  Security matters : privacy in voting and fairness in digital exchange , 2009 .

[75]  Xavier Leroy,et al.  Formal verification of a realistic compiler , 2009, CACM.

[76]  Hervé Grall,et al.  Coinductive big-step operational semantics , 2009, Inf. Comput..

[77]  M. J. de Mol,et al.  Reasoning about functional programs : Sparkle, a proof assistant for Clean , 2009 .

[78]  van Mj Muck Weerdenburg,et al.  Efficient rewriting techniques , 2009 .

[79]  Oscar H. Ibarra,et al.  On spiking neural P systems , 2006, Natural Computing.

[80]  Zaynah Dargaye,et al.  Vérification formelle d'un compilateur optimisant pour langages fonctionnels. (Formal verification of an optimizing compiler for functional languages) , 2009 .

[81]  Mari Antonius Cornelis Dekker,et al.  Flexible Access Control for Dynamic Collaborative Environments , 2009 .

[82]  A. Rodriguez Yakushev,et al.  Towards Getting Generic Programming Ready for Prime Time , 2009 .

[83]  Tingting Han,et al.  Diagnosis, Synthesis and Analysis of Probabilistic Models , 2009, Ausgezeichnete Informatikdissertationen.

[84]  Mohammed G. Khatib MEMS-Based Storage Devices : Integration in Energy-Constrained Mobile Systems , 2009 .

[85]  J. Kwisthout,et al.  The Computational Complexity of Probabilistic Networks , 2009 .

[86]  Sebastiaan Gijsbert Marinus Cornelissen,et al.  Evaluating Dynamic Analysis Techniques for Program Comprehension , 2009 .

[87]  Magnus O. Myreen Formal verification of machine-code programs , 2011 .

[88]  Karina R. Olmos Joffré Strategies for Context Sensitive Program Transformation , 2009 .

[89]  Andrew W. Appel,et al.  A Fresh Look at Separation Algebras and Share Accounting , 2009, APLAS.

[90]  Arthur I. Baars,et al.  Embedded Compilers , 2009 .

[91]  H. Hansen Coalgebraic Modelling : Applications in Automata theory and Modal logic , 2009 .

[92]  Burkhart Wolff,et al.  HOL-Boogie—An Interactive Prover-Backend for the Verifying C Compiler , 2009, Journal of Automated Reasoning.

[93]  Marcel Verhoef,et al.  Modeling and validating distributed embedded real-time control systems , 2009 .

[94]  Xavier Leroy,et al.  A Formally Verified Compiler Back-end , 2009, Journal of Automated Reasoning.

[95]  J. van den Berg,et al.  Reasoning about Java programs in PVS using JML , 2009 .

[96]  Matthieu Sozeau A New Look at Generalized Rewriting in Type Theory , 2009, J. Formaliz. Reason..

[97]  Mark A. Hillebrand,et al.  VCC: A Practical System for Verifying Concurrent C , 2009, TPHOLs.

[98]  Marcin Czenko,et al.  TuLiP : reshaping trust management , 2009 .

[99]  Tim K. Cocx,et al.  Algorithmic tools for data-oriented law enforcement , 2009 .

[100]  D. Costa Formal models for component connectors , 2010 .

[101]  Mohammad Mahdi Jaghoori,et al.  Time At Your Service: Schedulability Analysis of Real-Time and Distributed Services , 2010 .

[102]  D. Engler,et al.  A few billion lines of code later , 2010, Commun. ACM.

[103]  Assia Mahboubi,et al.  An introduction to small scale reflection in Coq , 2010, J. Formaliz. Reason..

[104]  Herman Geuvers,et al.  Pure Type Systems without Explicit Contexts , 2010, LFMTP.

[105]  J. K. Berendsen,et al.  Abstraction, prices and probability in model checking timed automata , 2010 .

[106]  Tom Staijen,et al.  Graph-based Specification and Verification for Aspect-Oriented Languages , 2010 .

[107]  Yanjing Wang,et al.  Epistemic Modelling and Protocol Dynamics , 2010 .

[108]  de A. Bruin,et al.  Service-oriented discovery of knowledge : foundations, implementations and applications , 2010 .

[109]  Francesco Zappa Nardelli,et al.  x86-TSO , 2010, Commun. ACM.

[110]  Shuvendu K. Lahiri,et al.  Towards Scalable Modular Checking of User-Defined Properties , 2010, VSTTE.

[111]  Yves Bertot,et al.  Interactive Theorem Proving and Program Development: Coq'Art The Calculus of Inductive Constructions , 2010 .

[112]  C. J. Boogerd,et al.  Focusing Automatic Code Inspections , 2010 .

[113]  Guillaume Melquiond,et al.  Flocq: A Unified Library for Proving Floating-Point Algorithms in Coq , 2011, 2011 IEEE 20th Symposium on Computer Arithmetic.

[114]  B. J. Arnoldus,et al.  An illumination of the template enigma : software code generation with templates , 2011 .

[115]  A. Morali,et al.  IT architecture-based confidentiality risk assessment in networks of organizations , 2011 .

[116]  Z Zvezdan Protic,et al.  Configuration management for models : generic methods for model comparison and model co-evolution , 2011 .

[117]  Hendrik Michaël van der Bijl,et al.  On changing models in model-based testing , 2011 .

[118]  Miguel E. Andrés,et al.  Quantitative Analysis of Information Leakage in Probabilistic and Nondeterministic Systems , 2011, ArXiv.

[119]  Xavier Leroy,et al.  Formal verification of object layout for c++ multiple inheritance , 2011, POPL '11.

[120]  Somayeh Malakuti Khah Olun Abadi Event composition model: achieving naturalness in runtime enforcement , 2011 .

[121]  José Proença,et al.  Synchronous Coordination of Distributed Components , 2011 .

[122]  Xuejun Yang,et al.  Finding and understanding bugs in C compilers , 2011, PLDI '11.

[123]  van Pja Paul Tilburg From computability to executability : a process-theoretic view on automata theory , 2011 .

[124]  Robbert Krebbers,et al.  A Formalization of the C99 Standard in HOL, Isabelle and Coq , 2011, Calculemus/MKM.

[125]  Christian Krause,et al.  Reconfigurable Component Connectors , 2011 .

[126]  Lacramioara Astefanoaei,et al.  An executable theory of multi-agent systems refinement , 2011 .

[127]  Stephanie Kemper,et al.  Modelling and analysis of real-time coordination patterns , 2011 .

[128]  Bas Spitters,et al.  Type classes for efficient exact real arithmetic in Coq , 2011, Log. Methods Comput. Sci..

[129]  Bas Spitters,et al.  Type classes for mathematics in type theory† , 2011, Mathematical Structures in Computer Science.

[130]  Herman Geuvers,et al.  The correctness of Newman's typability algorithm and some of its extensions , 2011, Theor. Comput. Sci..

[131]  Liang Gu,et al.  CertiKOS: a certified kernel for secure cloud computing , 2011, APSys.

[132]  Bas Spitters,et al.  Computer Certified Efficient Exact Reals in Coq , 2011, Calculemus/MKM.

[133]  Adam Chlipala,et al.  Mostly-automated verification of low-level programs in computational separation logic , 2011, PLDI '11.

[134]  Ronald Middelkoop,et al.  Capturing and exploiting abstract views of states in OO verification , 2011 .

[135]  S. Georgievska Probability and Hiding in Concurrent Processes ( thesis abstract ) , 2011 .

[136]  Lars Birkedal,et al.  Verifying Object-Oriented Programs with Higher-Order Separation Logic in Coq , 2011, ITP.

[137]  Francesco Zappa Nardelli,et al.  Lem: A Lightweight Tool for Heavyweight Semantics , 2011, ITP.

[138]  R. Bakhshi Gossiping Models : Formal Analysis of Epidemic Protocols , 2011 .

[139]  Hongseok Yang,et al.  Step-indexed kripke models over recursive worlds , 2011, POPL '11.

[140]  Young-Joo Moon,et al.  Stochastic models for quality of service of component connectors , 2011 .

[141]  Andreas Lochbihler,et al.  Animating the Formalised Semantics of a Java-Like Language , 2011, ITP.

[142]  Peter Sewell,et al.  Mathematizing C++ concurrency , 2011, POPL '11.

[143]  Emmanuele Zambon,et al.  Towards optimal IT availability planning: methods and tools , 2011 .

[144]  Bas Basten,et al.  Ambiguity Detection for Programming Language Grammars , 2011 .

[145]  Andrew W. Appel Verified Software Toolchain - (Invited Talk) , 2011, ESOP.

[146]  K. Tsirogiannis,et al.  Analysis of flow and visibility on triangulated terrains , 2011 .

[147]  S. Rajamani,et al.  A decade of software model checking with SLAM , 2011, Commun. ACM.

[148]  W. Kuijper Compositional Synthesis of Safety Controllers , 2012 .

[149]  Warren A. Hunt,et al.  Towards a Formal Model of the X86 ISA , 2012 .

[150]  Milo M. K. Martin,et al.  Formalizing the LLVM intermediate representation for verified program transformations , 2012, POPL '12.

[151]  Xavier Leroy,et al.  Validating LR(1) Parsers , 2012, ESOP.

[152]  Adriaan Middelkoop,et al.  Inference of Program Properties with Attribute Grammars, Revisited , 2012 .

[153]  Rafal Kolanski,et al.  Mechanised Separation Algebra , 2012, ITP.

[154]  John Regehr,et al.  Understanding integer overflow in C/C++ , 2012, ICSE 2012.

[155]  D. E. Nadales Agut,et al.  A Compositional Interchange Format for Hybrid Systems: Design and Implementation , 2012 .

[156]  Ljp Luc Engelen From napkin sketches to reliable software , 2012 .

[157]  Fpm Frank Stappers Bridging formal models : an engineering perspective , 2012 .

[158]  Gilles Barthe,et al.  A Formally Verified SSA-Based Middle-End - Static Single Assignment Meets CompCert , 2012, ESOP.

[159]  Alvin Cheung,et al.  Undefined behavior: what happened to my code? , 2012, APSys.

[160]  Kab Kevin Verbeek Algorithms for cartographic visualization , 2012 .

[161]  Lars Birkedal,et al.  Charge! - A Framework for Higher-Order Separation Logic in Coq , 2012, ITP.

[162]  Xavier Leroy,et al.  The CompCert Memory Model, Version 2 , 2012 .

[163]  Robbert Krebbers,et al.  A call-by-value lambda-calculus with lists and control , 2012, CL&C.

[164]  Andreas Lochbihler,et al.  A machine-checked, type-safe model of Java concurrency: language, virtual machine, memory model, and verified compiler , 2012 .

[165]  Charles McEwen Ellison,et al.  A formal semantics of C with applications , 2012 .

[166]  Brian Campbell,et al.  An Executable Semantics for CompCert C , 2012, CPP.

[167]  Chucky Ellison,et al.  An executable formal semantics of C with applications , 2011, POPL '12.

[168]  van Mf Marcel Amstel,et al.  Assessing and improving the quality of model transformations , 2012 .

[169]  Jonathan Aldrich,et al.  Verifying Higher-Order Imperative Programs with Higher-Order Separation Logic , 2012 .

[170]  Hossein Rahmani,et al.  Analysis of protein-protein interaction networks by means of annotated graph mining algorithms , 2012 .

[171]  Aah Ammar Osaiweran Formal development of control software in the medical systems domain , 2012 .

[172]  Xuejun Yang,et al.  Test-case reduction for C compiler bugs , 2012, PLDI.

[173]  Trajce Dimkov,et al.  Alignment of organizational security policies: Theory and Practice , 2012 .

[174]  Nikolai Kosmatov,et al.  Frama-C - A Software Analysis Perspective , 2012, SEFM.

[175]  John Businge,et al.  Co-evolution of the Eclipse SDK Framework and Its Third-Party Plug-Ins , 2013, 2013 17th European Conference on Software Maintenance and Reengineering.

[176]  Robbert Krebbers,et al.  Separation Logic for Non-local Control Flow and Block Scope Variables , 2013, FoSSaCS.

[177]  Jja Jeroen Keiren,et al.  Advanced reduction techniques for model checking , 2013 .

[178]  Guillaume Melquiond,et al.  Floating-point arithmetic , 2023, Acta Numerica.

[179]  M. S. Greiler,et al.  Test Suite Comprehension for Modular and Dynamic Systems , 2013 .

[180]  Mark Timmer,et al.  Efficient modelling, generation and analysis of Markov automata , 2013 .

[181]  Herman Geuvers,et al.  The λμT-calculus , 2013, Ann. Pure Appl. Log..

[182]  Andrew W. Appel,et al.  Mostly Sound Type System Improves a Foundational Program Verifier , 2013, CPP.

[183]  Reynald Affeldt,et al.  Towards formal verification of TLS network packet processing written in C , 2013, PLPV.

[184]  J. P. Boender,et al.  Certified Complexity (CerCo) , 2013, FOPARA.

[185]  Magnus O. Myreen,et al.  Translation validation for a verified OS kernel , 2013, PLDI.

[186]  L. Lensink,et al.  Applying formal methods in software development , 2013 .

[187]  Robbert Krebbers,et al.  Aliasing Restrictions of C11 Formalized in Coq , 2013, CPP.

[188]  Dhp Dirk Gerrits Pushing and pulling : computing push plans for disk-shaped robots, and dynamic labelings for moving points , 2013 .

[189]  Jean-François Monin,et al.  Handcrafted Inversions Made Operational on Operational Semantics , 2013, ITP.

[190]  Lauretta O. Osho,et al.  Axiomatic Basis for Computer Programming , 2013 .

[191]  Eduardo Zambon,et al.  Abstract Graph Transformation - Theory and Practice , 2013 .

[192]  Mjm Marcel Roeloffzen Kinetic data structures in the black-box model , 2013 .

[193]  Paolo Herms,et al.  Certification of a Tool Chain for Deductive Program Verification. (Certification d'une chaine de vérification déductive de programmes) , 2013 .

[194]  Georgeta Igna,et al.  Performance analysis of real-time task systems using timed automata , 2013 .

[195]  Gerhard de Koning Gans,et al.  Outsmarting smart cards , 2013 .

[196]  Sander van der Burg,et al.  A Reference Architecture for Distributed Software Deployment , 2013 .

[197]  Suresh Jagannathan,et al.  CompCertTSO: A Verified Compiler for Relaxed-Memory Concurrency , 2013, JACM.

[198]  Zhong Shao,et al.  End-to-end verification of stack-space bounds for C programs , 2014, PLDI.

[199]  Michiel Helvensteijn,et al.  Abstract delta modeling : software product lines and beyond , 2014 .

[200]  Axel Belinfante,et al.  JTorX: exploring model-based testing , 2014 .

[201]  Arthur Charguéraud,et al.  A trusted mechanised JavaScript specification , 2014, POPL.

[202]  Bn Bogdan Vasilescu Social aspects of collaboration in online software communities , 2014 .

[203]  Joost Winter,et al.  Coalgebraic Characterizations of Automata-Theoretic Classes , 2014 .

[204]  Adrianus Johannus Paulus Jeckmans Cryptographically-Enhanced Privacy for Recommender Systems , 2014 .

[205]  Sandrine Blazy,et al.  A Precise and Abstract Memory Model for C Using Symbolic Values , 2014, APLAS.

[206]  Robbert Krebbers An operational and axiomatic semantics for non-determinism and sequence points in C , 2014, POPL.

[207]  Marijn Paul Schraagen,et al.  Aspects of record linkage , 2014 .

[208]  Alfons Laarman,et al.  Scalable multi-core model checking , 2014 .

[209]  J. van den Bos,et al.  Gathering evidence: Model-driven software engineering in automated digital forensics , 2014 .

[210]  Xavier Leroy,et al.  Formal C Semantics: CompCert and the C Standard , 2014, ITP.

[211]  Frank W. Takes Algorithms for analyzing and mining real-world graphs , 2014 .

[212]  Dina Hadžiosmanović,et al.  The process matters: cyber security in industrial control systems , 2014 .

[213]  Reynald Affeldt,et al.  An Intrinsic Encoding of a Subset of C and its Application to TLS Network Packet Processing , 2014, J. Formaliz. Reason..

[214]  N Neda Noroozi,et al.  Improving input-output conformance testing theories , 2014 .

[215]  Gerwin Klein,et al.  Don't sweat the small stuff: formal verification of C code without the pain , 2014, PLDI.

[216]  Pim Vullers,et al.  Efficient implementations of attribute-based credentials on smart cards , 2014 .

[217]  Cor-Paul Bezemer,et al.  Performance Optimization of Multi-Tenant Software Systems , 2014 .

[218]  Andrew W. Appel,et al.  Verified Compilation for Shared-Memory C , 2014, ESOP.

[219]  Frank S. de Boer,et al.  Combining Monitoring with Run-Time Assertion Checking , 2014, SFM.

[220]  Fides Aarts,et al.  Tomte : bridging the gap between active learning and real-world systems , 2014 .

[221]  Andrew W. Appel,et al.  Program Logics for Certified Compilers , 2014 .

[222]  Robbert Krebbers,et al.  Separation Algebras for C Verification in Coq , 2014, VSTTE.

[223]  van der,et al.  Domain specific languages and their type systems , 2014 .

[224]  Wouter Meulemans,et al.  Similarity measures and algorithms for cartographic schematization , 2014 .

[225]  Minh Tri Ngo,et al.  Qualitative and Quantitative Information Flow Analysis for Multi-threaded Programs , 2014 .

[226]  Yanja Dajsuren,et al.  On the design of an architecture framework and quality evaluation for automotive software systems , 2015 .

[227]  Andrew W. Appel,et al.  Verification of a Cryptographic Primitive: SHA-256 , 2015, TOPL.

[228]  Xavier Leroy,et al.  A Formally-Verified C Static Analyzer , 2015, POPL.

[229]  Peter Sewell,et al.  The Problem of Programming Language Concurrency Semantics , 2015, ESOP.

[230]  Andrew W. Appel,et al.  Compositional CompCert , 2015, POPL.

[231]  Jeroen Bransen,et al.  On the Incremental Evaluation of Higher-Order Attribute Grammars , 2015 .

[232]  Joeri de Ruiter,et al.  Lessons learned in the analysis of the EMV and TLS security protocols , 2015 .

[233]  Robbert Krebbers,et al.  A Typed C11 Semantics for Interactive Theorem Proving , 2015, CPP.

[234]  Anja Guzzi,et al.  Supporting Developers' Teamwork from within the IDE , 2015 .

[235]  E. Gebler,et al.  Robust SOS Specifications of Probabilistic Processes , 2015 .

[236]  Chucky Ellison,et al.  Defining the undefinedness of C , 2015, PLDI.

[237]  Gergely Alpár,et al.  Attribute-based identity management : [bridging the cryptographic design of ABCs with the real world] , 2015 .

[238]  S Sjoerd Cranen,et al.  Getting the point : obtaining and understanding fixpoints in model checking , 2015 .

[239]  Cuiting Chen,et al.  Automated Fault Localization for Service-Oriented Software Systems , 2015 .

[240]  R.W.J. Kersten,et al.  Software analysis methods for resource-sensitive systems , 2015 .

[241]  T. V. Bui,et al.  A software architecture for body area sensor networks : flexibility and trustworthiness , 2015 .

[242]  Kayvan MemarianKyndylan,et al.  Cerberus: Towards an Executable Semantics for Sequential and Concurrent C11 , 2015 .

[243]  Elisa Costante,et al.  Privacy throughout the data cycle , 2015 .

[244]  Stefan Dietzel,et al.  Resilient in-network aggregation for vehicular networks , 2015 .

[245]  A. J. van der Ploeg,et al.  Efficient abstractions for visualization and interaction , 2015 .

[246]  Jeehoon Kang,et al.  A formal C memory model supporting integer-pointer casts , 2015, PLDI.

[247]  Viktor Vafeiadis,et al.  Common Compiler Optimisations are Invalid in the C11 Memory Model and what we can do about it , 2015, POPL.

[248]  Stjepan Picek,et al.  Applications of evolutionary computation to cryptology , 2015 .

[249]  Roel Verdult,et al.  The (in)security of proprietary cryptography , 2015 .

[250]  Tiago Espinha,et al.  Web Service Growing Pains: Understanding Services and Their Clients , 2015 .

[251]  Jeffrey Voas,et al.  Building Blocks of the Internet of Things , 2016, 2016 IEEE Symposium on Service-Oriented System Engineering (SOSE).

[252]  Peter Beike,et al.  The Definition Of Standard Ml Revised , 2016 .

[253]  Robbert Krebbers,et al.  A Formal C Memory Model for Separation Logic , 2015, Journal of Automated Reasoning.