Re: [escet-dev] Chi vs POOSL

["Hofkamp, Albert" <A.T.Hofkamp@xxxxxx>]

Interesting!

Thanks for all the information.

I pondered a bit about this, and came up with the following lists

poosl

• aims for designing a system as a static collection of sub-systems using pairwise synchronous communication
• simulate/debug decomposed system
• uses OO data.
• uses processes in an imperative language with some implementation-oriented primitives (interrupt, interleaved task)
• has test capabilities
• extensive IDE integration, debugging + visualization features

chi

• traditionally aims for modelling system of systems for investigating performance.
• uses structured data (elementary types + composition)
• typically high level models with relatively simple data
  
• imperative language with pairwise synchronous communication
  
• ​dynamic processes
  

cif

• aims to design a system as a static collection of sub-systems using multi-party synchronization with optional pairwise communication
• uses structured data (elementary types + composition)
• uses processes in a synchronization language
• has transformations to convert to other specifications / implementations
• simulate decomposed system
  

I believe you can use chi for designing a decomposition of a system like poosl. Data will be a little different but nothing major, implementation oriented primitives will need a more explicit switch point but arguably poosl just allows hiding that decision until somewhere further in the design process.

The strong point for chi is its dynamic processes. Whether that is useful depends on your application.

cif and poosl seem much closer, cif is somewhat more abstract with multi-party synchronization while poosl leans closer towards implementation and made choices with more familiar notations for engineers like imperative language and OO for data. Interestingly they don't push forward towards implementation it seems.

The difference in aim is perhaps that cif is more oriented towards formal methods while poosl is more a practical design tool. I would expect that poosl works better with data-intensive systems.

What I found interesting is that poosl seems to be shopping around for other projects to include, cooperate with commercial partners, and is more actively working on building a community even though they aren't eclipse-standard compliant yet.

As for simulation speed, I have only seen claims that they are fast but nothing otherwise. The fact that we don't advertise the tools as fast doesn't imply we're slow. We might just consider correctness more important than raw simulation speed.

---

From: escet-dev <escet-dev-bounces@xxxxxxxxxxx> on behalf of Dennis Hendriks <dh_tue@xxxxxxxxxxx>
Sent: Sunday, November 14, 2021 20:32
To: escet developer discussions <escet-dev@xxxxxxxxxxx>
Subject: Re: [escet-dev] Chi vs POOSL

 

Hi all,

The EclipseCon'21 POOSL video is now online. See https://www.youtube.com/watch?v=yB9ruWw5vig

Dennis

---

Van: Dennis Hendriks <dh_tue@xxxxxxxxxxx>
Verzonden: maandag 1 november 2021 14:49
Aan: escet developer discussions <escet-dev@xxxxxxxxxxx>
Onderwerp: Chi vs POOSL

 

Hi all,

As of October 20 there is a new Eclipse project: Eclipse POOSL. While I'm not an expert on POOSL or Chi, I see many similarities between the two, and some differences (the list is very likely not complete):

• Both originate from the Eindhoven University of Technology (TU/e), although from different departments.
• Both offer simulation and analysis of discrete event systems in early design/development stages, although they can be applied more generally. (see also https://gitlab.eclipse.org/eclipse/escet/escet/-/issues/35#note_244581 for a discussion we recently had on this for Chi)
• Both languages are based on parallel processes, use channels ('!' for send and '?' for receive from a channel), have sequence/choice/parallel, have 'delay' statements, etc.
• Chi offers dynamic process creation and processes/channels as data, while POOSL does not.
• Chi has built-in experiment support, while POOSL does not.
• Chi is statically typed, while POOSL is dynamically typed.
• POOSL has OO concepts (processes with data and methods) and inheritance of data types and processes, while Chi does not.
• POOSL has extensive IDE integration (graphical editor, debug integration, etc), while Chi offers less integration.
• POOSL has interrupt and abort statements, while Chi does not.
• POOSL seems to have a large focus on highly-scalable and fast simulation, maybe more so than Chi, but I'm not sure.

Some resources on POOSL:

• https://projects.eclipse.org/projects/modeling.poosl
• https://projects.eclipse.org/projects/modeling.poosl/reviews/creation-review
• https://www.es.ele.tue.nl/poosl/
• https://esi.nl/research/output/tools/poosl
  
• https://www.eclipsecon.org/2021/sessions/dive-poosl-simulate-your-systems (presentations from EclipseCon 2021 are not yet online, but they will be available soon I think)

I wonder how we look at the relation between the POOSL and Chi languages/tools?

Dennis

Disclaimer: POOSL, particularly the POOSL IDE, was developed not just by TU/e, but also by some of my colleagues at ESI (TNO).