A Semantic Framework to Debug Parallel Lazy Functional Languages

It is not easy to debug lazy functional programs. The reason is that laziness and higher-order complicates basic debugging strategies. Although there exist several debuggers for sequential lazy languages, dealing with parallel languages is much harder. In this case, it is important to implement debu...

Full description

Saved in:
Bibliographic Details
Published in:Mathematics (Basel) 2020-06, Vol.8 (6), p.864
Main Authors: de la Encina, Alberto, Hidalgo-Herrero, Mercedes, Llana, Luis, Rubio, Fernando
Format: Article
Language:English
Subjects:
debugging
functional programming
parallel programming
semantics
Citations: Items that this one cites
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites cdi_FETCH-LOGICAL-c294t-9fd62c8a84bdb63fc06d1c0889321b67f602347cd7e6445c2bbf5ec836ca6b843
container_end_page
container_issue 6
container_start_page 864
container_title Mathematics (Basel)
container_volume 8
creator de la Encina, Alberto
Hidalgo-Herrero, Mercedes
Llana, Luis
Rubio, Fernando
description It is not easy to debug lazy functional programs. The reason is that laziness and higher-order complicates basic debugging strategies. Although there exist several debuggers for sequential lazy languages, dealing with parallel languages is much harder. In this case, it is important to implement debugging platforms for parallel extensions, but it is also important to provide theoretical foundations to simplify the task of understanding the debugging process. In this work, we deal with the debugging process in two parallel languages that extend the lazy language Haskell. In particular, we provide an operational semantics that allows us to reason about our parallel extension of the sequential debugger Hood. In addition, we show how we can use it to analyze the amount of speculative work done by the processes, so that it can be used to optimize their use of resources.
doi_str_mv 10.3390/math8060864
format article
fullrecord <record><control><sourceid>doaj_cross</sourceid><recordid>TN_cdi_doaj_primary_oai_doaj_org_article_18c24a45e6ad4629bce1aa77238b8727</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><doaj_id>oai_doaj_org_article_18c24a45e6ad4629bce1aa77238b8727</doaj_id><sourcerecordid>oai_doaj_org_article_18c24a45e6ad4629bce1aa77238b8727</sourcerecordid><originalsourceid>FETCH-LOGICAL-c294t-9fd62c8a84bdb63fc06d1c0889321b67f602347cd7e6445c2bbf5ec836ca6b843</originalsourceid><addsrcrecordid>eNpNkEtLw0AUhQdRsNSu_AOzl-i8Oo-dpRotFBTU9XBnMompSUYmKVJ_vakV6dncc87ig3sQuqTkmnNDbloY3jWRREtxgiaMMZWpsT898udo1vcbMspQroWZoNsFfgktdEPtcZ6gDV8xfeAh4rvgthV-hgRNExq8hu8dzredH-rYwT531Raq0F-gsxKaPsz-7hS95fevy8ds_fSwWi7WmWdGDJkpC8m8Bi1c4SQvPZEF9URrwxl1UpWSMC6UL1SQQsw9c66cB6-59CCdFnyKVgduEWFjP1PdQtrZCLX9LWKqLKTxiyZYqj0TIOZBQiEkM84HCqAU49ppxdTIujqwfIp9n0L5z6PE7re0R1vyH2HgZjA</addsrcrecordid><sourcetype>Open Website</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>A Semantic Framework to Debug Parallel Lazy Functional Languages</title><source>Publicly Available Content Database</source><creator>de la Encina, Alberto ; Hidalgo-Herrero, Mercedes ; Llana, Luis ; Rubio, Fernando</creator><creatorcontrib>de la Encina, Alberto ; Hidalgo-Herrero, Mercedes ; Llana, Luis ; Rubio, Fernando</creatorcontrib><description>It is not easy to debug lazy functional programs. The reason is that laziness and higher-order complicates basic debugging strategies. Although there exist several debuggers for sequential lazy languages, dealing with parallel languages is much harder. In this case, it is important to implement debugging platforms for parallel extensions, but it is also important to provide theoretical foundations to simplify the task of understanding the debugging process. In this work, we deal with the debugging process in two parallel languages that extend the lazy language Haskell. In particular, we provide an operational semantics that allows us to reason about our parallel extension of the sequential debugger Hood. In addition, we show how we can use it to analyze the amount of speculative work done by the processes, so that it can be used to optimize their use of resources.</description><identifier>ISSN: 2227-7390</identifier><identifier>EISSN: 2227-7390</identifier><identifier>DOI: 10.3390/math8060864</identifier><language>eng</language><publisher>MDPI AG</publisher><subject>debugging ; functional programming ; parallel programming ; semantics</subject><ispartof>Mathematics (Basel), 2020-06, Vol.8 (6), p.864</ispartof><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-c294t-9fd62c8a84bdb63fc06d1c0889321b67f602347cd7e6445c2bbf5ec836ca6b843</cites><orcidid>0000-0001-9074-4537 ; 0000-0001-6510-6090 ; 0000-0002-8969-6002 ; 0000-0003-1962-1504</orcidid></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>de la Encina, Alberto</creatorcontrib><creatorcontrib>Hidalgo-Herrero, Mercedes</creatorcontrib><creatorcontrib>Llana, Luis</creatorcontrib><creatorcontrib>Rubio, Fernando</creatorcontrib><title>A Semantic Framework to Debug Parallel Lazy Functional Languages</title><title>Mathematics (Basel)</title><description>It is not easy to debug lazy functional programs. The reason is that laziness and higher-order complicates basic debugging strategies. Although there exist several debuggers for sequential lazy languages, dealing with parallel languages is much harder. In this case, it is important to implement debugging platforms for parallel extensions, but it is also important to provide theoretical foundations to simplify the task of understanding the debugging process. In this work, we deal with the debugging process in two parallel languages that extend the lazy language Haskell. In particular, we provide an operational semantics that allows us to reason about our parallel extension of the sequential debugger Hood. In addition, we show how we can use it to analyze the amount of speculative work done by the processes, so that it can be used to optimize their use of resources.</description><subject>debugging</subject><subject>functional programming</subject><subject>parallel programming</subject><subject>semantics</subject><issn>2227-7390</issn><issn>2227-7390</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2020</creationdate><recordtype>article</recordtype><sourceid>DOA</sourceid><recordid>eNpNkEtLw0AUhQdRsNSu_AOzl-i8Oo-dpRotFBTU9XBnMompSUYmKVJ_vakV6dncc87ig3sQuqTkmnNDbloY3jWRREtxgiaMMZWpsT898udo1vcbMspQroWZoNsFfgktdEPtcZ6gDV8xfeAh4rvgthV-hgRNExq8hu8dzredH-rYwT531Raq0F-gsxKaPsz-7hS95fevy8ds_fSwWi7WmWdGDJkpC8m8Bi1c4SQvPZEF9URrwxl1UpWSMC6UL1SQQsw9c66cB6-59CCdFnyKVgduEWFjP1PdQtrZCLX9LWKqLKTxiyZYqj0TIOZBQiEkM84HCqAU49ppxdTIujqwfIp9n0L5z6PE7re0R1vyH2HgZjA</recordid><startdate>20200601</startdate><enddate>20200601</enddate><creator>de la Encina, Alberto</creator><creator>Hidalgo-Herrero, Mercedes</creator><creator>Llana, Luis</creator><creator>Rubio, Fernando</creator><general>MDPI AG</general><scope>AAYXX</scope><scope>CITATION</scope><scope>DOA</scope><orcidid>https://orcid.org/0000-0001-9074-4537</orcidid><orcidid>https://orcid.org/0000-0001-6510-6090</orcidid><orcidid>https://orcid.org/0000-0002-8969-6002</orcidid><orcidid>https://orcid.org/0000-0003-1962-1504</orcidid></search><sort><creationdate>20200601</creationdate><title>A Semantic Framework to Debug Parallel Lazy Functional Languages</title><author>de la Encina, Alberto ; Hidalgo-Herrero, Mercedes ; Llana, Luis ; Rubio, Fernando</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c294t-9fd62c8a84bdb63fc06d1c0889321b67f602347cd7e6445c2bbf5ec836ca6b843</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2020</creationdate><topic>debugging</topic><topic>functional programming</topic><topic>parallel programming</topic><topic>semantics</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>de la Encina, Alberto</creatorcontrib><creatorcontrib>Hidalgo-Herrero, Mercedes</creatorcontrib><creatorcontrib>Llana, Luis</creatorcontrib><creatorcontrib>Rubio, Fernando</creatorcontrib><collection>CrossRef</collection><collection>Directory of Open Access Journals</collection><jtitle>Mathematics (Basel)</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>de la Encina, Alberto</au><au>Hidalgo-Herrero, Mercedes</au><au>Llana, Luis</au><au>Rubio, Fernando</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>A Semantic Framework to Debug Parallel Lazy Functional Languages</atitle><jtitle>Mathematics (Basel)</jtitle><date>2020-06-01</date><risdate>2020</risdate><volume>8</volume><issue>6</issue><spage>864</spage><pages>864-</pages><issn>2227-7390</issn><eissn>2227-7390</eissn><abstract>It is not easy to debug lazy functional programs. The reason is that laziness and higher-order complicates basic debugging strategies. Although there exist several debuggers for sequential lazy languages, dealing with parallel languages is much harder. In this case, it is important to implement debugging platforms for parallel extensions, but it is also important to provide theoretical foundations to simplify the task of understanding the debugging process. In this work, we deal with the debugging process in two parallel languages that extend the lazy language Haskell. In particular, we provide an operational semantics that allows us to reason about our parallel extension of the sequential debugger Hood. In addition, we show how we can use it to analyze the amount of speculative work done by the processes, so that it can be used to optimize their use of resources.</abstract><pub>MDPI AG</pub><doi>10.3390/math8060864</doi><orcidid>https://orcid.org/0000-0001-9074-4537</orcidid><orcidid>https://orcid.org/0000-0001-6510-6090</orcidid><orcidid>https://orcid.org/0000-0002-8969-6002</orcidid><orcidid>https://orcid.org/0000-0003-1962-1504</orcidid><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2227-7390
ispartof Mathematics (Basel), 2020-06, Vol.8 (6), p.864
issn 2227-7390
2227-7390
language eng
recordid cdi_doaj_primary_oai_doaj_org_article_18c24a45e6ad4629bce1aa77238b8727
source Publicly Available Content Database
subjects debugging
functional programming
parallel programming
semantics
title A Semantic Framework to Debug Parallel Lazy Functional Languages
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-26T15%3A08%3A31IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-doaj_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=A%20Semantic%20Framework%20to%20Debug%20Parallel%20Lazy%20Functional%20Languages&rft.jtitle=Mathematics%20(Basel)&rft.au=de%20la%20Encina,%20Alberto&rft.date=2020-06-01&rft.volume=8&rft.issue=6&rft.spage=864&rft.pages=864-&rft.issn=2227-7390&rft.eissn=2227-7390&rft_id=info:doi/10.3390/math8060864&rft_dat=%3Cdoaj_cross%3Eoai_doaj_org_article_18c24a45e6ad4629bce1aa77238b8727%3C/doaj_cross%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c294t-9fd62c8a84bdb63fc06d1c0889321b67f602347cd7e6445c2bbf5ec836ca6b843%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true