No Cover Image

E-Thesis 316 views 61 downloads

Algebraically modelling object-orientated programs. / Justin Biddle

Swansea University Author: Justin Biddle

Abstract

We explore the process of building algebraic models of the behaviour of Java classes. A fundamental building block of object-oriented programs is the class that can typically contain multiple fields, constructors, and methods. In Java a programmer can control access to the various methods, fields an...

Full description

Published: 2006
Institution: Swansea University
Degree level: Doctoral
Degree name: Ph.D
URI: https://cronfa.swan.ac.uk/Record/cronfa42519
Tags: Add Tag
No Tags, Be the first to tag this record!
first_indexed 2018-08-02T18:54:54Z
last_indexed 2019-10-21T16:47:58Z
id cronfa42519
recordtype RisThesis
fullrecord <?xml version="1.0"?><rfc1807><datestamp>2018-08-14T12:33:01.3034181</datestamp><bib-version>v2</bib-version><id>42519</id><entry>2018-08-02</entry><title>Algebraically modelling object-orientated programs.</title><swanseaauthors><author><sid>5aa16b5c94c473490c516022f94fa147</sid><ORCID>NULL</ORCID><firstname>Justin</firstname><surname>Biddle</surname><name>Justin Biddle</name><active>true</active><ethesisStudent>true</ethesisStudent></author></swanseaauthors><date>2018-08-02</date><abstract>We explore the process of building algebraic models of the behaviour of Java classes. A fundamental building block of object-oriented programs is the class that can typically contain multiple fields, constructors, and methods. In Java a programmer can control access to the various methods, fields and constructors of a class. We will be formally specifying and documenting a class' public behaviour algebraically. In practice even a simple Java class can have complex behaviour. A full algebraic specification (FAS) of a class can be complicated and hard to understand for someone who wishes to quickly ascertain the behaviour of a class. This complexity is largely as a result of machinery needed to define class behaviours that are implicit, that is behaviour that is considered part of Java's general language behaviour and defines the general structure of classes, methods, fields and constructors. However, it is unreasonable to expect a programmer to write such full specifications. Therefore we introduce the concept of an Algebraic Class Specification (ACS) that provides a much reduced version of the FAS of a class. The ACS is therefore more readable and is aimed at showing what we consider to be key information in the specification of a class that cannot be programmatically inferred from the language definition. Using the ACS we present a methodology for generating an FAS thus reducing the complexity of specification for the user. We will show that the ACS provides a reader with a clear formal understanding of a class' behaviour using a minimum of information. The ACS is designed to be human readable yet still machine readable. We will show that in order to aid users in creating specifications of classes we have mimicked the Java syntax closely in the specification syntax. We will, in addition, present a methodology for embedding the formal semantic description for a Java class within javadoc comments thus allowing Java API documentation to contain both a formal specification of the behaviour of a class and its components and an informal general textual description. These techniques have been developed by the analysis of case studies. We will demonstrate all of these techniques applied to a wide and varied range of both invented and existing examples of Java classes.</abstract><type>E-Thesis</type><journal/><journalNumber></journalNumber><paginationStart/><paginationEnd/><publisher/><placeOfPublication/><isbnPrint/><issnPrint/><issnElectronic/><keywords>Computer science.</keywords><publishedDay>31</publishedDay><publishedMonth>12</publishedMonth><publishedYear>2006</publishedYear><publishedDate>2006-12-31</publishedDate><doi/><url/><notes/><college>COLLEGE NANME</college><department>Computer Science</department><CollegeCode>COLLEGE CODE</CollegeCode><institution>Swansea University</institution><degreelevel>Doctoral</degreelevel><degreename>Ph.D</degreename><apcterm/><lastEdited>2018-08-14T12:33:01.3034181</lastEdited><Created>2018-08-02T16:24:29.5405962</Created><path><level id="1">Faculty of Science and Engineering</level><level id="2">School of Mathematics and Computer Science - Computer Science</level></path><authors><author><firstname>Justin</firstname><surname>Biddle</surname><orcid>NULL</orcid><order>1</order></author></authors><documents><document><filename>0042519-02082018162500.pdf</filename><originalFilename>10805268.pdf</originalFilename><uploaded>2018-08-02T16:25:00.8970000</uploaded><type>Output</type><contentLength>8102569</contentLength><contentType>application/pdf</contentType><version>E-Thesis</version><cronfaStatus>true</cronfaStatus><embargoDate>2018-08-02T16:25:00.8970000</embargoDate><copyrightCorrect>false</copyrightCorrect></document></documents><OutputDurs/></rfc1807>
spelling 2018-08-14T12:33:01.3034181 v2 42519 2018-08-02 Algebraically modelling object-orientated programs. 5aa16b5c94c473490c516022f94fa147 NULL Justin Biddle Justin Biddle true true 2018-08-02 We explore the process of building algebraic models of the behaviour of Java classes. A fundamental building block of object-oriented programs is the class that can typically contain multiple fields, constructors, and methods. In Java a programmer can control access to the various methods, fields and constructors of a class. We will be formally specifying and documenting a class' public behaviour algebraically. In practice even a simple Java class can have complex behaviour. A full algebraic specification (FAS) of a class can be complicated and hard to understand for someone who wishes to quickly ascertain the behaviour of a class. This complexity is largely as a result of machinery needed to define class behaviours that are implicit, that is behaviour that is considered part of Java's general language behaviour and defines the general structure of classes, methods, fields and constructors. However, it is unreasonable to expect a programmer to write such full specifications. Therefore we introduce the concept of an Algebraic Class Specification (ACS) that provides a much reduced version of the FAS of a class. The ACS is therefore more readable and is aimed at showing what we consider to be key information in the specification of a class that cannot be programmatically inferred from the language definition. Using the ACS we present a methodology for generating an FAS thus reducing the complexity of specification for the user. We will show that the ACS provides a reader with a clear formal understanding of a class' behaviour using a minimum of information. The ACS is designed to be human readable yet still machine readable. We will show that in order to aid users in creating specifications of classes we have mimicked the Java syntax closely in the specification syntax. We will, in addition, present a methodology for embedding the formal semantic description for a Java class within javadoc comments thus allowing Java API documentation to contain both a formal specification of the behaviour of a class and its components and an informal general textual description. These techniques have been developed by the analysis of case studies. We will demonstrate all of these techniques applied to a wide and varied range of both invented and existing examples of Java classes. E-Thesis Computer science. 31 12 2006 2006-12-31 COLLEGE NANME Computer Science COLLEGE CODE Swansea University Doctoral Ph.D 2018-08-14T12:33:01.3034181 2018-08-02T16:24:29.5405962 Faculty of Science and Engineering School of Mathematics and Computer Science - Computer Science Justin Biddle NULL 1 0042519-02082018162500.pdf 10805268.pdf 2018-08-02T16:25:00.8970000 Output 8102569 application/pdf E-Thesis true 2018-08-02T16:25:00.8970000 false
title Algebraically modelling object-orientated programs.
spellingShingle Algebraically modelling object-orientated programs.
Justin Biddle
title_short Algebraically modelling object-orientated programs.
title_full Algebraically modelling object-orientated programs.
title_fullStr Algebraically modelling object-orientated programs.
title_full_unstemmed Algebraically modelling object-orientated programs.
title_sort Algebraically modelling object-orientated programs.
author_id_str_mv 5aa16b5c94c473490c516022f94fa147
author_id_fullname_str_mv 5aa16b5c94c473490c516022f94fa147_***_Justin Biddle
author Justin Biddle
author2 Justin Biddle
format E-Thesis
publishDate 2006
institution Swansea University
college_str Faculty of Science and Engineering
hierarchytype
hierarchy_top_id facultyofscienceandengineering
hierarchy_top_title Faculty of Science and Engineering
hierarchy_parent_id facultyofscienceandengineering
hierarchy_parent_title Faculty of Science and Engineering
department_str School of Mathematics and Computer Science - Computer Science{{{_:::_}}}Faculty of Science and Engineering{{{_:::_}}}School of Mathematics and Computer Science - Computer Science
document_store_str 1
active_str 0
description We explore the process of building algebraic models of the behaviour of Java classes. A fundamental building block of object-oriented programs is the class that can typically contain multiple fields, constructors, and methods. In Java a programmer can control access to the various methods, fields and constructors of a class. We will be formally specifying and documenting a class' public behaviour algebraically. In practice even a simple Java class can have complex behaviour. A full algebraic specification (FAS) of a class can be complicated and hard to understand for someone who wishes to quickly ascertain the behaviour of a class. This complexity is largely as a result of machinery needed to define class behaviours that are implicit, that is behaviour that is considered part of Java's general language behaviour and defines the general structure of classes, methods, fields and constructors. However, it is unreasonable to expect a programmer to write such full specifications. Therefore we introduce the concept of an Algebraic Class Specification (ACS) that provides a much reduced version of the FAS of a class. The ACS is therefore more readable and is aimed at showing what we consider to be key information in the specification of a class that cannot be programmatically inferred from the language definition. Using the ACS we present a methodology for generating an FAS thus reducing the complexity of specification for the user. We will show that the ACS provides a reader with a clear formal understanding of a class' behaviour using a minimum of information. The ACS is designed to be human readable yet still machine readable. We will show that in order to aid users in creating specifications of classes we have mimicked the Java syntax closely in the specification syntax. We will, in addition, present a methodology for embedding the formal semantic description for a Java class within javadoc comments thus allowing Java API documentation to contain both a formal specification of the behaviour of a class and its components and an informal general textual description. These techniques have been developed by the analysis of case studies. We will demonstrate all of these techniques applied to a wide and varied range of both invented and existing examples of Java classes.
published_date 2006-12-31T03:53:07Z
_version_ 1763752634240466944
score 11.012678

Similar Items