C D G H M N S T V W

	Chechina, Natalia	Erlang '15: "Performance Portability through ..." Performance Portability through Semi-explicit Placement in Distributed Erlang Kenneth MacKenzie, Natalia Chechina, and Phil Trinder (University of St. Andrews, UK; University of Glasgow, UK) We consider the problem of adapting distributed Erlang applications to large or heterogeneous architectures to achieve good performance in a portable way. In many architectures, and especially large architectures, the communication latency between pairs of virtual machines (nodes) is no longer uniform. We propose two language-level methods that enable programs to automatically adapt to heterogeneity and non-uniform communication latencies, and both provide information enabling a program to identify an appropriate node when spawning a process. We provide a means of recording node attributes describing the hardware and software capabilities of nodes, and mechanisms that allow an application to examine the attributes of remote nodes. We provide an abstraction of communication distances that enables an application to select nodes to facilitate efficient communication. We have developed open source libraries that implement these ideas. We show that the use of attributes for node selection can lead to significant performance improvements if different components of the application have different processing requirements. We report a detailed empirical investigation of non-uniform communication times in several representative architectures, and show that our abstract model provides a good description of the hierarchy of communication times. @InProceedings{Erlang15p27, author = {Kenneth MacKenzie and Natalia Chechina and Phil Trinder}, title = {Performance Portability through Semi-explicit Placement in Distributed Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {27--38}, doi = {}, year = {2015}, }
	Derrick, John	Erlang '15: "Smother: An MC/DC Analysis ..." Smother: An MC/DC Analysis Tool for Erlang Ramsay Taylor and John Derrick (University of Sheffield, UK) This paper discusses an MC/DC analysis tool built for the Erlang programming language. Code coverage metrics are one way to measure the adequacy of a test suite, however, despite widespread industrial use in business-critical software, the only coverage metric readily available for Erlang is statement coverage, provided by the Cover tool that is distributed by the OTP standard libraries. An alternative to statement cover is Multiple Condition/Decision Coverage (MC/DC) -- one of the most extensive coverage metrics, which is mandated by many software safety standards. Here we describe the application of MC/DC analysis to Erlang programs, and include an extension to traditional MC/DC analysis that applies the underlying philosophy to the pattern matching decision structures of functional languages. We have implemented the approach in the Smother tool that we also describe here as well as its use by our industrial project partners. @InProceedings{Erlang15p13, author = {Ramsay Taylor and John Derrick}, title = {Smother: An MC/DC Analysis Tool for Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {13--18}, doi = {}, year = {2015}, }
	Gerdes, Alex	Erlang '15: "Linking Unit Tests and Properties ..." Linking Unit Tests and Properties Alex Gerdes, John Hughes, Nick Smallbone, and Meng Wang (QuviQ, Sweden; Chalmers University of Technology, Sweden; University of Kent, UK) QuickCheck allows us to verify software against particular properties. A property can be regarded as an abstraction over many unit tests. QuickCheck uses generated random input data to test such properties. If a counterexample is found, it becomes immediately clear what we have tested. This is not the case when all tests pass, since we do not (and shall not) see the actual generated test cases. How can we be sure about what is tested? QuickCheck has the ability to gather statistics about the test cases, which is insightful. But still it does not tell us whether the particular unit test scenarios we have in mind are included. For this reason, we have developed a tool that can answer this question. It checks if a given unit test can be generated by a property, making it easier to judge the property's quality. We have applied our tool to an industrial use case of testing the AUTOSAR basic software modules and shows that it can handle complex models and large unit tests. @InProceedings{Erlang15p19, author = {Alex Gerdes and John Hughes and Nick Smallbone and Meng Wang}, title = {Linking Unit Tests and Properties}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {19--26}, doi = {}, year = {2015}, } Erlang '15: "Attribute Grammars in Erlang ..." Attribute Grammars in Erlang Ulf Norell and Alex Gerdes (QuviQ, Sweden; Chalmers University of Technology, Sweden) Many functions take a value of a particular (recursive) data structure as input and compute an output value by traversing the structure and collect, combine, or update values in that data structure. Some examples are: collecting all hyperlink tags in a HTML tree, calculating the depth of a binary tree, or adding a prefix to every free variable name in an abstract syntax tree. When defining such functions we need to write code that takes care of traversing a data structure. This code is often repeated for functions that operate on the same data structure, and is often not essential for the operation we want to perform. This type of repetitive code is often referred to as boilerplate code. Abstraction is a way to remove this boilerplate code, for example by defining higher-order functions. Higher-order functions can be used to separate the boilerplate code from the essential parts. Common examples of higher order functions are map and fold. @InProceedings{Erlang15p1, author = {Ulf Norell and Alex Gerdes}, title = {Attribute Grammars in Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, }
	Hughes, John	Erlang '15: "Linking Unit Tests and Properties ..." Linking Unit Tests and Properties Alex Gerdes, John Hughes, Nick Smallbone, and Meng Wang (QuviQ, Sweden; Chalmers University of Technology, Sweden; University of Kent, UK) QuickCheck allows us to verify software against particular properties. A property can be regarded as an abstraction over many unit tests. QuickCheck uses generated random input data to test such properties. If a counterexample is found, it becomes immediately clear what we have tested. This is not the case when all tests pass, since we do not (and shall not) see the actual generated test cases. How can we be sure about what is tested? QuickCheck has the ability to gather statistics about the test cases, which is insightful. But still it does not tell us whether the particular unit test scenarios we have in mind are included. For this reason, we have developed a tool that can answer this question. It checks if a given unit test can be generated by a property, making it easier to judge the property's quality. We have applied our tool to an industrial use case of testing the AUTOSAR basic software modules and shows that it can handle complex models and large unit tests. @InProceedings{Erlang15p19, author = {Alex Gerdes and John Hughes and Nick Smallbone and Meng Wang}, title = {Linking Unit Tests and Properties}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {19--26}, doi = {}, year = {2015}, }
	MacKenzie, Kenneth	Erlang '15: "Performance Portability through ..." Performance Portability through Semi-explicit Placement in Distributed Erlang Kenneth MacKenzie, Natalia Chechina, and Phil Trinder (University of St. Andrews, UK; University of Glasgow, UK) We consider the problem of adapting distributed Erlang applications to large or heterogeneous architectures to achieve good performance in a portable way. In many architectures, and especially large architectures, the communication latency between pairs of virtual machines (nodes) is no longer uniform. We propose two language-level methods that enable programs to automatically adapt to heterogeneity and non-uniform communication latencies, and both provide information enabling a program to identify an appropriate node when spawning a process. We provide a means of recording node attributes describing the hardware and software capabilities of nodes, and mechanisms that allow an application to examine the attributes of remote nodes. We provide an abstraction of communication distances that enables an application to select nodes to facilitate efficient communication. We have developed open source libraries that implement these ideas. We show that the use of attributes for node selection can lead to significant performance improvements if different components of the application have different processing requirements. We report a detailed empirical investigation of non-uniform communication times in several representative architectures, and show that our abstract model provides a good description of the hierarchy of communication times. @InProceedings{Erlang15p27, author = {Kenneth MacKenzie and Natalia Chechina and Phil Trinder}, title = {Performance Portability through Semi-explicit Placement in Distributed Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {27--38}, doi = {}, year = {2015}, }
	Meiklejohn, Christopher	Erlang '15: "The Implementation and Use ..." The Implementation and Use of a Generic Dataflow Behaviour in Erlang Christopher Meiklejohn and Peter Van Roy (Basho Technologies, USA; Université Catholique de Louvain, Belgium) We propose a new "generic" abstraction for Erlang/OTP that aids in the implementation of dataflow programming languages and models on the Erlang VM. This abstraction simplifies the implementation of "processing elements" in dataflow languages by providing a simple callback interface in the style of the gen_server and gen_fsm abstractions. We motivate the use of this new abstraction by examining the implementation of a distributed dataflow programming variant called Lasp. @InProceedings{Erlang15p39, author = {Christopher Meiklejohn and Peter Van Roy}, title = {The Implementation and Use of a Generic Dataflow Behaviour in Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {39--45}, doi = {}, year = {2015}, }
	Norell, Ulf	Erlang '15: "Attribute Grammars in Erlang ..." Attribute Grammars in Erlang Ulf Norell and Alex Gerdes (QuviQ, Sweden; Chalmers University of Technology, Sweden) Many functions take a value of a particular (recursive) data structure as input and compute an output value by traversing the structure and collect, combine, or update values in that data structure. Some examples are: collecting all hyperlink tags in a HTML tree, calculating the depth of a binary tree, or adding a prefix to every free variable name in an abstract syntax tree. When defining such functions we need to write code that takes care of traversing a data structure. This code is often repeated for functions that operate on the same data structure, and is often not essential for the operation we want to perform. This type of repetitive code is often referred to as boilerplate code. Abstraction is a way to remove this boilerplate code, for example by defining higher-order functions. Higher-order functions can be used to separate the boilerplate code from the essential parts. Common examples of higher order functions are map and fold. @InProceedings{Erlang15p1, author = {Ulf Norell and Alex Gerdes}, title = {Attribute Grammars in Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, }
	Smallbone, Nick	Erlang '15: "Linking Unit Tests and Properties ..." Linking Unit Tests and Properties Alex Gerdes, John Hughes, Nick Smallbone, and Meng Wang (QuviQ, Sweden; Chalmers University of Technology, Sweden; University of Kent, UK) QuickCheck allows us to verify software against particular properties. A property can be regarded as an abstraction over many unit tests. QuickCheck uses generated random input data to test such properties. If a counterexample is found, it becomes immediately clear what we have tested. This is not the case when all tests pass, since we do not (and shall not) see the actual generated test cases. How can we be sure about what is tested? QuickCheck has the ability to gather statistics about the test cases, which is insightful. But still it does not tell us whether the particular unit test scenarios we have in mind are included. For this reason, we have developed a tool that can answer this question. It checks if a given unit test can be generated by a property, making it easier to judge the property's quality. We have applied our tool to an industrial use case of testing the AUTOSAR basic software modules and shows that it can handle complex models and large unit tests. @InProceedings{Erlang15p19, author = {Alex Gerdes and John Hughes and Nick Smallbone and Meng Wang}, title = {Linking Unit Tests and Properties}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {19--26}, doi = {}, year = {2015}, }
	Taylor, Ramsay	Erlang '15: "Smother: An MC/DC Analysis ..." Smother: An MC/DC Analysis Tool for Erlang Ramsay Taylor and John Derrick (University of Sheffield, UK) This paper discusses an MC/DC analysis tool built for the Erlang programming language. Code coverage metrics are one way to measure the adequacy of a test suite, however, despite widespread industrial use in business-critical software, the only coverage metric readily available for Erlang is statement coverage, provided by the Cover tool that is distributed by the OTP standard libraries. An alternative to statement cover is Multiple Condition/Decision Coverage (MC/DC) -- one of the most extensive coverage metrics, which is mandated by many software safety standards. Here we describe the application of MC/DC analysis to Erlang programs, and include an extension to traditional MC/DC analysis that applies the underlying philosophy to the pattern matching decision structures of functional languages. We have implemented the approach in the Smother tool that we also describe here as well as its use by our industrial project partners. @InProceedings{Erlang15p13, author = {Ramsay Taylor and John Derrick}, title = {Smother: An MC/DC Analysis Tool for Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {13--18}, doi = {}, year = {2015}, }
	Trinder, Phil	Erlang '15: "Performance Portability through ..." Performance Portability through Semi-explicit Placement in Distributed Erlang Kenneth MacKenzie, Natalia Chechina, and Phil Trinder (University of St. Andrews, UK; University of Glasgow, UK) We consider the problem of adapting distributed Erlang applications to large or heterogeneous architectures to achieve good performance in a portable way. In many architectures, and especially large architectures, the communication latency between pairs of virtual machines (nodes) is no longer uniform. We propose two language-level methods that enable programs to automatically adapt to heterogeneity and non-uniform communication latencies, and both provide information enabling a program to identify an appropriate node when spawning a process. We provide a means of recording node attributes describing the hardware and software capabilities of nodes, and mechanisms that allow an application to examine the attributes of remote nodes. We provide an abstraction of communication distances that enables an application to select nodes to facilitate efficient communication. We have developed open source libraries that implement these ideas. We show that the use of attributes for node selection can lead to significant performance improvements if different components of the application have different processing requirements. We report a detailed empirical investigation of non-uniform communication times in several representative architectures, and show that our abstract model provides a good description of the hierarchy of communication times. @InProceedings{Erlang15p27, author = {Kenneth MacKenzie and Natalia Chechina and Phil Trinder}, title = {Performance Portability through Semi-explicit Placement in Distributed Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {27--38}, doi = {}, year = {2015}, }
	Van Roy, Peter	Erlang '15: "The Implementation and Use ..." The Implementation and Use of a Generic Dataflow Behaviour in Erlang Christopher Meiklejohn and Peter Van Roy (Basho Technologies, USA; Université Catholique de Louvain, Belgium) We propose a new "generic" abstraction for Erlang/OTP that aids in the implementation of dataflow programming languages and models on the Erlang VM. This abstraction simplifies the implementation of "processing elements" in dataflow languages by providing a simple callback interface in the style of the gen_server and gen_fsm abstractions. We motivate the use of this new abstraction by examining the implementation of a distributed dataflow programming variant called Lasp. @InProceedings{Erlang15p39, author = {Christopher Meiklejohn and Peter Van Roy}, title = {The Implementation and Use of a Generic Dataflow Behaviour in Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {39--45}, doi = {}, year = {2015}, }
	Wang, Meng	Erlang '15: "Linking Unit Tests and Properties ..." Linking Unit Tests and Properties Alex Gerdes, John Hughes, Nick Smallbone, and Meng Wang (QuviQ, Sweden; Chalmers University of Technology, Sweden; University of Kent, UK) QuickCheck allows us to verify software against particular properties. A property can be regarded as an abstraction over many unit tests. QuickCheck uses generated random input data to test such properties. If a counterexample is found, it becomes immediately clear what we have tested. This is not the case when all tests pass, since we do not (and shall not) see the actual generated test cases. How can we be sure about what is tested? QuickCheck has the ability to gather statistics about the test cases, which is insightful. But still it does not tell us whether the particular unit test scenarios we have in mind are included. For this reason, we have developed a tool that can answer this question. It checks if a given unit test can be generated by a property, making it easier to judge the property's quality. We have applied our tool to an industrial use case of testing the AUTOSAR basic software modules and shows that it can handle complex models and large unit tests. @InProceedings{Erlang15p19, author = {Alex Gerdes and John Hughes and Nick Smallbone and Meng Wang}, title = {Linking Unit Tests and Properties}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {19--26}, doi = {}, year = {2015}, }

13 authors

proc time: 0.64