{"id":96,"date":"2017-02-04T12:19:02","date_gmt":"2017-02-04T12:19:02","guid":{"rendered":"http:\/\/flux.cs.queensu.ca\/mase\/?page_id=96"},"modified":"2025-01-15T17:51:32","modified_gmt":"2025-01-15T17:51:32","slug":"per-type","status":"publish","type":"page","link":"https:\/\/labs.cs.queensu.ca\/mase\/publications\/per-type\/","title":{"rendered":"Publications per type"},"content":{"rendered":"\n<p class=\"has-ast-global-color-5-background-color has-background\">View publications by: <a href=\"https:\/\/labs.cs.queensu.ca\/mase\/publications\/per-year\/\" data-type=\"page\" data-id=\"90\">year<\/a> | <strong>type<\/strong><\/p>\n\n\n\n<p>Most publications prior to 2021 are listed below. For an up-to-date list that also includes recent publications, please see&nbsp;<a href=\"https:\/\/scholar.google.com\/citations?user=MZggB6kAAAAJ&amp;hl=en&amp;oi=ao\">Google Scholar<\/a>&nbsp;or&nbsp;<a href=\"https:\/\/dblp.org\/search?q=juergen+dingel\">DBLP<\/a>.<a><\/a><\/p>\n\n\n<div class=\"teachpress_pub_list\"><form name=\"tppublistform\" method=\"get\"><a name=\"tppubs\" id=\"tppubs\"><\/a><\/form><div class=\"teachpress_publication_list\"><h3 class=\"tp_h3\" id=\"tp_h3_article\">Journal Articles<\/h3><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Jahed, Karim;  Dingel, Juergen;  Combemale, Benoit<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('2','tp_links')\" style=\"cursor:pointer;\">Live Modeling in the Context of State Machine Models and Code Generation<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 20, <\/span><span class=\"tp_pub_additional_pages\">pp. 795-819, <\/span><span class=\"tp_pub_additional_year\">2021<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_2\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('2','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_2\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('2','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_2\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BJDC21,<br \/>\r\ntitle = {Live Modeling in the Context of State Machine Models and Code Generation},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Karim Jahed and Juergen Dingel and Benoit Combemale},<br \/>\r\nurl = {https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00829-y},<br \/>\r\ndoi = {10.1007\/s10270-020-00829-y},<br \/>\r\nyear  = {2021},<br \/>\r\ndate = {2021-06-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {20},<br \/>\r\npages = {795-819},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('2','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_2\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00829-y\" title=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00829-y\" target=\"_blank\">https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00829-y<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-020-00829-y\" title=\"Follow DOI:10.1007\/s10270-020-00829-y\" target=\"_blank\">doi:10.1007\/s10270-020-00829-y<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('2','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Kahani, Nafiseh;  Jahed, Karim;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('6','tp_links')\" style=\"cursor:pointer;\">Execution of Partial State Machine Models<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">IEEE Transactions on Software Engineering, <\/span><span class=\"tp_pub_additional_year\">2020<\/span><span class=\"tp_pub_additional_note\">, (In print)<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_6\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('6','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_6\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('6','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_6\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BKJD20,<br \/>\r\ntitle = {Execution of Partial State Machine Models},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Nafiseh Kahani and Karim Jahed and Juergen Dingel},<br \/>\r\nurl = {https:\/\/ieeexplore.ieee.org\/document\/9139402},<br \/>\r\ndoi = {10.1109\/TSE.2020.3008850},<br \/>\r\nyear  = {2020},<br \/>\r\ndate = {2020-01-01},<br \/>\r\njournal = {IEEE Transactions on Software Engineering},<br \/>\r\npublisher = {IEEE},<br \/>\r\nnote = {In print},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('6','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_6\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/ieeexplore.ieee.org\/document\/9139402\" title=\"https:\/\/ieeexplore.ieee.org\/document\/9139402\" target=\"_blank\">https:\/\/ieeexplore.ieee.org\/document\/9139402<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1109\/TSE.2020.3008850\" title=\"Follow DOI:10.1109\/TSE.2020.3008850\" target=\"_blank\">doi:10.1109\/TSE.2020.3008850<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('6','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Jahed, Karim;  Bagherzadeh, Mojtaba;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('7','tp_links')\" style=\"cursor:pointer;\">On the Benefits of File-level Modularity in the Context of Model-driven Development<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 20, <\/span><span class=\"tp_pub_additional_pages\">pp. 267-286, <\/span><span class=\"tp_pub_additional_year\">2020<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_7\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('7','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_7\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('7','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_7\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{JDB20,<br \/>\r\ntitle = {On the Benefits of File-level Modularity in the Context of Model-driven Development},<br \/>\r\nauthor = {Karim Jahed and Mojtaba Bagherzadeh and Juergen Dingel},<br \/>\r\nurl = {https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00804-7},<br \/>\r\ndoi = {10.1007\/s10270-020-00804-7},<br \/>\r\nyear  = {2020},<br \/>\r\ndate = {2020-01-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {20},<br \/>\r\npages = {267-286},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('7','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_7\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00804-7\" title=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00804-7\" target=\"_blank\">https:\/\/link.springer.com\/article\/10.1007\/s10270-020-00804-7<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-020-00804-7\" title=\"Follow DOI:10.1007\/s10270-020-00804-7\" target=\"_blank\">doi:10.1007\/s10270-020-00804-7<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('7','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Hili, Nicolas;  Bagherzadeh, Mojtaba;  Jahed, Karim;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('8','tp_links')\" style=\"cursor:pointer;\">A model-based architecture for interactive run-time monitoring<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM) publisher = Springer, <\/span><span class=\"tp_pub_additional_volume\">vol. 19, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 959-981, <\/span><span class=\"tp_pub_additional_year\">2020<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_8\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('8','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_8\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('8','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_8\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{HBJD20,<br \/>\r\ntitle = {A model-based architecture for interactive run-time monitoring},<br \/>\r\nauthor = {Nicolas Hili and Mojtaba Bagherzadeh and Karim Jahed and Juergen Dingel},<br \/>\r\nurl = {http:\/\/link.springer.com\/article\/10.1007\/s10270-020-00780-y},<br \/>\r\ndoi = {10.1007\/s10270-020-00780-y},<br \/>\r\nyear  = {2020},<br \/>\r\ndate = {2020-01-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM) publisher = Springer},<br \/>\r\nvolume = {19},<br \/>\r\nnumber = {4},<br \/>\r\npages = {959-981},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('8','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_8\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/link.springer.com\/article\/10.1007\/s10270-020-00780-y\" title=\"http:\/\/link.springer.com\/article\/10.1007\/s10270-020-00780-y\" target=\"_blank\">http:\/\/link.springer.com\/article\/10.1007\/s10270-020-00780-y<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-020-00780-y\" title=\"Follow DOI:10.1007\/s10270-020-00780-y\" target=\"_blank\">doi:10.1007\/s10270-020-00780-y<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('8','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Atampore, Francis;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\">A Controller Synthesis Framework for Automated Service Composition <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Discrete Event Dynamic Systems (JDEDS), <\/span><span class=\"tp_pub_additional_volume\">vol. 29, <\/span><span class=\"tp_pub_additional_pages\">pp. 297-365, <\/span><span class=\"tp_pub_additional_year\">2019<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_19\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('19','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_19\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{ADR19b,<br \/>\r\ntitle = {A Controller Synthesis Framework for Automated Service Composition},<br \/>\r\nauthor = {Francis Atampore and Juergen Dingel and Karen Rudie},<br \/>\r\nyear  = {2019},<br \/>\r\ndate = {2019-01-01},<br \/>\r\njournal = {Discrete Event Dynamic Systems (JDEDS)},<br \/>\r\nvolume = {29},<br \/>\r\npages = {297-365},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('19','tp_bibtex')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Atampore, Francis;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\">A Controller Synthesis Framework for Automated Service Composition <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Discrete Event Dynamic Systems (JDEDS), <\/span><span class=\"tp_pub_additional_year\">2019<\/span><span class=\"tp_pub_additional_note\">, (To appear)<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_20\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('20','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_20\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{ADR19,<br \/>\r\ntitle = {A Controller Synthesis Framework for Automated Service Composition},<br \/>\r\nauthor = {Francis Atampore and Juergen Dingel and Karen Rudie},<br \/>\r\nyear  = {2019},<br \/>\r\ndate = {2019-01-01},<br \/>\r\njournal = {Discrete Event Dynamic Systems (JDEDS)},<br \/>\r\npublisher = {Springer},<br \/>\r\nnote = {To appear},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('20','tp_bibtex')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Das, Tuhin Kanti;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('26','tp_links')\" style=\"cursor:pointer;\">Model Development Guidelines for UML-RT: Conventions, Patterns, and Antipatterns<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 17, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 717-752, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_26\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('26','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_26\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('26','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_26\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DD18,<br \/>\r\ntitle = {Model Development Guidelines for UML-RT: Conventions, Patterns, and Antipatterns},<br \/>\r\nauthor = {Tuhin Kanti Das and Juergen Dingel},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-016-0549-6},<br \/>\r\ndoi = {10.1007\/s10270-016-0549-6},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-07-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {17},<br \/>\r\nnumber = {3},<br \/>\r\npages = {717-752},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('26','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_26\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-016-0549-6\" title=\"https:\/\/doi.org\/10.1007\/s10270-016-0549-6\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-016-0549-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"Follow DOI:10.1007\/s10270-016-0549-6\" target=\"_blank\">doi:10.1007\/s10270-016-0549-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('26','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Das, Tuhin Kanti;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('25','tp_links')\" style=\"cursor:pointer;\">Model Development Guidelines for UML-RT: Conventions, Patterns, and Antipatterns<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 17, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 717-752, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_25\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('25','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_25\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('25','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_25\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DD18b,<br \/>\r\ntitle = {Model Development Guidelines for UML-RT: Conventions, Patterns, and Antipatterns},<br \/>\r\nauthor = {Tuhin Kanti Das and Juergen Dingel},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-016-0549-6},<br \/>\r\ndoi = {10.1007\/s10270-016-0549-6},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-07-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {17},<br \/>\r\nnumber = {3},<br \/>\r\npages = {717-752},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('25','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_25\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-016-0549-6\" title=\"https:\/\/doi.org\/10.1007\/s10270-016-0549-6\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-016-0549-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"Follow DOI:10.1007\/s10270-016-0549-6\" target=\"_blank\">doi:10.1007\/s10270-016-0549-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('25','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Kahani, Nafiseh;  Bezemer, Cor-Paul;  Hassan, Ahmed E;  Dingel, Juergen;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('29','tp_links')\" style=\"cursor:pointer;\">Analyzing a Decade of Linux System Calls<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Empirical Software Engineering Journal, <\/span><span class=\"tp_pub_additional_volume\">vol. 23, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 1519-1551, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_29\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('29','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_29\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('29','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_29\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('29','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_29\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BKBHDC18,<br \/>\r\ntitle = {Analyzing a Decade of Linux System Calls},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10664-017-9551-z},<br \/>\r\ndoi = {10.1007\/s10664-017-9551-z},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-06-01},<br \/>\r\njournal = {Empirical Software Engineering Journal},<br \/>\r\nvolume = {23},<br \/>\r\nnumber = {3},<br \/>\r\npages = {1519-1551},<br \/>\r\npublisher = {Springer},<br \/>\r\nabstract = {Over the past 25 years, thousands of developers have contributed more than 18 million lines of code (LOC) to the Linux kernel. As the Linux kernel forms the central part of various operating systems that are used by millions of users, the kernel must be continuously adapted to the changing demands and expectations of these users. <br \/>\r\nThe Linux kernel provides its services to an application through system calls. The combined set of all system calls forms the essential Application Programming Interface (API) through which an application interacts with the kernel. In this paper, we conduct an empirical study of 8,770 changes that were made to Linux system calls during the last decade (i.e., from April 2005 to December 2014). In particular, we study the size of the changes, and we manually identify the type of changes and bug fixes that were made. Our analysis provides an overview of the evolution of the Linux system calls over the last decade. We find that there was a considerable amount of technical debt in the kernel, that was addressed by adding a number of sibling calls(i.e., 26% of all system calls). In addition, we find that by far, the ptrace() and signal handling system calls are the most challenging to maintain. Our study can be used by developers who want to improve the design and ensure the successful evolution of their own kernel APIs.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('29','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_29\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Over the past 25 years, thousands of developers have contributed more than 18 million lines of code (LOC) to the Linux kernel. As the Linux kernel forms the central part of various operating systems that are used by millions of users, the kernel must be continuously adapted to the changing demands and expectations of these users. <br \/>\r\nThe Linux kernel provides its services to an application through system calls. The combined set of all system calls forms the essential Application Programming Interface (API) through which an application interacts with the kernel. In this paper, we conduct an empirical study of 8,770 changes that were made to Linux system calls during the last decade (i.e., from April 2005 to December 2014). In particular, we study the size of the changes, and we manually identify the type of changes and bug fixes that were made. Our analysis provides an overview of the evolution of the Linux system calls over the last decade. We find that there was a considerable amount of technical debt in the kernel, that was addressed by adding a number of sibling calls(i.e., 26% of all system calls). In addition, we find that by far, the ptrace() and signal handling system calls are the most challenging to maintain. Our study can be used by developers who want to improve the design and ensure the successful evolution of their own kernel APIs.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('29','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_29\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" title=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10664-017-9551-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10664-017-9551-z\" title=\"Follow DOI:10.1007\/s10664-017-9551-z\" target=\"_blank\">doi:10.1007\/s10664-017-9551-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('29','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Kahani, Nafiseh;  Bezemer, Cor-Paul;  Hassan, Ahmed E;  Dingel, Juergen;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('27','tp_links')\" style=\"cursor:pointer;\">Analyzing a Decade of Linux System Calls<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Empirical Software Engineering Journal, <\/span><span class=\"tp_pub_additional_volume\">vol. 23, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 1519-1551, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_27\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('27','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_27\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('27','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_27\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('27','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_27\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BKBHDC18b,<br \/>\r\ntitle = {Analyzing a Decade of Linux System Calls},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10664-017-9551-z},<br \/>\r\ndoi = {10.1007\/s10664-017-9551-z},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-06-01},<br \/>\r\njournal = {Empirical Software Engineering Journal},<br \/>\r\nvolume = {23},<br \/>\r\nnumber = {3},<br \/>\r\npages = {1519-1551},<br \/>\r\npublisher = {Springer},<br \/>\r\nabstract = {Over the past 25 years, thousands of developers have contributed more than 18 million lines of code (LOC) to the Linux kernel. As the Linux kernel forms the central part of various operating systems that are used by millions of users, the kernel must be continuously adapted to the changing demands and expectations of these users. <br \/>\r\nThe Linux kernel provides its services to an application through system calls. The combined set of all system calls forms the essential Application Programming Interface (API) through which an application interacts with the kernel. In this paper, we conduct an empirical study of 8,770 changes that were made to Linux system calls during the last decade (i.e., from April 2005 to December 2014). In particular, we study the size of the changes, and we manually identify the type of changes and bug fixes that were made. Our analysis provides an overview of the evolution of the Linux system calls over the last decade. We find that there was a considerable amount of technical debt in the kernel, that was addressed by adding a number of sibling calls(i.e., 26% of all system calls). In addition, we find that by far, the ptrace() and signal handling system calls are the most challenging to maintain. Our study can be used by developers who want to improve the design and ensure the successful evolution of their own kernel APIs.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('27','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_27\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Over the past 25 years, thousands of developers have contributed more than 18 million lines of code (LOC) to the Linux kernel. As the Linux kernel forms the central part of various operating systems that are used by millions of users, the kernel must be continuously adapted to the changing demands and expectations of these users. <br \/>\r\nThe Linux kernel provides its services to an application through system calls. The combined set of all system calls forms the essential Application Programming Interface (API) through which an application interacts with the kernel. In this paper, we conduct an empirical study of 8,770 changes that were made to Linux system calls during the last decade (i.e., from April 2005 to December 2014). In particular, we study the size of the changes, and we manually identify the type of changes and bug fixes that were made. Our analysis provides an overview of the evolution of the Linux system calls over the last decade. We find that there was a considerable amount of technical debt in the kernel, that was addressed by adding a number of sibling calls(i.e., 26% of all system calls). In addition, we find that by far, the ptrace() and signal handling system calls are the most challenging to maintain. Our study can be used by developers who want to improve the design and ensure the successful evolution of their own kernel APIs.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('27','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_27\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" title=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10664-017-9551-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10664-017-9551-z\" title=\"Follow DOI:10.1007\/s10664-017-9551-z\" target=\"_blank\">doi:10.1007\/s10664-017-9551-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('27','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Kahani, Nafiseh;  Bagherzadeh, Mojtaba;  Cordy, Jim;  Dingel, Juergen;  Varro, Daniel<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('38','tp_links')\" style=\"cursor:pointer;\">Survey and Classification of Model Transformation Tools<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_pages\">pp. 37, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_38\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('38','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_38\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('38','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_38\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{KBCDV18,<br \/>\r\ntitle = {Survey and Classification of Model Transformation Tools},<br \/>\r\nauthor = {Nafiseh Kahani and Mojtaba Bagherzadeh and Jim Cordy and Juergen Dingel and Daniel Varro},<br \/>\r\nurl = {https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6},<br \/>\r\ndoi = {https:\/\/doi.org\/10.1007\/s10270-018-0665-6},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-02-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\npages = {37},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('38','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_38\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6\" title=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6\" target=\"_blank\">https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/https:\/\/doi.org\/10.1007\/s10270-018-0665-6\" title=\"Follow DOI:https:\/\/doi.org\/10.1007\/s10270-018-0665-6\" target=\"_blank\">doi:https:\/\/doi.org\/10.1007\/s10270-018-0665-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('38','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Schulte, Wolfram<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('37','tp_links')\" style=\"cursor:pointer;\">Guest editorial for the special section on MODELS 2014<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 17, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 9-10, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_37\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('37','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_37\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('37','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_37\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DS18,<br \/>\r\ntitle = {Guest editorial for the special section on MODELS 2014},<br \/>\r\nauthor = {Juergen Dingel and Wolfram Schulte},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-016-0561-x},<br \/>\r\ndoi = {10.1007\/s10270-016-0561-x},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-02-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {17},<br \/>\r\nnumber = {1},<br \/>\r\npages = {9-10},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('37','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_37\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-016-0561-x\" title=\"https:\/\/doi.org\/10.1007\/s10270-016-0561-x\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-016-0561-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0561-x\" title=\"Follow DOI:10.1007\/s10270-016-0561-x\" target=\"_blank\">doi:10.1007\/s10270-016-0561-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('37','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Kahani, Nafiseh;  Bagherzadeh, Mojtaba;  Cordy, Jim;  Dingel, Juergen;  Varro, Daniel<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('36','tp_links')\" style=\"cursor:pointer;\">Survey and Classification of Model Transformation Tools<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_pages\">pp. 37, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_36\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('36','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_36\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('36','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_36\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{KBCDV18b,<br \/>\r\ntitle = {Survey and Classification of Model Transformation Tools},<br \/>\r\nauthor = {Nafiseh Kahani and Mojtaba Bagherzadeh and Jim Cordy and Juergen Dingel and Daniel Varro},<br \/>\r\nurl = {https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6},<br \/>\r\ndoi = {https:\/\/doi.org\/10.1007\/s10270-018-0665-6},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-02-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\npages = {37},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('36','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_36\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6\" title=\"https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6\" target=\"_blank\">https:\/\/link.springer.com\/article\/10.1007\/s10270-018-0665-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/https:\/\/doi.org\/10.1007\/s10270-018-0665-6\" title=\"Follow DOI:https:\/\/doi.org\/10.1007\/s10270-018-0665-6\" target=\"_blank\">doi:https:\/\/doi.org\/10.1007\/s10270-018-0665-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('36','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Schulte, Wolfram<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('35','tp_links')\" style=\"cursor:pointer;\">Guest editorial for the special section on MODELS 2014<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling (SoSyM), <\/span><span class=\"tp_pub_additional_volume\">vol. 17, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 9-10, <\/span><span class=\"tp_pub_additional_year\">2018<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_35\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('35','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_35\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('35','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_35\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DS18b,<br \/>\r\ntitle = {Guest editorial for the special section on MODELS 2014},<br \/>\r\nauthor = {Juergen Dingel and Wolfram Schulte},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-016-0561-x},<br \/>\r\ndoi = {10.1007\/s10270-016-0561-x},<br \/>\r\nyear  = {2018},<br \/>\r\ndate = {2018-02-01},<br \/>\r\njournal = {Software and Systems Modeling (SoSyM)},<br \/>\r\nvolume = {17},<br \/>\r\nnumber = {1},<br \/>\r\npages = {9-10},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('35','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_35\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-016-0561-x\" title=\"https:\/\/doi.org\/10.1007\/s10270-016-0561-x\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-016-0561-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0561-x\" title=\"Follow DOI:10.1007\/s10270-016-0561-x\" target=\"_blank\">doi:10.1007\/s10270-016-0561-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('35','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Waez, Md. Tawhid Bin;  W\u0105sowski, Andrzej;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('44','tp_links')\" style=\"cursor:pointer;\">Controller Synthesis for Dynamic Hierarchical Real-Time Plants Using Timed Automata<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Journal Discrete Event Dynamic Systems, Special Issue on Formal Methods in Control, <\/span><span class=\"tp_pub_additional_volume\">vol. 27, <\/span><span class=\"tp_pub_additional_pages\">pp. 407-441, <\/span><span class=\"tp_pub_additional_year\">2017<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_44\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('44','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_44\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('44','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_44\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('44','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_44\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{WWD+17,<br \/>\r\ntitle = {Controller Synthesis for Dynamic Hierarchical Real-Time Plants Using Timed Automata},<br \/>\r\nauthor = {Md. Tawhid Bin Waez and Andrzej W\u0105sowski and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2},<br \/>\r\ndoi = {10.1007\/s10626-017-0240-2},<br \/>\r\nyear  = {2017},<br \/>\r\ndate = {2017-06-01},<br \/>\r\njournal = {Journal Discrete Event Dynamic Systems, Special Issue on Formal Methods in Control},<br \/>\r\nvolume = {27},<br \/>\r\npages = {407-441},<br \/>\r\npublisher = {Springer},<br \/>\r\nabstract = {We use timed I\/O automata based timed games to synthesize task-level reconfiguration services for cost-effective fault tolerance in a case study. The case study shows that state-space explosion is a severe problem for timed games. By applying suitable abstractions, we dramatically improve the scalability. However, timed I\/O automata do not facilitate algorithmic abstraction generation techniques. The case study motivates the development of timed process automata to improve modeling and analysis for controller synthesis of time-critical plants which can be hierarchical and dynamic. The model offers two essential features for industrial systems: (i) compositional modeling with reusable designs for different contexts, and (ii) state-space reduction technique. Timed process automata model dynamic networks of continuous-time communicating plant processes which can activate other plant processes. We show how to establish safety and reachability properties of timed process automata by reduction to solving timed games. To mitigate the state-space explosion problem, an algorithmic state-space reduction technique using compositional reasoning and aggressive abstractions is also proposed. In this article, we demonstrate the theoretical framework of timed process automata and the effectiveness of the proposed state-space reduction technique by extending the case study.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('44','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_44\" style=\"display:none;\"><div class=\"tp_abstract_entry\">We use timed I\/O automata based timed games to synthesize task-level reconfiguration services for cost-effective fault tolerance in a case study. The case study shows that state-space explosion is a severe problem for timed games. By applying suitable abstractions, we dramatically improve the scalability. However, timed I\/O automata do not facilitate algorithmic abstraction generation techniques. The case study motivates the development of timed process automata to improve modeling and analysis for controller synthesis of time-critical plants which can be hierarchical and dynamic. The model offers two essential features for industrial systems: (i) compositional modeling with reusable designs for different contexts, and (ii) state-space reduction technique. Timed process automata model dynamic networks of continuous-time communicating plant processes which can activate other plant processes. We show how to establish safety and reachability properties of timed process automata by reduction to solving timed games. To mitigate the state-space explosion problem, an algorithmic state-space reduction technique using compositional reasoning and aggressive abstractions is also proposed. In this article, we demonstrate the theoretical framework of timed process automata and the effectiveness of the proposed state-space reduction technique by extending the case study.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('44','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_44\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" title=\"http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" title=\"Follow DOI:10.1007\/s10626-017-0240-2\" target=\"_blank\">doi:10.1007\/s10626-017-0240-2<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('44','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Waez, Md. Tawhid Bin;  W\u0105sowski, Andrzej;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('43','tp_links')\" style=\"cursor:pointer;\">Controller Synthesis for Dynamic Hierarchical Real-Time Plants Using Timed Automata<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Journal Discrete Event Dynamic Systems, Special Issue on Formal Methods in Control, <\/span><span class=\"tp_pub_additional_volume\">vol. 27, <\/span><span class=\"tp_pub_additional_pages\">pp. 407-441, <\/span><span class=\"tp_pub_additional_year\">2017<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_43\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('43','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_43\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('43','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_43\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('43','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_43\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{WWD+17b,<br \/>\r\ntitle = {Controller Synthesis for Dynamic Hierarchical Real-Time Plants Using Timed Automata},<br \/>\r\nauthor = {Md. Tawhid Bin Waez and Andrzej W\u0105sowski and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2},<br \/>\r\ndoi = {10.1007\/s10626-017-0240-2},<br \/>\r\nyear  = {2017},<br \/>\r\ndate = {2017-06-01},<br \/>\r\njournal = {Journal Discrete Event Dynamic Systems, Special Issue on Formal Methods in Control},<br \/>\r\nvolume = {27},<br \/>\r\npages = {407-441},<br \/>\r\npublisher = {Springer},<br \/>\r\nabstract = {We use timed I\/O automata based timed games to synthesize task-level reconfiguration services for cost-effective fault tolerance in a case study. The case study shows that state-space explosion is a severe problem for timed games. By applying suitable abstractions, we dramatically improve the scalability. However, timed I\/O automata do not facilitate algorithmic abstraction generation techniques. The case study motivates the development of timed process automata to improve modeling and analysis for controller synthesis of time-critical plants which can be hierarchical and dynamic. The model offers two essential features for industrial systems: (i) compositional modeling with reusable designs for different contexts, and (ii) state-space reduction technique. Timed process automata model dynamic networks of continuous-time communicating plant processes which can activate other plant processes. We show how to establish safety and reachability properties of timed process automata by reduction to solving timed games. To mitigate the state-space explosion problem, an algorithmic state-space reduction technique using compositional reasoning and aggressive abstractions is also proposed. In this article, we demonstrate the theoretical framework of timed process automata and the effectiveness of the proposed state-space reduction technique by extending the case study.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('43','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_43\" style=\"display:none;\"><div class=\"tp_abstract_entry\">We use timed I\/O automata based timed games to synthesize task-level reconfiguration services for cost-effective fault tolerance in a case study. The case study shows that state-space explosion is a severe problem for timed games. By applying suitable abstractions, we dramatically improve the scalability. However, timed I\/O automata do not facilitate algorithmic abstraction generation techniques. The case study motivates the development of timed process automata to improve modeling and analysis for controller synthesis of time-critical plants which can be hierarchical and dynamic. The model offers two essential features for industrial systems: (i) compositional modeling with reusable designs for different contexts, and (ii) state-space reduction technique. Timed process automata model dynamic networks of continuous-time communicating plant processes which can activate other plant processes. We show how to establish safety and reachability properties of timed process automata by reduction to solving timed games. To mitigate the state-space explosion problem, an algorithmic state-space reduction technique using compositional reasoning and aggressive abstractions is also proposed. In this article, we demonstrate the theoretical framework of timed process automata and the effectiveness of the proposed state-space reduction technique by extending the case study.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('43','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_43\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" title=\"http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10626-017-0240-2\" title=\"Follow DOI:10.1007\/s10626-017-0240-2\" target=\"_blank\">doi:10.1007\/s10626-017-0240-2<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('43','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Kahani, Nafiseh;  Bezemer, Cor-Paul;  Hassan, Ahmed E;  Dingel, Juergen;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('56','tp_links')\" style=\"cursor:pointer;\">Analyzing a Decade of Linux System Calls<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Empirical Software Engineering Journal, <\/span><span class=\"tp_pub_additional_year\">2017<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_56\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('56','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_56\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('56','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_56\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BKB+17,<br \/>\r\ntitle = {Analyzing a Decade of Linux System Calls},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10664-017-9551-z},<br \/>\r\ndoi = {10.1007\/s10664-017-9551-z},<br \/>\r\nyear  = {2017},<br \/>\r\ndate = {2017-01-01},<br \/>\r\njournal = {Empirical Software Engineering Journal},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('56','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_56\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" title=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10664-017-9551-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10664-017-9551-z\" title=\"Follow DOI:10.1007\/s10664-017-9551-z\" target=\"_blank\">doi:10.1007\/s10664-017-9551-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('56','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Bagherzadeh, Mojtaba;  Kahani, Nafiseh;  Bezemer, Cor-Paul;  Hassan, Ahmed E;  Dingel, Juergen;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('48','tp_links')\" style=\"cursor:pointer;\">Analyzing a Decade of Linux System Calls<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Empirical Software Engineering Journal, <\/span><span class=\"tp_pub_additional_year\">2017<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_48\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('48','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_48\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('48','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_48\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{BKB+17b,<br \/>\r\ntitle = {Analyzing a Decade of Linux System Calls},<br \/>\r\nauthor = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10664-017-9551-z},<br \/>\r\ndoi = {10.1007\/s10664-017-9551-z},<br \/>\r\nyear  = {2017},<br \/>\r\ndate = {2017-01-01},<br \/>\r\njournal = {Empirical Software Engineering Journal},<br \/>\r\npublisher = {Springer},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('48','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_48\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" title=\"https:\/\/doi.org\/10.1007\/s10664-017-9551-z\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10664-017-9551-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10664-017-9551-z\" title=\"Follow DOI:10.1007\/s10664-017-9551-z\" target=\"_blank\">doi:10.1007\/s10664-017-9551-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('48','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Das, Tuhin Kanti;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('63','tp_links')\" style=\"cursor:pointer;\">Model development guidelines for UML-RT: conventions, patterns and antipatterns<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_63\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('63','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_63\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('63','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_63\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('63','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_63\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Das2016b,<br \/>\r\ntitle = {Model development guidelines for UML-RT: conventions, patterns and antipatterns},<br \/>\r\nauthor = {Tuhin Kanti Das and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6},<br \/>\r\ndoi = {10.1007\/s10270-016-0549-6},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-07-23},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nabstract = {Software development guidelines are a set of rules which can help improve the quality of software. These rules are defined on the basis of experience gained by the software development community over time. This paper discusses a set of design guidelines for model-based development of complex real-time embedded software systems. To be precise, we propose nine design conventions, three design patterns and thirteen antipatterns for developing UML-RT models. These guidelines have been identified based on our analysis of around 100 UML-RT models from industry and academia. Most of the guidelines are explained with the help of examples, and standard templates from the current state of the art are used for documenting the design rules.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('63','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_63\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Software development guidelines are a set of rules which can help improve the quality of software. These rules are defined on the basis of experience gained by the software development community over time. This paper discusses a set of design guidelines for model-based development of complex real-time embedded software systems. To be precise, we propose nine design conventions, three design patterns and thirteen antipatterns for developing UML-RT models. These guidelines have been identified based on our analysis of around 100 UML-RT models from industry and academia. Most of the guidelines are explained with the help of examples, and standard templates from the current state of the art are used for documenting the design rules.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('63','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_63\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"Follow DOI:10.1007\/s10270-016-0549-6\" target=\"_blank\">doi:10.1007\/s10270-016-0549-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('63','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Das, Tuhin Kanti;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('64','tp_links')\" style=\"cursor:pointer;\">Model development guidelines for UML-RT: conventions, patterns and antipatterns<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_64\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('64','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_64\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('64','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_64\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('64','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_64\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Das2016,<br \/>\r\ntitle = {Model development guidelines for UML-RT: conventions, patterns and antipatterns},<br \/>\r\nauthor = {Tuhin Kanti Das and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6},<br \/>\r\ndoi = {10.1007\/s10270-016-0549-6},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-07-23},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nabstract = {Software development guidelines are a set of rules which can help improve the quality of software. These rules are defined on the basis of experience gained by the software development community over time. This paper discusses a set of design guidelines for model-based development of complex real-time embedded software systems. To be precise, we propose nine design conventions, three design patterns and thirteen antipatterns for developing UML-RT models. These guidelines have been identified based on our analysis of around 100 UML-RT models from industry and academia. Most of the guidelines are explained with the help of examples, and standard templates from the current state of the art are used for documenting the design rules.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('64','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_64\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Software development guidelines are a set of rules which can help improve the quality of software. These rules are defined on the basis of experience gained by the software development community over time. This paper discusses a set of design guidelines for model-based development of complex real-time embedded software systems. To be precise, we propose nine design conventions, three design patterns and thirteen antipatterns for developing UML-RT models. These guidelines have been identified based on our analysis of around 100 UML-RT models from industry and academia. Most of the guidelines are explained with the help of examples, and standard templates from the current state of the art are used for documenting the design rules.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('64','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_64\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0549-6\" title=\"Follow DOI:10.1007\/s10270-016-0549-6\" target=\"_blank\">doi:10.1007\/s10270-016-0549-6<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('64','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> L\u00facio, Levi;  Amrani, Moussa;  Dingel, Juergen;  Lambers, Leen;  Salay, Rick;  Selim, Gehan M K;  Syriani, Eugene;  Wimmer, Manuel<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('65','tp_links')\" style=\"cursor:pointer;\">Model transformation intents and their properties<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 15, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 647-684, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_65\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('65','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_65\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('65','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_65\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('65','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_65\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Lucio2016b,<br \/>\r\ntitle = {Model transformation intents and their properties},<br \/>\r\nauthor = {Levi L\u00facio and Moussa Amrani and Juergen Dingel and Leen Lambers and Rick Salay and Gehan M K Selim and Eugene Syriani and Manuel Wimmer},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x},<br \/>\r\ndoi = {10.1007\/s10270-014-0429-x},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-07-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {15},<br \/>\r\nnumber = {3},<br \/>\r\npages = {647-684},<br \/>\r\nabstract = {The notion of model transformation intent is proposed to capture the purpose of a transformation. In this paper, a framework for the description of model transformation intents is defined, which includes, for instance, a description of properties a model transformation has to satisfy to qualify as a suitable realization of an intent. Several common model transformation intents are identified, and the framework is used to describe six of them in detail. A case study from the automotive industry is used to demonstrate the usefulness of the proposed framework for identifying crucial properties of model transformations with different intents and to illustrate the wide variety of model transformation intents that an industrial model-driven software development process typically encompasses.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('65','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_65\" style=\"display:none;\"><div class=\"tp_abstract_entry\">The notion of model transformation intent is proposed to capture the purpose of a transformation. In this paper, a framework for the description of model transformation intents is defined, which includes, for instance, a description of properties a model transformation has to satisfy to qualify as a suitable realization of an intent. Several common model transformation intents are identified, and the framework is used to describe six of them in detail. A case study from the automotive industry is used to demonstrate the usefulness of the proposed framework for identifying crucial properties of model transformations with different intents and to illustrate the wide variety of model transformation intents that an industrial model-driven software development process typically encompasses.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('65','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_65\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" title=\"Follow DOI:10.1007\/s10270-014-0429-x\" target=\"_blank\">doi:10.1007\/s10270-014-0429-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('65','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> L\u00facio, Levi;  Amrani, Moussa;  Dingel, Juergen;  Lambers, Leen;  Salay, Rick;  Selim, Gehan M K;  Syriani, Eugene;  Wimmer, Manuel<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('66','tp_links')\" style=\"cursor:pointer;\">Model transformation intents and their properties<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 15, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 647-684, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_66\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('66','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_66\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('66','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_66\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('66','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_66\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Lucio2016,<br \/>\r\ntitle = {Model transformation intents and their properties},<br \/>\r\nauthor = {Levi L\u00facio and Moussa Amrani and Juergen Dingel and Leen Lambers and Rick Salay and Gehan M K Selim and Eugene Syriani and Manuel Wimmer},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x},<br \/>\r\ndoi = {10.1007\/s10270-014-0429-x},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-07-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {15},<br \/>\r\nnumber = {3},<br \/>\r\npages = {647-684},<br \/>\r\nabstract = {The notion of model transformation intent is proposed to capture the purpose of a transformation. In this paper, a framework for the description of model transformation intents is defined, which includes, for instance, a description of properties a model transformation has to satisfy to qualify as a suitable realization of an intent. Several common model transformation intents are identified, and the framework is used to describe six of them in detail. A case study from the automotive industry is used to demonstrate the usefulness of the proposed framework for identifying crucial properties of model transformations with different intents and to illustrate the wide variety of model transformation intents that an industrial model-driven software development process typically encompasses.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('66','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_66\" style=\"display:none;\"><div class=\"tp_abstract_entry\">The notion of model transformation intent is proposed to capture the purpose of a transformation. In this paper, a framework for the description of model transformation intents is defined, which includes, for instance, a description of properties a model transformation has to satisfy to qualify as a suitable realization of an intent. Several common model transformation intents are identified, and the framework is used to describe six of them in detail. A case study from the automotive industry is used to demonstrate the usefulness of the proposed framework for identifying crucial properties of model transformations with different intents and to illustrate the wide variety of model transformation intents that an industrial model-driven software development process typically encompasses.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('66','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_66\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-014-0429-x\" title=\"Follow DOI:10.1007\/s10270-014-0429-x\" target=\"_blank\">doi:10.1007\/s10270-014-0429-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('66','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Schulte, Wolfram<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('70','tp_links')\" style=\"cursor:pointer;\">Guest editorial for the special section on MODELS 2014<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_year\">2016<\/span><span class=\"tp_pub_additional_note\">, (To appear)<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_70\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('70','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_70\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('70','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_70\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DS16b,<br \/>\r\ntitle = {Guest editorial for the special section on MODELS 2014},<br \/>\r\nauthor = {Juergen Dingel and Wolfram Schulte},<br \/>\r\ndoi = {10.1007\/s10270-016-0561-x},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\npublisher = {Springer},<br \/>\r\nnote = {To appear},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('70','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_70\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0561-x\" title=\"Follow DOI:10.1007\/s10270-016-0561-x\" target=\"_blank\">doi:10.1007\/s10270-016-0561-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('70','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Posse, Ernesto;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('72','tp_links')\" style=\"cursor:pointer;\">An executable formal semantics for UML-RT<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 15, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 179-217, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_72\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('72','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_72\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('72','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_72\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('72','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_72\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Posse2016b,<br \/>\r\ntitle = {An executable formal semantics for UML-RT},<br \/>\r\nauthor = {Ernesto Posse and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z},<br \/>\r\ndoi = {10.1007\/s10270-014-0399-z},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {15},<br \/>\r\nnumber = {1},<br \/>\r\npages = {179-217},<br \/>\r\nabstract = {We propose a formal semantics for UML-RT, a UML profile for real-time and embedded systems. The formal semantics is given by mapping UML-RT models into a language called kiltera, a real-time extension of the Pi-calculus. Previous attempts to formalize the semantics of UML-RT have fallen short by considering only a very small subset of the language and providing fundamentally incomplete semantics based on incorrect assumptions, such as a one-to-one correspondence between 'capsules' and threads. Our semantics is novel in several ways: (1) it deals with both state machine diagrams and capsule diagrams; (2) it deals with aspects of UML-RT that have not been formalized before, such as thread allocation, service provision points, and service access points; (3) it supports an action language; and (4) the translation has been implemented in the form of a transformation from UML-RT models created with IBM's RSA-RTE tool, into kiltera code. To our knowledge, this is the most comprehensive formal semantics for UML-RT to date.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('72','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_72\" style=\"display:none;\"><div class=\"tp_abstract_entry\">We propose a formal semantics for UML-RT, a UML profile for real-time and embedded systems. The formal semantics is given by mapping UML-RT models into a language called kiltera, a real-time extension of the Pi-calculus. Previous attempts to formalize the semantics of UML-RT have fallen short by considering only a very small subset of the language and providing fundamentally incomplete semantics based on incorrect assumptions, such as a one-to-one correspondence between 'capsules' and threads. Our semantics is novel in several ways: (1) it deals with both state machine diagrams and capsule diagrams; (2) it deals with aspects of UML-RT that have not been formalized before, such as thread allocation, service provision points, and service access points; (3) it supports an action language; and (4) the translation has been implemented in the form of a transformation from UML-RT models created with IBM's RSA-RTE tool, into kiltera code. To our knowledge, this is the most comprehensive formal semantics for UML-RT to date.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('72','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_72\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" title=\"Follow DOI:10.1007\/s10270-014-0399-z\" target=\"_blank\">doi:10.1007\/s10270-014-0399-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('72','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Schulte, Wolfram<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('78','tp_links')\" style=\"cursor:pointer;\">Guest editorial for the special section on MODELS 2014<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_year\">2016<\/span><span class=\"tp_pub_additional_note\">, (To appear)<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_78\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('78','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_78\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('78','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_78\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DS16,<br \/>\r\ntitle = {Guest editorial for the special section on MODELS 2014},<br \/>\r\nauthor = {Juergen Dingel and Wolfram Schulte},<br \/>\r\ndoi = {10.1007\/s10270-016-0561-x},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\npublisher = {Springer},<br \/>\r\nnote = {To appear},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('78','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_78\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-016-0561-x\" title=\"Follow DOI:10.1007\/s10270-016-0561-x\" target=\"_blank\">doi:10.1007\/s10270-016-0561-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('78','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Posse, Ernesto;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('80','tp_links')\" style=\"cursor:pointer;\">An executable formal semantics for UML-RT<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 15, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 179-217, <\/span><span class=\"tp_pub_additional_year\">2016<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_80\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('80','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_80\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('80','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_80\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('80','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_80\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Posse2016,<br \/>\r\ntitle = {An executable formal semantics for UML-RT},<br \/>\r\nauthor = {Ernesto Posse and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z},<br \/>\r\ndoi = {10.1007\/s10270-014-0399-z},<br \/>\r\nyear  = {2016},<br \/>\r\ndate = {2016-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {15},<br \/>\r\nnumber = {1},<br \/>\r\npages = {179-217},<br \/>\r\nabstract = {We propose a formal semantics for UML-RT, a UML profile for real-time and embedded systems. The formal semantics is given by mapping UML-RT models into a language called kiltera, a real-time extension of the Pi-calculus. Previous attempts to formalize the semantics of UML-RT have fallen short by considering only a very small subset of the language and providing fundamentally incomplete semantics based on incorrect assumptions, such as a one-to-one correspondence between 'capsules' and threads. Our semantics is novel in several ways: (1) it deals with both state machine diagrams and capsule diagrams; (2) it deals with aspects of UML-RT that have not been formalized before, such as thread allocation, service provision points, and service access points; (3) it supports an action language; and (4) the translation has been implemented in the form of a transformation from UML-RT models created with IBM's RSA-RTE tool, into kiltera code. To our knowledge, this is the most comprehensive formal semantics for UML-RT to date.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('80','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_80\" style=\"display:none;\"><div class=\"tp_abstract_entry\">We propose a formal semantics for UML-RT, a UML profile for real-time and embedded systems. The formal semantics is given by mapping UML-RT models into a language called kiltera, a real-time extension of the Pi-calculus. Previous attempts to formalize the semantics of UML-RT have fallen short by considering only a very small subset of the language and providing fundamentally incomplete semantics based on incorrect assumptions, such as a one-to-one correspondence between 'capsules' and threads. Our semantics is novel in several ways: (1) it deals with both state machine diagrams and capsule diagrams; (2) it deals with aspects of UML-RT that have not been formalized before, such as thread allocation, service provision points, and service access points; (3) it supports an action language; and (4) the translation has been implemented in the form of a transformation from UML-RT models created with IBM's RSA-RTE tool, into kiltera code. To our knowledge, this is the most comprehensive formal semantics for UML-RT to date.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('80','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_80\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-014-0399-z\" title=\"Follow DOI:10.1007\/s10270-014-0399-z\" target=\"_blank\">doi:10.1007\/s10270-014-0399-z<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('80','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Amrani, Moussa;  Combemale, Benoit;  L\u00facio, Levi;  Selim, Gehan M K;  Dingel, Juergen;  Traon, Yves Le;  Vangheluwe, Hans;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('94','tp_links')\" style=\"cursor:pointer;\">Formal Verification Techniques for Model Transformations: A Tridimensional Classification<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Journal of Object Technology, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 1-43, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1660-1769<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_94\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('94','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_94\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('94','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_94\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{JOT:issue_2015_03\/article1,<br \/>\r\ntitle = {Formal Verification Techniques for Model Transformations: A Tridimensional Classification},<br \/>\r\nauthor = {Moussa Amrani and Benoit Combemale and Levi L\u00facio and Gehan M K Selim and Juergen Dingel and Yves Le Traon and Hans Vangheluwe and James R Cordy},<br \/>\r\nurl = {http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html},<br \/>\r\ndoi = {10.5381\/jot.2015.14.3.a1},<br \/>\r\nissn = {1660-1769},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-08-01},<br \/>\r\njournal = {Journal of Object Technology},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {3},<br \/>\r\npages = {1-43},<br \/>\r\npublisher = {Association Internationale pour les Technologies Objets (AITO)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('94','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_94\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html\" title=\"http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html\" target=\"_blank\">http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.5381\/jot.2015.14.3.a1\" title=\"Follow DOI:10.5381\/jot.2015.14.3.a1\" target=\"_blank\">doi:10.5381\/jot.2015.14.3.a1<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('94','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Amrani, Moussa;  Combemale, Benoit;  L\u00facio, Levi;  Selim, Gehan M K;  Dingel, Juergen;  Traon, Yves Le;  Vangheluwe, Hans;  Cordy, James R<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('93','tp_links')\" style=\"cursor:pointer;\">Formal Verification Techniques for Model Transformations: A Tridimensional Classification<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Journal of Object Technology, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 1-43, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1660-1769<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_93\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('93','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_93\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('93','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_93\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{JOT:issue_2015_03\/article1b,<br \/>\r\ntitle = {Formal Verification Techniques for Model Transformations: A Tridimensional Classification},<br \/>\r\nauthor = {Moussa Amrani and Benoit Combemale and Levi L\u00facio and Gehan M K Selim and Juergen Dingel and Yves Le Traon and Hans Vangheluwe and James R Cordy},<br \/>\r\nurl = {http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html},<br \/>\r\ndoi = {10.5381\/jot.2015.14.3.a1},<br \/>\r\nissn = {1660-1769},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-08-01},<br \/>\r\njournal = {Journal of Object Technology},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {3},<br \/>\r\npages = {1-43},<br \/>\r\npublisher = {Association Internationale pour les Technologies Objets (AITO)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('93','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_93\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html\" title=\"http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html\" target=\"_blank\">http:\/\/www.jot.fm\/contents\/issue_2015_03\/article1.html<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.5381\/jot.2015.14.3.a1\" title=\"Follow DOI:10.5381\/jot.2015.14.3.a1\" target=\"_blank\">doi:10.5381\/jot.2015.14.3.a1<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('93','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Selim, Gehan M K;  Wang, Shige;  Cordy, James R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('102','tp_links')\" style=\"cursor:pointer;\">Model transformations for migrating legacy deployment models in the automotive industry<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 365-381, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_102\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('102','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_102\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('102','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_102\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('102','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_102\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Selim2015,<br \/>\r\ntitle = {Model transformations for migrating legacy deployment models in the automotive industry},<br \/>\r\nauthor = {Gehan M K Selim and Shige Wang and James R Cordy and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1},<br \/>\r\ndoi = {10.1007\/s10270-013-0365-1},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-02-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {1},<br \/>\r\npages = {365-381},<br \/>\r\nabstract = {Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('102','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_102\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('102','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_102\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" title=\"Follow DOI:10.1007\/s10270-013-0365-1\" target=\"_blank\">doi:10.1007\/s10270-013-0365-1<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('102','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Selim, Gehan M K;  Wang, Shige;  Cordy, James R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('100','tp_links')\" style=\"cursor:pointer;\">Model transformations for migrating legacy deployment models in the automotive industry<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 365-381, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_100\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('100','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_100\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('100','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_100\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('100','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_100\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Selim2015c,<br \/>\r\ntitle = {Model transformations for migrating legacy deployment models in the automotive industry},<br \/>\r\nauthor = {Gehan M K Selim and Shige Wang and James R Cordy and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1},<br \/>\r\ndoi = {10.1007\/s10270-013-0365-1},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-02-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {1},<br \/>\r\npages = {365-381},<br \/>\r\nabstract = {Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('100','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_100\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('100','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_100\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-013-0365-1\" title=\"Follow DOI:10.1007\/s10270-013-0365-1\" target=\"_blank\">doi:10.1007\/s10270-013-0365-1<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('100','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Zurowska, Karolina;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('112','tp_links')\" style=\"cursor:pointer;\">A Customizable Execution Engine for Models of Embedded Systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_pages\">pp. 82-110, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>, <span class=\"tp_pub_additional_isbn\">ISBN: 978-3-319-21911-0<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_112\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('112','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_112\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('112','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_112\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Zurowska:2015:CEE:2977726.2977732,<br \/>\r\ntitle = {A Customizable Execution Engine for Models of Embedded Systems},<br \/>\r\nauthor = {Karolina Zurowska and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4},<br \/>\r\ndoi = {10.1007\/978-3-319-21912-7_4},<br \/>\r\nisbn = {978-3-319-21911-0},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-01-01},<br \/>\r\nbooktitle = {Revised Selected Papers of the International Workshops on Behavior Modeling - Foundations and Applications},<br \/>\r\npages = {82-110},<br \/>\r\npublisher = {Springer},<br \/>\r\naddress = {New York, NY, USA},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('112','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_112\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" title=\"http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" title=\"Follow DOI:10.1007\/978-3-319-21912-7_4\" target=\"_blank\">doi:10.1007\/978-3-319-21912-7_4<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('112','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Zurowska, Karolina;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('104','tp_links')\" style=\"cursor:pointer;\">A Customizable Execution Engine for Models of Embedded Systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_pages\">pp. 82-110, <\/span><span class=\"tp_pub_additional_year\">2015<\/span>, <span class=\"tp_pub_additional_isbn\">ISBN: 978-3-319-21911-0<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_104\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('104','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_104\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('104','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_104\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Zurowska:2015:CEE:2977726.2977732b,<br \/>\r\ntitle = {A Customizable Execution Engine for Models of Embedded Systems},<br \/>\r\nauthor = {Karolina Zurowska and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4},<br \/>\r\ndoi = {10.1007\/978-3-319-21912-7_4},<br \/>\r\nisbn = {978-3-319-21911-0},<br \/>\r\nyear  = {2015},<br \/>\r\ndate = {2015-01-01},<br \/>\r\nbooktitle = {Revised Selected Papers of the International Workshops on Behavior Modeling - Foundations and Applications},<br \/>\r\npages = {82-110},<br \/>\r\npublisher = {Springer},<br \/>\r\naddress = {New York, NY, USA},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('104','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_104\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" title=\"http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/978-3-319-21912-7_4\" title=\"Follow DOI:10.1007\/978-3-319-21912-7_4\" target=\"_blank\">doi:10.1007\/978-3-319-21912-7_4<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('104','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Auer, Anthony;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('128','tp_links')\" style=\"cursor:pointer;\">Concurrency control generation for dynamic threads using discrete-event systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Science of Computer Programming, <\/span><span class=\"tp_pub_additional_volume\">vol. 82, <\/span><span class=\"tp_pub_additional_pages\">pp. 22 - 43, <\/span><span class=\"tp_pub_additional_year\">2014<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0167-6423<\/span><span class=\"tp_pub_additional_note\">, (Special Issue on Automated Verification of Critical Systems (AVoCS'11))<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_128\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('128','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_128\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('128','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_128\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{AUER201422,<br \/>\r\ntitle = {Concurrency control generation for dynamic threads using discrete-event systems},<br \/>\r\nauthor = {Anthony Auer and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007},<br \/>\r\nissn = {0167-6423},<br \/>\r\nyear  = {2014},<br \/>\r\ndate = {2014-01-01},<br \/>\r\njournal = {Science of Computer Programming},<br \/>\r\nvolume = {82},<br \/>\r\npages = {22 - 43},<br \/>\r\nnote = {Special Issue on Automated Verification of Critical Systems (AVoCS'11)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('128','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_128\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('128','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Auer, Anthony;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('122','tp_links')\" style=\"cursor:pointer;\">Concurrency control generation for dynamic threads using discrete-event systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Science of Computer Programming, <\/span><span class=\"tp_pub_additional_volume\">vol. 82, <\/span><span class=\"tp_pub_additional_pages\">pp. 22 - 43, <\/span><span class=\"tp_pub_additional_year\">2014<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0167-6423<\/span><span class=\"tp_pub_additional_note\">, (Special Issue on Automated Verification of Critical Systems (AVoCS'11))<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_122\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('122','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_122\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('122','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_122\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{AUER201422b,<br \/>\r\ntitle = {Concurrency control generation for dynamic threads using discrete-event systems},<br \/>\r\nauthor = {Anthony Auer and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007},<br \/>\r\nissn = {0167-6423},<br \/>\r\nyear  = {2014},<br \/>\r\ndate = {2014-01-01},<br \/>\r\njournal = {Science of Computer Programming},<br \/>\r\nvolume = {82},<br \/>\r\npages = {22 - 43},<br \/>\r\nnote = {Special Issue on Automated Verification of Critical Systems (AVoCS'11)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('122','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_122\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642313000208<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.scico.2013.01.007<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('122','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Moffett, Yann;  Dingel, Juergen;  Beaulieu, Alain<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('132','tp_links')\" style=\"cursor:pointer;\">Verifying Protocol Conformance Using Software Model Checking for the Model-Driven Development of Embedded Systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">IEEE Transactions on Software Engineering, <\/span><span class=\"tp_pub_additional_volume\">vol. 39, <\/span><span class=\"tp_pub_additional_number\">no. 9, <\/span><span class=\"tp_pub_additional_pages\">pp. 1307-13256, <\/span><span class=\"tp_pub_additional_year\">2013<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0098-5589<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_132\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('132','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_132\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('132','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_132\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{6482140b,<br \/>\r\ntitle = {Verifying Protocol Conformance Using Software Model Checking for the Model-Driven Development of Embedded Systems},<br \/>\r\nauthor = {Yann Moffett and Juergen Dingel and Alain Beaulieu},<br \/>\r\nurl = {http:\/\/ieeexplore.ieee.org\/document\/6482140},<br \/>\r\ndoi = {10.1109\/TSE.2013.14},<br \/>\r\nissn = {0098-5589},<br \/>\r\nyear  = {2013},<br \/>\r\ndate = {2013-09-01},<br \/>\r\njournal = {IEEE Transactions on Software Engineering},<br \/>\r\nvolume = {39},<br \/>\r\nnumber = {9},<br \/>\r\npages = {1307-13256},<br \/>\r\npublisher = {IEEE},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('132','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_132\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/ieeexplore.ieee.org\/document\/6482140\" title=\"http:\/\/ieeexplore.ieee.org\/document\/6482140\" target=\"_blank\">http:\/\/ieeexplore.ieee.org\/document\/6482140<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1109\/TSE.2013.14\" title=\"Follow DOI:10.1109\/TSE.2013.14\" target=\"_blank\">doi:10.1109\/TSE.2013.14<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('132','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Moffett, Yann;  Dingel, Juergen;  Beaulieu, Alain<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('134','tp_links')\" style=\"cursor:pointer;\">Verifying Protocol Conformance Using Software Model Checking for the Model-Driven Development of Embedded Systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">IEEE Transactions on Software Engineering, <\/span><span class=\"tp_pub_additional_volume\">vol. 39, <\/span><span class=\"tp_pub_additional_number\">no. 9, <\/span><span class=\"tp_pub_additional_pages\">pp. 1307-13256, <\/span><span class=\"tp_pub_additional_year\">2013<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0098-5589<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_134\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('134','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_134\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('134','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_134\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{6482140,<br \/>\r\ntitle = {Verifying Protocol Conformance Using Software Model Checking for the Model-Driven Development of Embedded Systems},<br \/>\r\nauthor = {Yann Moffett and Juergen Dingel and Alain Beaulieu},<br \/>\r\nurl = {http:\/\/ieeexplore.ieee.org\/document\/6482140},<br \/>\r\ndoi = {10.1109\/TSE.2013.14},<br \/>\r\nissn = {0098-5589},<br \/>\r\nyear  = {2013},<br \/>\r\ndate = {2013-09-01},<br \/>\r\njournal = {IEEE Transactions on Software Engineering},<br \/>\r\nvolume = {39},<br \/>\r\nnumber = {9},<br \/>\r\npages = {1307-13256},<br \/>\r\npublisher = {IEEE},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('134','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_134\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/ieeexplore.ieee.org\/document\/6482140\" title=\"http:\/\/ieeexplore.ieee.org\/document\/6482140\" target=\"_blank\">http:\/\/ieeexplore.ieee.org\/document\/6482140<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1109\/TSE.2013.14\" title=\"Follow DOI:10.1109\/TSE.2013.14\" target=\"_blank\">doi:10.1109\/TSE.2013.14<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('134','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Waez, Md Tawhid Bin;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('141','tp_links')\" style=\"cursor:pointer;\">A survey of timed automata for the development of real-time systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Computer Science Review, <\/span><span class=\"tp_pub_additional_volume\">vol. 9, <\/span><span class=\"tp_pub_additional_pages\">pp. 1 - 26, <\/span><span class=\"tp_pub_additional_year\">2013<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1574-0137<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_141\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('141','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_141\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('141','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_141\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{WAEZ20131b,<br \/>\r\ntitle = {A survey of timed automata for the development of real-time systems},<br \/>\r\nauthor = {Md Tawhid Bin Waez and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001},<br \/>\r\nissn = {1574-0137},<br \/>\r\nyear  = {2013},<br \/>\r\ndate = {2013-01-01},<br \/>\r\njournal = {Computer Science Review},<br \/>\r\nvolume = {9},<br \/>\r\npages = {1 - 26},<br \/>\r\npublisher = {Elsevier},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('141','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_141\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('141','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Waez, Md Tawhid Bin;  Dingel, Juergen;  Rudie, Karen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('143','tp_links')\" style=\"cursor:pointer;\">A survey of timed automata for the development of real-time systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Computer Science Review, <\/span><span class=\"tp_pub_additional_volume\">vol. 9, <\/span><span class=\"tp_pub_additional_pages\">pp. 1 - 26, <\/span><span class=\"tp_pub_additional_year\">2013<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1574-0137<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_143\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('143','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_143\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('143','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_143\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{WAEZ20131,<br \/>\r\ntitle = {A survey of timed automata for the development of real-time systems},<br \/>\r\nauthor = {Md Tawhid Bin Waez and Juergen Dingel and Karen Rudie},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001},<br \/>\r\nissn = {1574-0137},<br \/>\r\nyear  = {2013},<br \/>\r\ndate = {2013-01-01},<br \/>\r\njournal = {Computer Science Review},<br \/>\r\nvolume = {9},<br \/>\r\npages = {1 - 26},<br \/>\r\npublisher = {Elsevier},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('143','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_143\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1574013713000178<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.cosrev.2013.05.001<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('143','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Diskin, Zinovy;  Zito, Alanna<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('198','tp_links')\" style=\"cursor:pointer;\">Understanding and improving UML package merge<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 7, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 443-467, <\/span><span class=\"tp_pub_additional_year\">2008<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_198\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('198','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_198\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('198','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_198\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('198','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_198\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel2008,<br \/>\r\ntitle = {Understanding and improving UML package merge},<br \/>\r\nauthor = {Juergen Dingel and Zinovy Diskin and Alanna Zito},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9},<br \/>\r\ndoi = {10.1007\/s10270-007-0073-9},<br \/>\r\nyear  = {2008},<br \/>\r\ndate = {2008-10-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {7},<br \/>\r\nnumber = {4},<br \/>\r\npages = {443-467},<br \/>\r\nabstract = {Package merge allows the content of one package to be combined with that of another package. Package merge is used extensively in the UML 2 specification to modularize the definition of the UML 2 meta model and to define the four compliance levels of UML 2. Package merge is a novel construct in UML and currently not well understood. This paper summarizes our work to understand and improve package merge. First, we identify ambiguous and missing rules in the package merge definition and suggest corrections. Then, we formalize package merge and analyze it with respect to some desirable properties. Our analyses employs Alloy, a first-order modelling language with tool support, and concepts from mathematical logic which allow us to develop a general taxonomy of package extension mechanisms. The analyses reveal the unexpected failure of important properties.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('198','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_198\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Package merge allows the content of one package to be combined with that of another package. Package merge is used extensively in the UML 2 specification to modularize the definition of the UML 2 meta model and to define the four compliance levels of UML 2. Package merge is a novel construct in UML and currently not well understood. This paper summarizes our work to understand and improve package merge. First, we identify ambiguous and missing rules in the package merge definition and suggest corrections. Then, we formalize package merge and analyze it with respect to some desirable properties. Our analyses employs Alloy, a first-order modelling language with tool support, and concepts from mathematical logic which allow us to develop a general taxonomy of package extension mechanisms. The analyses reveal the unexpected failure of important properties.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('198','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_198\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" title=\"Follow DOI:10.1007\/s10270-007-0073-9\" target=\"_blank\">doi:10.1007\/s10270-007-0073-9<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('198','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen;  Diskin, Zinovy;  Zito, Alanna<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('197','tp_links')\" style=\"cursor:pointer;\">Understanding and improving UML package merge<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 7, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 443-467, <\/span><span class=\"tp_pub_additional_year\">2008<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_197\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('197','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_197\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('197','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_197\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('197','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_197\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel2008b,<br \/>\r\ntitle = {Understanding and improving UML package merge},<br \/>\r\nauthor = {Juergen Dingel and Zinovy Diskin and Alanna Zito},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9},<br \/>\r\ndoi = {10.1007\/s10270-007-0073-9},<br \/>\r\nyear  = {2008},<br \/>\r\ndate = {2008-10-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {7},<br \/>\r\nnumber = {4},<br \/>\r\npages = {443-467},<br \/>\r\nabstract = {Package merge allows the content of one package to be combined with that of another package. Package merge is used extensively in the UML 2 specification to modularize the definition of the UML 2 meta model and to define the four compliance levels of UML 2. Package merge is a novel construct in UML and currently not well understood. This paper summarizes our work to understand and improve package merge. First, we identify ambiguous and missing rules in the package merge definition and suggest corrections. Then, we formalize package merge and analyze it with respect to some desirable properties. Our analyses employs Alloy, a first-order modelling language with tool support, and concepts from mathematical logic which allow us to develop a general taxonomy of package extension mechanisms. The analyses reveal the unexpected failure of important properties.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('197','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_197\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Package merge allows the content of one package to be combined with that of another package. Package merge is used extensively in the UML 2 specification to modularize the definition of the UML 2 meta model and to define the four compliance levels of UML 2. Package merge is a novel construct in UML and currently not well understood. This paper summarizes our work to understand and improve package merge. First, we identify ambiguous and missing rules in the package merge definition and suggest corrections. Then, we formalize package merge and analyze it with respect to some desirable properties. Our analyses employs Alloy, a first-order modelling language with tool support, and concepts from mathematical logic which allow us to develop a general taxonomy of package extension mechanisms. The analyses reveal the unexpected failure of important properties.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('197','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_197\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" title=\"http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-007-0073-9\" title=\"Follow DOI:10.1007\/s10270-007-0073-9\" target=\"_blank\">doi:10.1007\/s10270-007-0073-9<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('197','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Crane, Michelle L;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('222','tp_links')\" style=\"cursor:pointer;\">UML vs. Classical vs. Rhapsody statecharts: not all models are created equal<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 6, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 415-435, <\/span><span class=\"tp_pub_additional_year\">2007<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_222\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('222','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_222\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('222','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_222\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DBLP:journals\/sosym\/CraneD07,<br \/>\r\ntitle = {UML vs. Classical vs. Rhapsody statecharts: not all models are created equal},<br \/>\r\nauthor = {Michelle L Crane and Juergen Dingel},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-006-0042-8},<br \/>\r\ndoi = {10.1007\/s10270-006-0042-8},<br \/>\r\nyear  = {2007},<br \/>\r\ndate = {2007-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {6},<br \/>\r\nnumber = {4},<br \/>\r\npages = {415-435},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('222','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_222\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-006-0042-8\" title=\"https:\/\/doi.org\/10.1007\/s10270-006-0042-8\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-006-0042-8<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-006-0042-8\" title=\"Follow DOI:10.1007\/s10270-006-0042-8\" target=\"_blank\">doi:10.1007\/s10270-006-0042-8<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('222','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Crane, Michelle L;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('221','tp_links')\" style=\"cursor:pointer;\">UML vs. Classical vs. Rhapsody statecharts: not all models are created equal<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Software and Systems Modeling, <\/span><span class=\"tp_pub_additional_volume\">vol. 6, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 415-435, <\/span><span class=\"tp_pub_additional_year\">2007<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_221\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('221','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_221\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('221','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_221\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{DBLP:journals\/sosym\/CraneD07b,<br \/>\r\ntitle = {UML vs. Classical vs. Rhapsody statecharts: not all models are created equal},<br \/>\r\nauthor = {Michelle L Crane and Juergen Dingel},<br \/>\r\nurl = {https:\/\/doi.org\/10.1007\/s10270-006-0042-8},<br \/>\r\ndoi = {10.1007\/s10270-006-0042-8},<br \/>\r\nyear  = {2007},<br \/>\r\ndate = {2007-01-01},<br \/>\r\njournal = {Software and Systems Modeling},<br \/>\r\nvolume = {6},<br \/>\r\nnumber = {4},<br \/>\r\npages = {415-435},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('221','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_221\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/doi.org\/10.1007\/s10270-006-0042-8\" title=\"https:\/\/doi.org\/10.1007\/s10270-006-0042-8\" target=\"_blank\">https:\/\/doi.org\/10.1007\/s10270-006-0042-8<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s10270-006-0042-8\" title=\"Follow DOI:10.1007\/s10270-006-0042-8\" target=\"_blank\">doi:10.1007\/s10270-006-0042-8<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('221','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('244','tp_links')\" style=\"cursor:pointer;\">Compositional Analysis of C\/C++ Programs with VeriSoft<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Acta Informatica, <\/span><span class=\"tp_pub_additional_volume\">vol. 43, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 45-71, <\/span><span class=\"tp_pub_additional_year\">2006<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0001-5903<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_244\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('244','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_244\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('244','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_244\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel:2006:CAC:1148011.1148013b,<br \/>\r\ntitle = {Compositional Analysis of C\/C++ Programs with VeriSoft},<br \/>\r\nauthor = {Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x},<br \/>\r\ndoi = {10.1007\/s00236-006-0016-x},<br \/>\r\nissn = {0001-5903},<br \/>\r\nyear  = {2006},<br \/>\r\ndate = {2006-01-01},<br \/>\r\njournal = {Acta Informatica},<br \/>\r\nvolume = {43},<br \/>\r\nnumber = {1},<br \/>\r\npages = {45-71},<br \/>\r\npublisher = {Springer},<br \/>\r\naddress = {Secaucus, NJ, USA},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('244','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_244\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" title=\"http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" title=\"Follow DOI:10.1007\/s00236-006-0016-x\" target=\"_blank\">doi:10.1007\/s00236-006-0016-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('244','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Zhang, Hongyu;  Bradbury, Jeremy S;  Cordy, James R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('243','tp_links')\" style=\"cursor:pointer;\">Using source transformation to test and model check implicit-invocation systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Science of Computer Programming, <\/span><span class=\"tp_pub_additional_volume\">vol. 62, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 209 - 227, <\/span><span class=\"tp_pub_additional_year\">2006<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0167-6423<\/span><span class=\"tp_pub_additional_note\">, (Special issue on Source code analysis and manipulation (SCAM 2005))<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_243\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('243','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_243\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('243','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_243\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{ZHANG2006209b,<br \/>\r\ntitle = {Using source transformation to test and model check implicit-invocation systems},<br \/>\r\nauthor = {Hongyu Zhang and Jeremy S Bradbury and James R Cordy and Juergen Dingel},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008},<br \/>\r\nissn = {0167-6423},<br \/>\r\nyear  = {2006},<br \/>\r\ndate = {2006-01-01},<br \/>\r\njournal = {Science of Computer Programming},<br \/>\r\nvolume = {62},<br \/>\r\nnumber = {3},<br \/>\r\npages = {209 - 227},<br \/>\r\nnote = {Special issue on Source code analysis and manipulation (SCAM 2005)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('243','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_243\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('243','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('239','tp_links')\" style=\"cursor:pointer;\">Compositional Analysis of C\/C++ Programs with VeriSoft<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Acta Informatica, <\/span><span class=\"tp_pub_additional_volume\">vol. 43, <\/span><span class=\"tp_pub_additional_number\">no. 1, <\/span><span class=\"tp_pub_additional_pages\">pp. 45-71, <\/span><span class=\"tp_pub_additional_year\">2006<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0001-5903<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_239\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('239','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_239\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('239','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_239\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel:2006:CAC:1148011.1148013,<br \/>\r\ntitle = {Compositional Analysis of C\/C++ Programs with VeriSoft},<br \/>\r\nauthor = {Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x},<br \/>\r\ndoi = {10.1007\/s00236-006-0016-x},<br \/>\r\nissn = {0001-5903},<br \/>\r\nyear  = {2006},<br \/>\r\ndate = {2006-01-01},<br \/>\r\njournal = {Acta Informatica},<br \/>\r\nvolume = {43},<br \/>\r\nnumber = {1},<br \/>\r\npages = {45-71},<br \/>\r\npublisher = {Springer},<br \/>\r\naddress = {Secaucus, NJ, USA},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('239','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_239\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" title=\"http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s00236-006-0016-x\" title=\"Follow DOI:10.1007\/s00236-006-0016-x\" target=\"_blank\">doi:10.1007\/s00236-006-0016-x<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('239','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Zhang, Hongyu;  Bradbury, Jeremy S;  Cordy, James R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('237','tp_links')\" style=\"cursor:pointer;\">Using source transformation to test and model check implicit-invocation systems<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Science of Computer Programming, <\/span><span class=\"tp_pub_additional_volume\">vol. 62, <\/span><span class=\"tp_pub_additional_number\">no. 3, <\/span><span class=\"tp_pub_additional_pages\">pp. 209 - 227, <\/span><span class=\"tp_pub_additional_year\">2006<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 0167-6423<\/span><span class=\"tp_pub_additional_note\">, (Special issue on Source code analysis and manipulation (SCAM 2005))<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_237\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('237','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_237\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('237','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_237\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{ZHANG2006209,<br \/>\r\ntitle = {Using source transformation to test and model check implicit-invocation systems},<br \/>\r\nauthor = {Hongyu Zhang and Jeremy S Bradbury and James R Cordy and Juergen Dingel},<br \/>\r\nurl = {http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955},<br \/>\r\ndoi = {http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008},<br \/>\r\nissn = {0167-6423},<br \/>\r\nyear  = {2006},<br \/>\r\ndate = {2006-01-01},<br \/>\r\njournal = {Science of Computer Programming},<br \/>\r\nvolume = {62},<br \/>\r\nnumber = {3},<br \/>\r\npages = {209 - 227},<br \/>\r\nnote = {Special issue on Source code analysis and manipulation (SCAM 2005)},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('237','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_237\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955\" title=\"http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955\" target=\"_blank\">http:\/\/www.sciencedirect.com\/science\/article\/pii\/S0167642306000955<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008\" title=\"Follow DOI:http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008\" target=\"_blank\">doi:http:\/\/dx.doi.org\/10.1016\/j.scico.2006.04.008<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('237','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Cassidy, Timothy;  Cordy, James R;  Dean, Thomas R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('254','tp_links')\" style=\"cursor:pointer;\">Source Transformation for Concurrency Analysis<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Electron. Notes Theor. Comput. Sci., <\/span><span class=\"tp_pub_additional_volume\">vol. 141, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 57-75, <\/span><span class=\"tp_pub_additional_year\">2005<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1571-0661<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_254\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('254','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_254\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('254','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_254\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Cassidy:2005:STC:1705513.1705661b,<br \/>\r\ntitle = {Source Transformation for Concurrency Analysis},<br \/>\r\nauthor = {Timothy Cassidy and James R Cordy and Thomas R Dean and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012},<br \/>\r\ndoi = {10.1016\/j.entcs.2005.05.012},<br \/>\r\nissn = {1571-0661},<br \/>\r\nyear  = {2005},<br \/>\r\ndate = {2005-01-01},<br \/>\r\njournal = {Electron. Notes Theor. Comput. Sci.},<br \/>\r\nvolume = {141},<br \/>\r\nnumber = {4},<br \/>\r\npages = {57-75},<br \/>\r\npublisher = {Elsevier},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('254','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_254\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" title=\"http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" target=\"_blank\">http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" title=\"Follow DOI:10.1016\/j.entcs.2005.05.012\" target=\"_blank\">doi:10.1016\/j.entcs.2005.05.012<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('254','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Cassidy, Timothy;  Cordy, James R;  Dean, Thomas R;  Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('251','tp_links')\" style=\"cursor:pointer;\">Source Transformation for Concurrency Analysis<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Electron. Notes Theor. Comput. Sci., <\/span><span class=\"tp_pub_additional_volume\">vol. 141, <\/span><span class=\"tp_pub_additional_number\">no. 4, <\/span><span class=\"tp_pub_additional_pages\">pp. 57-75, <\/span><span class=\"tp_pub_additional_year\">2005<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1571-0661<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_resource_link\"><a id=\"tp_links_sh_251\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('251','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_251\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('251','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_251\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Cassidy:2005:STC:1705513.1705661,<br \/>\r\ntitle = {Source Transformation for Concurrency Analysis},<br \/>\r\nauthor = {Timothy Cassidy and James R Cordy and Thomas R Dean and Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012},<br \/>\r\ndoi = {10.1016\/j.entcs.2005.05.012},<br \/>\r\nissn = {1571-0661},<br \/>\r\nyear  = {2005},<br \/>\r\ndate = {2005-01-01},<br \/>\r\njournal = {Electron. Notes Theor. Comput. Sci.},<br \/>\r\nvolume = {141},<br \/>\r\nnumber = {4},<br \/>\r\npages = {57-75},<br \/>\r\npublisher = {Elsevier},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('251','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_251\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" title=\"http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" target=\"_blank\">http:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1016\/j.entcs.2005.05.012\" title=\"Follow DOI:10.1016\/j.entcs.2005.05.012\" target=\"_blank\">doi:10.1016\/j.entcs.2005.05.012<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('251','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('268','tp_links')\" style=\"cursor:pointer;\">A Refinement Calculus for Shared-Variable Parallel and Distributed Programming<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Formal Aspects of Computing, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 2, <\/span><span class=\"tp_pub_additional_pages\">pp. 123-197, <\/span><span class=\"tp_pub_additional_year\">2002<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1433-299X<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_268\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('268','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_268\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('268','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_268\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('268','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_268\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel2002b,<br \/>\r\ntitle = {A Refinement Calculus for Shared-Variable Parallel and Distributed Programming},<br \/>\r\nauthor = {Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s001650200032},<br \/>\r\ndoi = {10.1007\/s001650200032},<br \/>\r\nissn = {1433-299X},<br \/>\r\nyear  = {2002},<br \/>\r\ndate = {2002-12-01},<br \/>\r\njournal = {Formal Aspects of Computing},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {2},<br \/>\r\npages = {123-197},<br \/>\r\nabstract = {Parallel computers have not yet had the expected impact on mainstream computing. Parallelism adds a level of complexity to the programming task that makes it very error-prone. Moreover, a large variety of very different parallel architectures exists. Porting an implementation from one machine to another may require substantial changes. This paper addresses some of these problems by developing a formal basis for the design of parallel programs in the form of a refinement calculus. The calculus allows the stepwise formal derivation of an abstract, low-level implementation from a trusted, high-level specification. The calculus thus helps structuring and documenting the development process. Portability is increased, because the introduction of a machine-dependent feature can be located in the refinement tree. Development efforts above this point in the tree are independent of that feature and are thus reusable. Moreover, the discovery of new, possibly more efficient solutions is facilitated. Last but not least, programs are correct by construction, which obviates the need for difficult debugging. Our programming\/specification notation supports fair parallelism, shared-variable and message-passing concurrency, local variables and channels. The calculus rests on a compositional trace semantics that treats shared-variable and message-passing concurrency uniformly. The refinement relation combines a context-sensitive notion of trace inclusion and assumption-commitment reasoning to achieve compositionality. The calculus straddles both concurrency paradigms, that is, a shared-variable program can be refined into a distributed, message-passing program and vice versa.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('268','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_268\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Parallel computers have not yet had the expected impact on mainstream computing. Parallelism adds a level of complexity to the programming task that makes it very error-prone. Moreover, a large variety of very different parallel architectures exists. Porting an implementation from one machine to another may require substantial changes. This paper addresses some of these problems by developing a formal basis for the design of parallel programs in the form of a refinement calculus. The calculus allows the stepwise formal derivation of an abstract, low-level implementation from a trusted, high-level specification. The calculus thus helps structuring and documenting the development process. Portability is increased, because the introduction of a machine-dependent feature can be located in the refinement tree. Development efforts above this point in the tree are independent of that feature and are thus reusable. Moreover, the discovery of new, possibly more efficient solutions is facilitated. Last but not least, programs are correct by construction, which obviates the need for difficult debugging. Our programming\/specification notation supports fair parallelism, shared-variable and message-passing concurrency, local variables and channels. The calculus rests on a compositional trace semantics that treats shared-variable and message-passing concurrency uniformly. The refinement relation combines a context-sensitive notion of trace inclusion and assumption-commitment reasoning to achieve compositionality. The calculus straddles both concurrency paradigms, that is, a shared-variable program can be refined into a distributed, message-passing program and vice versa.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('268','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_268\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s001650200032\" title=\"http:\/\/dx.doi.org\/10.1007\/s001650200032\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s001650200032<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s001650200032\" title=\"Follow DOI:10.1007\/s001650200032\" target=\"_blank\">doi:10.1007\/s001650200032<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('268','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><div class=\"tp_publication tp_publication_article\"><div class=\"tp_pub_info\"><p class=\"tp_pub_author\"> Dingel, Juergen<\/p><p class=\"tp_pub_title\"><a class=\"tp_title_link\" onclick=\"teachpress_pub_showhide('267','tp_links')\" style=\"cursor:pointer;\">A Refinement Calculus for Shared-Variable Parallel and Distributed Programming<\/a> <span class=\"tp_pub_type tp_  article\">Journal Article<\/span> <\/p><p class=\"tp_pub_additional\"><span class=\"tp_pub_additional_in\">In: <\/span><span class=\"tp_pub_additional_journal\">Formal Aspects of Computing, <\/span><span class=\"tp_pub_additional_volume\">vol. 14, <\/span><span class=\"tp_pub_additional_number\">no. 2, <\/span><span class=\"tp_pub_additional_pages\">pp. 123-197, <\/span><span class=\"tp_pub_additional_year\">2002<\/span>, <span class=\"tp_pub_additional_issn\">ISSN: 1433-299X<\/span>.<\/p><p class=\"tp_pub_menu\"><span class=\"tp_abstract_link\"><a id=\"tp_abstract_sh_267\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('267','tp_abstract')\" title=\"Show abstract\" style=\"cursor:pointer;\">Abstract<\/a><\/span> | <span class=\"tp_resource_link\"><a id=\"tp_links_sh_267\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('267','tp_links')\" title=\"Show links and resources\" style=\"cursor:pointer;\">Links<\/a><\/span> | <span class=\"tp_bibtex_link\"><a id=\"tp_bibtex_sh_267\" class=\"tp_show\" onclick=\"teachpress_pub_showhide('267','tp_bibtex')\" title=\"Show BibTeX entry\" style=\"cursor:pointer;\">BibTeX<\/a><\/span><\/p><div class=\"tp_bibtex\" id=\"tp_bibtex_267\" style=\"display:none;\"><div class=\"tp_bibtex_entry\"><pre>@article{Dingel2002,<br \/>\r\ntitle = {A Refinement Calculus for Shared-Variable Parallel and Distributed Programming},<br \/>\r\nauthor = {Juergen Dingel},<br \/>\r\nurl = {http:\/\/dx.doi.org\/10.1007\/s001650200032},<br \/>\r\ndoi = {10.1007\/s001650200032},<br \/>\r\nissn = {1433-299X},<br \/>\r\nyear  = {2002},<br \/>\r\ndate = {2002-12-01},<br \/>\r\njournal = {Formal Aspects of Computing},<br \/>\r\nvolume = {14},<br \/>\r\nnumber = {2},<br \/>\r\npages = {123-197},<br \/>\r\nabstract = {Parallel computers have not yet had the expected impact on mainstream computing. Parallelism adds a level of complexity to the programming task that makes it very error-prone. Moreover, a large variety of very different parallel architectures exists. Porting an implementation from one machine to another may require substantial changes. This paper addresses some of these problems by developing a formal basis for the design of parallel programs in the form of a refinement calculus. The calculus allows the stepwise formal derivation of an abstract, low-level implementation from a trusted, high-level specification. The calculus thus helps structuring and documenting the development process. Portability is increased, because the introduction of a machine-dependent feature can be located in the refinement tree. Development efforts above this point in the tree are independent of that feature and are thus reusable. Moreover, the discovery of new, possibly more efficient solutions is facilitated. Last but not least, programs are correct by construction, which obviates the need for difficult debugging. Our programming\/specification notation supports fair parallelism, shared-variable and message-passing concurrency, local variables and channels. The calculus rests on a compositional trace semantics that treats shared-variable and message-passing concurrency uniformly. The refinement relation combines a context-sensitive notion of trace inclusion and assumption-commitment reasoning to achieve compositionality. The calculus straddles both concurrency paradigms, that is, a shared-variable program can be refined into a distributed, message-passing program and vice versa.},<br \/>\r\nkeywords = {},<br \/>\r\npubstate = {published},<br \/>\r\ntppubtype = {article}<br \/>\r\n}<br \/>\r\n<\/pre><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('267','tp_bibtex')\">Close<\/a><\/p><\/div><div class=\"tp_abstract\" id=\"tp_abstract_267\" style=\"display:none;\"><div class=\"tp_abstract_entry\">Parallel computers have not yet had the expected impact on mainstream computing. Parallelism adds a level of complexity to the programming task that makes it very error-prone. Moreover, a large variety of very different parallel architectures exists. Porting an implementation from one machine to another may require substantial changes. This paper addresses some of these problems by developing a formal basis for the design of parallel programs in the form of a refinement calculus. The calculus allows the stepwise formal derivation of an abstract, low-level implementation from a trusted, high-level specification. The calculus thus helps structuring and documenting the development process. Portability is increased, because the introduction of a machine-dependent feature can be located in the refinement tree. Development efforts above this point in the tree are independent of that feature and are thus reusable. Moreover, the discovery of new, possibly more efficient solutions is facilitated. Last but not least, programs are correct by construction, which obviates the need for difficult debugging. Our programming\/specification notation supports fair parallelism, shared-variable and message-passing concurrency, local variables and channels. The calculus rests on a compositional trace semantics that treats shared-variable and message-passing concurrency uniformly. The refinement relation combines a context-sensitive notion of trace inclusion and assumption-commitment reasoning to achieve compositionality. The calculus straddles both concurrency paradigms, that is, a shared-variable program can be refined into a distributed, message-passing program and vice versa.<\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('267','tp_abstract')\">Close<\/a><\/p><\/div><div class=\"tp_links\" id=\"tp_links_267\" style=\"display:none;\"><div class=\"tp_links_entry\"><ul class=\"tp_pub_list\"><li><i class=\"fas fa-globe\"><\/i><a class=\"tp_pub_list\" href=\"http:\/\/dx.doi.org\/10.1007\/s001650200032\" title=\"http:\/\/dx.doi.org\/10.1007\/s001650200032\" target=\"_blank\">http:\/\/dx.doi.org\/10.1007\/s001650200032<\/a><\/li><li><i class=\"ai ai-doi\"><\/i><a class=\"tp_pub_list\" href=\"https:\/\/dx.doi.org\/10.1007\/s001650200032\" title=\"Follow DOI:10.1007\/s001650200032\" target=\"_blank\">doi:10.1007\/s001650200032<\/a><\/li><\/ul><\/div><p class=\"tp_close_menu\"><a class=\"tp_close\" onclick=\"teachpress_pub_showhide('267','tp_links')\">Close<\/a><\/p><\/div><\/div><\/div><\/div><\/div>\n\n\n\n<p><\/p>\n","protected":false},"excerpt":{"rendered":"<p>View publications by: year | type Most publications prior to 2021 are listed below. For an up-to-date list that also [&hellip;]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":13,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_acf_changed":false,"_uag_custom_page_level_css":"","site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"class_list":["post-96","page","type-page","status-publish","hentry"],"acf":[],"spectra_custom_meta":{"_edit_last":["2"],"_wp_page_template":["default"],"_edit_lock":["1736963350:2"],"_uag_page_assets":["a:9:{s:3:\"css\";s:263:\".uag-blocks-common-selector{z-index:var(--z-index-desktop) !important}@media (max-width: 976px){.uag-blocks-common-selector{z-index:var(--z-index-tablet) !important}}@media (max-width: 767px){.uag-blocks-common-selector{z-index:var(--z-index-mobile) !important}}\n\";s:2:\"js\";s:0:\"\";s:18:\"current_block_list\";a:11:{i:0;s:14:\"core\/paragraph\";i:1;s:14:\"core\/shortcode\";i:2;s:11:\"core\/search\";i:3;s:10:\"core\/group\";i:4;s:12:\"core\/heading\";i:5;s:17:\"core\/latest-posts\";i:6;s:20:\"core\/latest-comments\";i:7;s:13:\"core\/archives\";i:8;s:15:\"core\/categories\";i:9;s:12:\"core\/columns\";i:10;s:11:\"core\/column\";}s:8:\"uag_flag\";b:0;s:11:\"uag_version\";s:10:\"1761579844\";s:6:\"gfonts\";a:0:{}s:10:\"gfonts_url\";s:0:\"\";s:12:\"gfonts_files\";a:0:{}s:14:\"uag_faq_layout\";b:0;}"],"_uag_css_file_name":["uag-css-96.css"]},"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Doug Martin","author_link":"https:\/\/labs.cs.queensu.ca\/mase\/author\/dm70\/"},"uagb_comment_info":0,"uagb_excerpt":"View publications by: year | type Most publications prior to 2021 are listed below. For an up-to-date list that also [&hellip;]","_links":{"self":[{"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/pages\/96","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/comments?post=96"}],"version-history":[{"count":2,"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/pages\/96\/revisions"}],"predecessor-version":[{"id":381,"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/pages\/96\/revisions\/381"}],"up":[{"embeddable":true,"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/pages\/13"}],"wp:attachment":[{"href":"https:\/\/labs.cs.queensu.ca\/mase\/wp-json\/wp\/v2\/media?parent=96"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}