No Cover Image

Conference Paper/Proceeding/Abstract 1158 views

Tool support for component-based semantics

L. Thomas van Binsbergen, Neil Sculthorpe, Peter Mosses Orcid Logo

MODULARITY Companion 2016 Companion Proceedings of the 15th International Conference on Modularity, Pages: 8 - 11

Swansea University Author: Peter Mosses Orcid Logo

Full text not available from this repository: check for access using links below.

DOI (Published version): 10.1145/2892664.2893464

Abstract

The developers of a programming language need to document its intended syntax and semantics, and to update the documentation when the language evolves. They use formal grammars to define context-free syntax, but usually give only an informal description of semantics. Use of formal semantics could gr...

Full description

Published in: MODULARITY Companion 2016 Companion Proceedings of the 15th International Conference on Modularity
Published: Malaga, Spain ACM 2016
URI: https://cronfa.swan.ac.uk/Record/cronfa26941
first_indexed 2016-03-25T02:00:17Z
last_indexed 2018-02-09T05:09:29Z
id cronfa26941
recordtype SURis
fullrecord <?xml version="1.0"?><rfc1807><datestamp>2016-12-22T13:06:22.5731187</datestamp><bib-version>v2</bib-version><id>26941</id><entry>2016-03-24</entry><title>Tool support for component-based semantics</title><swanseaauthors><author><sid>3f13b8ec315845c81d371f41e772399c</sid><ORCID>0000-0002-5826-7520</ORCID><firstname>Peter</firstname><surname>Mosses</surname><name>Peter Mosses</name><active>true</active><ethesisStudent>false</ethesisStudent></author></swanseaauthors><date>2016-03-24</date><abstract>The developers of a programming language need to document its intended syntax and semantics, and to update the documentation when the language evolves. They use formal grammars to define context-free syntax, but usually give only an informal description of semantics. Use of formal semantics could greatly increase the consistency and completeness of language documentation, support rapid prototyping, and allow empirical validation. Modularity of semantics is essential for practicality when scaling up to definitions of larger languages. Component-based semantics takes modularity to the highest possible level. In this approach, the semantics of a language is defined by equations translating its constructs (compositionally) to combinations of so-called fundamental constructs, or 'funcons'. The definition of each funcon is a small, highly reusable component. The PLanCompS project has defined a substantial library of funcons, and shown their reusability in several case studies. We have designed a meta-language called CBS for component-based semantics, and an IDE to support development, rapid prototyping, and validation of definitions in CBS. After introducing and motivating CBS, we demonstrate how the IDE can be used to browse and edit the CBS definition of a toy language, to generate a prototype implementation of the language, and to parse and run programs.</abstract><type>Conference Paper/Proceeding/Abstract</type><journal>MODULARITY Companion 2016 Companion Proceedings of the 15th International Conference on Modularity</journal><paginationStart>8</paginationStart><paginationEnd>11</paginationEnd><publisher>ACM</publisher><placeOfPublication>Malaga, Spain</placeOfPublication><keywords/><publishedDay>14</publishedDay><publishedMonth>3</publishedMonth><publishedYear>2016</publishedYear><publishedDate>2016-03-14</publishedDate><doi>10.1145/2892664.2893464</doi><url/><notes/><college>COLLEGE NANME</college><CollegeCode>COLLEGE CODE</CollegeCode><institution>Swansea University</institution><apcterm/><lastEdited>2016-12-22T13:06:22.5731187</lastEdited><Created>2016-03-24T22:50:25.6318734</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>L. Thomas van</firstname><surname>Binsbergen</surname><order>1</order></author><author><firstname>Neil</firstname><surname>Sculthorpe</surname><order>2</order></author><author><firstname>Peter</firstname><surname>Mosses</surname><orcid>0000-0002-5826-7520</orcid><order>3</order></author></authors><documents/><OutputDurs/></rfc1807>
spelling 2016-12-22T13:06:22.5731187 v2 26941 2016-03-24 Tool support for component-based semantics 3f13b8ec315845c81d371f41e772399c 0000-0002-5826-7520 Peter Mosses Peter Mosses true false 2016-03-24 The developers of a programming language need to document its intended syntax and semantics, and to update the documentation when the language evolves. They use formal grammars to define context-free syntax, but usually give only an informal description of semantics. Use of formal semantics could greatly increase the consistency and completeness of language documentation, support rapid prototyping, and allow empirical validation. Modularity of semantics is essential for practicality when scaling up to definitions of larger languages. Component-based semantics takes modularity to the highest possible level. In this approach, the semantics of a language is defined by equations translating its constructs (compositionally) to combinations of so-called fundamental constructs, or 'funcons'. The definition of each funcon is a small, highly reusable component. The PLanCompS project has defined a substantial library of funcons, and shown their reusability in several case studies. We have designed a meta-language called CBS for component-based semantics, and an IDE to support development, rapid prototyping, and validation of definitions in CBS. After introducing and motivating CBS, we demonstrate how the IDE can be used to browse and edit the CBS definition of a toy language, to generate a prototype implementation of the language, and to parse and run programs. Conference Paper/Proceeding/Abstract MODULARITY Companion 2016 Companion Proceedings of the 15th International Conference on Modularity 8 11 ACM Malaga, Spain 14 3 2016 2016-03-14 10.1145/2892664.2893464 COLLEGE NANME COLLEGE CODE Swansea University 2016-12-22T13:06:22.5731187 2016-03-24T22:50:25.6318734 Faculty of Science and Engineering School of Mathematics and Computer Science - Computer Science L. Thomas van Binsbergen 1 Neil Sculthorpe 2 Peter Mosses 0000-0002-5826-7520 3
title Tool support for component-based semantics
spellingShingle Tool support for component-based semantics
Peter Mosses
title_short Tool support for component-based semantics
title_full Tool support for component-based semantics
title_fullStr Tool support for component-based semantics
title_full_unstemmed Tool support for component-based semantics
title_sort Tool support for component-based semantics
author_id_str_mv 3f13b8ec315845c81d371f41e772399c
author_id_fullname_str_mv 3f13b8ec315845c81d371f41e772399c_***_Peter Mosses
author Peter Mosses
author2 L. Thomas van Binsbergen
Neil Sculthorpe
Peter Mosses
format Conference Paper/Proceeding/Abstract
container_title MODULARITY Companion 2016 Companion Proceedings of the 15th International Conference on Modularity
container_start_page 8
publishDate 2016
institution Swansea University
doi_str_mv 10.1145/2892664.2893464
publisher ACM
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 0
active_str 0
description The developers of a programming language need to document its intended syntax and semantics, and to update the documentation when the language evolves. They use formal grammars to define context-free syntax, but usually give only an informal description of semantics. Use of formal semantics could greatly increase the consistency and completeness of language documentation, support rapid prototyping, and allow empirical validation. Modularity of semantics is essential for practicality when scaling up to definitions of larger languages. Component-based semantics takes modularity to the highest possible level. In this approach, the semantics of a language is defined by equations translating its constructs (compositionally) to combinations of so-called fundamental constructs, or 'funcons'. The definition of each funcon is a small, highly reusable component. The PLanCompS project has defined a substantial library of funcons, and shown their reusability in several case studies. We have designed a meta-language called CBS for component-based semantics, and an IDE to support development, rapid prototyping, and validation of definitions in CBS. After introducing and motivating CBS, we demonstrate how the IDE can be used to browse and edit the CBS definition of a toy language, to generate a prototype implementation of the language, and to parse and run programs.
published_date 2016-03-14T12:58:06Z
_version_ 1821410367214977024
score 10.958922

Similar Items