• Contact

  • Newsletter

  • About us

  • Delivery options

  • Prospero Book Market Podcast

  • News

  • 0
    Verification of Object-Oriented Software. The KeY Approach: Foreword by K. Rustan M. Leino

    Verification of Object-Oriented Software. The KeY Approach by Beckert, Bernhard; Hähnle, Reiner; Schmitt, Peter H.;

    Foreword by K. Rustan M. Leino

    Series: Lecture Notes in Computer Science; 4334;

      • GET 20% OFF

      • The discount is only available for 'Alert of Favourite Topics' newsletter recipients.
      • Publisher's listprice EUR 106.99
      • The price is estimated because at the time of ordering we do not know what conversion rates will apply to HUF / product currency when the book arrives. In case HUF is weaker, the price increases slightly, in case HUF is stronger, the price goes lower slightly.

        45 385 Ft (43 223 Ft + 5% VAT)
      • Discount 20% (cc. 9 077 Ft off)
      • Discounted price 36 307 Ft (34 578 Ft + 5% VAT)

    45 385 Ft

    db

    Availability

    Estimated delivery time: In stock at the publisher, but not at Prospero's office. Delivery time approx. 3-5 weeks.
    Not in stock at Prospero.

    Why don't you give exact delivery time?

    Delivery time is estimated on our previous experiences. We give estimations only, because we order from outside Hungary, and the delivery time mainly depends on how quickly the publisher supplies the book. Faster or slower deliveries both happen, but we do our best to supply as quickly as possible.

    Short description:

    The ultimate goal of program verification is not the theory behind the tools or the tools themselves, but the application of the theory and tools in the software engineering process. Our society relies on the correctness of a vast and growing amount of software. Improving the software engineering process is an important, long-term goal with many steps. Two of those steps are the KeY tool and this KeY book.

    More

    Long description:

    Long gone are the days when program veri?cation was a task carried out merely by hand with paper and pen. For one, we are increasingly interested in proving actual program artifacts, not just abstractions thereof or core algorithms. The programs we want to verify today are thus longer, including whole classes and modules. As we consider larger programs, the number of cases to be considered in a proof increases. The creative and insightful parts of a proof can easily be lost in scores of mundane cases. Another problem with paper-and-pen proofs is that the features of the programming languages we employ in these programs are plentiful, including object-oriented organizations of data, facilities for specifying di?erent c- trol ?ow for rare situations, constructs for iterating over the elements of a collection, and the grouping together of operations into atomic transactions. These language features were designed to facilitate simpler and more natural encodings of programs, and ideally they are accompanied by simpler proof rules. But the variety and increased number of these features make it harder to remember all that needs to be proved about their uses. As a third problem, we have come to expect a higher degree of rigor from our proofs. A proof carried out or replayed by a machine somehow gets more credibility than one that requires human intellect to understand.

    From the reviews:



    "This book is a collection of work by different authors on software verification. The context of the book is the key project, which aims to build a verification of the systems based on model checking. The book features the widely used specification languages: object constraint language (OCL) and Java modeling language (JML). ? this book is a good resource for graduate students and researchers ? ." (S. Balaraman, Computing Reviews, December, 2007)

    More

    Table of Contents:

    A New Look at Formal Methods for Software Construction.- A New Look at Formal Methods for Software Construction.- I: Foundations.- First-Order Logic.- Dynamic Logic.- Construction of Proofs.- II: Expressing and Formalising Requirements.- Formal Specification.- Pattern-Driven Formal Specification.- Natural Language Specifications.- Proof Obligations.- From Sequential Java to Java Card.- III: Using the KeY System.- Using KeY.- Proving by Induction.- Java Integers.- Proof Reuse.- IV: Case Studies.- The Demoney Case Study.- The Schorr-Waite-Algorithm.- Appendices.- Predefined Operators in Java Card DL.- The KeY Syntax.

    More
    Recently viewed
    previous
    Verification of Object-Oriented Software. The KeY Approach: Foreword by K. Rustan M. Leino

    Verification of Object-Oriented Software. The KeY Approach: Foreword by K. Rustan M. Leino

    Beckert, Bernhard; Hähnle, Reiner; Schmitt, Peter H.; (ed.)

    45 385 HUF

    Neural Network Training Using Genetic Algorithms

    Neural Network Training Using Genetic Algorithms

    Jain, Lakhmi C; Johnson, R P; Rooij, A J F Van;

    13 664 HUF

    A Guide to Convolutional Neural Networks for Computer Vision

    A Guide to Convolutional Neural Networks for Computer Vision

    Khan, Salman; Rahmani, Hossein; Shah, Syed Afaq Ali;

    29 498 HUF

    Mathematics for Engineers and Science Labs Using Maxima

    Mathematics for Engineers and Science Labs Using Maxima

    Kadry, Seifedine; Awad, Pauly;

    58 707 HUF

    next