- mojtaba@cs.queensu.ca
- Website
- Profile
- Mojtaba Bagherzadeh is a PhD candidate in the School of Computing at Queen’s University, in Canada. He obtained his Masters in E-commerce and Bachelors in software engineering. Mojtaba has several years of experience working as a software developer at IBM and leader at a startup company. His research areas of interest are real-time systems design, software analysis, and model-driven development.
- Featured publications
Bagherzadeh, Mojtaba; Kahani, Nafiseh; Bezemer, Cor-Paul; Hassan, Ahmed E; Dingel, Juergen; Cordy, James R
Analyzing a Decade of Linux System Calls Journal Article
In: Empirical Software Engineering Journal, vol. 23, no. 3, pp. 1519-1551, 2018.
@article{BKBHDC18,
title = {Analyzing a Decade of Linux System Calls},
author = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},
url = {https://doi.org/10.1007/s10664-017-9551-z},
doi = {10.1007/s10664-017-9551-z},
year = {2018},
date = {2018-06-01},
journal = {Empirical Software Engineering Journal},
volume = {23},
number = {3},
pages = {1519-1551},
publisher = {Springer},
abstract = {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.
The 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.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}
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.
The 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.Bagherzadeh, Mojtaba; Kahani, Nafiseh; Bezemer, Cor-Paul; Hassan, Ahmed E; Dingel, Juergen; Cordy, James R
Analyzing a Decade of Linux System Calls Journal Article
In: Empirical Software Engineering Journal, vol. 23, no. 3, pp. 1519-1551, 2018.
@article{BKBHDC18b,
title = {Analyzing a Decade of Linux System Calls},
author = {Mojtaba Bagherzadeh and Nafiseh Kahani and Cor-Paul Bezemer and Ahmed E Hassan and Juergen Dingel and James R Cordy},
url = {https://doi.org/10.1007/s10664-017-9551-z},
doi = {10.1007/s10664-017-9551-z},
year = {2018},
date = {2018-06-01},
journal = {Empirical Software Engineering Journal},
volume = {23},
number = {3},
pages = {1519-1551},
publisher = {Springer},
abstract = {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.
The 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.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}
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.
The 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.Bagherzadeh, Mojtaba; Hili, Nicolas; Seekatz, David; Dingel, Juergen
MDebugger: A Model-level Debugger for UML-RT Proceedings Article
In: 40th International Conference on Software Engineering (ICSE'18): Companion Proceedings, pp. 4, Gothenburg, Sweden, 2018.
@inproceedings{BHSD18,
title = {MDebugger: A Model-level Debugger for UML-RT},
author = {Mojtaba Bagherzadeh and Nicolas Hili and David Seekatz and Juergen Dingel},
url = {https://dl.acm.org/citation.cfm?id=3183440.3183473, paper
https://github.com/moji1/MDebugger, code
https://www.youtube.com/watch?v=L0JDn8eczwQ, video},
year = {2018},
date = {2018-05-01},
booktitle = {40th International Conference on Software Engineering (ICSE'18): Companion Proceedings},
pages = {4},
address = {Gothenburg, Sweden},
abstract = {Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.Bagherzadeh, Mojtaba; Hili, Nicolas; Seekatz, David; Dingel, Juergen
MDebugger: A Model-level Debugger for UML-RT Proceedings Article
In: 40th International Conference on Software Engineering (ICSE'18): Companion Proceedings, pp. 4, Gothenburg, Sweden, 2018.
@inproceedings{BHSD18b,
title = {MDebugger: A Model-level Debugger for UML-RT},
author = {Mojtaba Bagherzadeh and Nicolas Hili and David Seekatz and Juergen Dingel},
url = {https://dl.acm.org/citation.cfm?id=3183440.3183473, paper
https://github.com/moji1/MDebugger, code https://www.youtube.com/watch?v=L0JDn8eczwQ, video},
year = {2018},
date = {2018-05-01},
booktitle = {40th International Conference on Software Engineering (ICSE'18): Companion Proceedings},
pages = {4},
address = {Gothenburg, Sweden},
abstract = {Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.Bagherzadeh, Mojtaba; Hili, Nicolas; Dingel, Juergen
Model-Level, Platform-Independent Debugging In The Context Of The Model-Driven Development Of Real-time Systems Proceedings Article
In: 11th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'17), Paderborn, Germany. September 04-08, 2017, 2017.
@inproceedings{Bhd17,
title = {Model-Level, Platform-Independent Debugging In The Context Of The Model-Driven Development Of Real-time Systems},
author = {Mojtaba Bagherzadeh and Nicolas Hili and Juergen Dingel},
url = {https://dl.acm.org/citation.cfm?id=3106278, paper
https://github.com/moji1/MDebugger, code},
doi = {10.1145/3106237.3106278},
year = {2017},
date = {2017-01-01},
booktitle = {11th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'17)},
address = {Paderborn, Germany. September 04-08, 2017},
series = {ESEC/FSE'17},
abstract = {Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.Bagherzadeh, Mojtaba; Hili, Nicolas; Dingel, Juergen
Model-Level, Platform-Independent Debugging In The Context Of The Model-Driven Development Of Real-time Systems Proceedings Article
In: 11th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'17), Paderborn, Germany. September 04-08, 2017, 2017.
@inproceedings{Bhd17b,
title = {Model-Level, Platform-Independent Debugging In The Context Of The Model-Driven Development Of Real-time Systems},
author = {Mojtaba Bagherzadeh and Nicolas Hili and Juergen Dingel},
url = {https://dl.acm.org/citation.cfm?id=3106278, paper
https://github.com/moji1/MDebugger, code},
doi = {10.1145/3106237.3106278},
year = {2017},
date = {2017-01-01},
booktitle = {11th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'17)},
address = {Paderborn, Germany. September 04-08, 2017},
series = {ESEC/FSE'17},
abstract = {Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
Providing proper support for debugging models at model-level is one of the main barriers to a broader adoption of Model Driven Development (MDD). In this paper, we focus on the use of MDD for the development of real-time embedded systems (RTE). We introduce a new platform-independent approach to implement model-level debuggers. We describe how to realize support for model-level debugging entirely in terms of the modeling language and show how to implement this support in terms of a model-to-model transformation. Key advantages of the approach over existing work are that (1) it does not require a program debugger for the code generated from the model, and that (2) any changes to, e.g., the code generator, the target language, or the hardware platform leave the debugger completely unaffected. We also describe an implementation of the approach in the context of Papyrus-RT, an open source MDD tool based on the modeling language UML-RT. We summarize the results of the use of our model-based debugger on several use cases to determine its overhead in terms of size and performance. Despite being a prototype, the performance overhead is in the order of microseconds, while the size overhead is comparable with that of GDB, the GNU Debugger.Das, Nondini; Ganesan, Suchita; Jweda, Leo; Bagherzadeh, Mojtaba; Hili, Nicolas; Dingel, Juergen
Supporting the Model-driven Development of Real-time Embedded Systems with Run-time Monitoring and Animation via Highly Customizable Code Generation Proceedings Article
In: ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS'16), pp. 36-43, ACM, Saint-Malo, France. October 2-7, 2016, 2016, ISBN: 978-1-4503-4321-3.
@inproceedings{Das:2016:SMD:2976767.2976781,
title = {Supporting the Model-driven Development of Real-time Embedded Systems with Run-time Monitoring and Animation via Highly Customizable Code Generation},
author = {Nondini Das and Suchita Ganesan and Leo Jweda and Mojtaba Bagherzadeh and Nicolas Hili and Juergen Dingel},
url = {http://doi.acm.org/10.1145/2976767.2976781},
doi = {10.1145/2976767.2976781},
isbn = {978-1-4503-4321-3},
year = {2016},
date = {2016-01-01},
booktitle = {ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS'16)},
pages = {36-43},
publisher = {ACM},
address = {Saint-Malo, France. October 2-7, 2016},
series = {MODELS'16},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
Das, Nondini; Ganesan, Suchita; Jweda, Leo; Bagherzadeh, Mojtaba; Hili, Nicolas; Dingel, Juergen
Supporting the Model-driven Development of Real-time Embedded Systems with Run-time Monitoring and Animation via Highly Customizable Code Generation Proceedings Article
In: ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS'16), pp. 36-43, ACM, Saint-Malo, France. October 2-7, 2016, 2016, ISBN: 978-1-4503-4321-3.
@inproceedings{Das:2016:SMD:2976767.2976781b,
title = {Supporting the Model-driven Development of Real-time Embedded Systems with Run-time Monitoring and Animation via Highly Customizable Code Generation},
author = {Nondini Das and Suchita Ganesan and Leo Jweda and Mojtaba Bagherzadeh and Nicolas Hili and Juergen Dingel},
url = {http://doi.acm.org/10.1145/2976767.2976781},
doi = {10.1145/2976767.2976781},
isbn = {978-1-4503-4321-3},
year = {2016},
date = {2016-01-01},
booktitle = {ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS'16)},
pages = {36-43},
publisher = {ACM},
address = {Saint-Malo, France. October 2-7, 2016},
series = {MODELS'16},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}
- full list of publications
- Teaching
EEE499 - Real-Time Embedded System Design