@InProceedings{Khomenko2011,
  author =	 {Khomenko, Victor},
  title =	 {Unfolding Models of Asynchronous Systems: Applications to
                  Analysis and Synthesis},
  crossref =	 {|PNSE2011},
  pages =	 {9-9},
  year =	 2011,
  abstract =	 {Analysis and synthesis of concurrent systems suffers
                  from combinatorial state space explosion.  That is, even
                  a relatively small system specification can (and often
                  does) yield a very large state space.  One of the
                  prominent techniques for alleviating this problem is
                  based on complete prefixes of Petri net unfoldings.  It
                  relies on the partial order view of concurrent
                  computation, and represents system states implicitly,
                  using an acyclic Petri net.  This talk describes
                  applications of the unfolding technique to analysis of
                  concurrent systems in general, and to verification and
                  synthesis of asynchronous circuits in particular.}
}

@InProceedings{Mazzara2011,
  author =	 {Mazzara, Manuel and Abouzaid, Faisal and Dragon, Nicola and
                  Bhattacharyya, Anirban},
  title =	 {Design, Modelling and Analysis of a Workflow
                  Reconfiguration},
  crossref =	 {|PNSE2011},
  pages =	 {10-24},
  year =	 2011,
  abstract = 	 {This paper describes a case study involving the
                  reconfiguration of an office workflow.  We state the
                  requirements on a system implementing the workflow and
                  its reconfiguration, and describe the system's design in
                  BPMN.  We then use an asynchronous $\pi$-calculus and
                  $Web\pi_{\infty}$ to model the design and to verify
                  whether or not it will meet the requirements.  In the
                  process, we evaluate the formalisms for their suitability
                  for the modelling and analysis of dynamic reconfiguration
                  of dependable systems.}
}

@InProceedings{Westergaard2011a,
  author =	 {Westergaard, Michael and Verbeek, H.M.W. (Eric)},
  title =	 {Efficient Implementation of Prioritized Transitions for
                  High-level {Petri} Nets},
  crossref =	 {|PNSE2011},
  pages =	 {27-41},
  year =	 2011,
  abstract = 	 {Transition priorities can be a useful mechanism when
                  modeling using Petri nets.  For example, high-priority
                  transitions can be used to model exception handling and
                  low-priority transitions can be used to model background
                  tasks that should only be executed when no other
                  transition is enabled.  Transition priorities can be
                  simulated in Petri nets using, e.\,g., inhibitor arcs,
                  but such constructs tend to unnecessarily clutter models,
                  making it useful to support priorities directly.

                  Computing the enabling of transitions in high-level Petri
                  nets is an expensive operation and should be avoided.  As
                  transition priorities introduce a nonlocal enabling
                  condition, at first sight this forces us to compute
                  enabling for all transitions in a highest-priority-first
                  order, but it is possible to do better.  Here we describe
                  our implementation of transition priorities in CPN Tools
                  3.0, where we minimize the number of enabling
                  computations.  We describe algorithms for executing
                  transitions at random, useful for automatic simulation
                  without user interactions, and for maintaining a set of
                  known enabled transitions, useful for interactive
                  user-guided simulation.  Experiments show that using our
                  algorithms we can execute $4-7$ million transitions a
                  minute for real-life models and more than $20$ million
                  transitions a minute for other models, a significant
                  improvement over the $1-5$ million transitions a minute
                  possible for simpler algorithms.}
}

@InProceedings{Kindler2011,
  author =	 {Kindler, Ekkart},
  title =	 {Modelling Local and Global Behaviour: {Petri} Nets and
                  Event Coordination},
  crossref =	 {|PNSE2011},
  pages =	 {42-56},
  year =	 2011,
  abstract = 	 {Today, it is possible to generate major parts of a
                  software system from models.  Most of the generated code,
                  however, concerns the structural parts of the software;
                  the parts that concern the functionality or behaviour of
                  a system are still programmed manually.  In order to
                  overcome this problem, we are developing the concept of
                  coordination diagrams that define the global
                  behaviour on top of structural software models.
                  Basically, these diagrams define how the local behaviour
                  of an element is coordinated with the behaviour of the
                  elements it is connected to.  The exact concepts of these
                  coordination diagrams and their notation is still under
                  development, but there exists a first prototype for
                  experimenting and for fine-tuning its features.  We call
                  it the Event Coordination Notation (ECNO).

                  For experimenting with the ECNO, we implemented also a
                  simple modelling notation for the local behaviour, which
                  is based on Petri nets.  In this paper, we briefly
                  discuss the general idea of the ECNO and then present
                  ECNO nets that define the local behaviour of
                  elements.  They are implemented as a Petri net type for
                  the ePNK tool, together with a code generator that
                  produces code that can be used in the ECNO framework and
                  runtime environment.  This way, all the behaviour of a
                  system can be modelled -- and code can be generated that
                  easily integrates with the structural models and existing
                  software.}
}

@InProceedings{Westergaard2011b,
  author =	 {Westergaard, Michael},
  title =	 {Towards Verifying Parallel Algorithms and Programs using
                  Coloured {Petri} Nets},
  crossref =	 {|PNSE2011},
  pages =	 {57-71},
  year =	 2011,
  abstract = 	 {Coloured Petri nets have proved to be a useful formalism
                  for modeling distributed algorithms, i.e., algorithms
                  where nodes communicate via message passing.  Here we
                  describe an approach for modeling parallel algorithms and
                  programs, i.e., algorithms and programs where processes
                  communicate via shared memory.  The model is verified for
                  correctness, here to prove absence of mutual exclusion
                  violations and to find dead- and live-locks.  The
                  approach can be used in a model-driven development
                  approach, where code is generated from a model, in a
                  model-extraction approach, where a model is extracted
                  from running code, or using a combination of the two,
                  supporting extracting a model from an abstract
                  description and generation of correct implementation
                  code.  We illustrate our idea by applying the technique
                  to a parallel implementation of explicit state-space
                  exploration.}
}

@InProceedings{Meski2011,
  author =	 {M{\k e}ski, Artur and P{\'o}{\l }rola, Agata and
                  Penczek, Wojciech and Wo{\'z}na-Szcze{\'s}niak, Bo{\.z}ena
                  and Zbrzezny, Andrzej},
  authorplain =	 {Meski, Artur and Polrola, Agata and
                  Penczek, Wojciech and Wozna-Szczesniak, Bozena
                  and Zbrzezny, Andrzej},
  title =	 {Bounded Model Checking Approaches for Verification of
                  Distributed Time {Petri} Nets},
  crossref =	 {|PNSE2011},
  pages =	 {72-91},
  year =	 2011,
  abstract = 	 {We consider two symbolic approaches to bounded model
                  checking (BMC) of distributed time Petri nets (DTPNs).
                  We focus on the properties expressed in Linear Temporal
                  Logic without the neXt-time operator (LTL-X) and the
                  existential fragment of Computation Tree Logic without
                  the neXt-time operator (ECTL-X).  We give a translation
                  of BMC to SAT and describe a BDD-based BMC for both LTL-X
                  and ECTL-X.  The two translations have been implemented,
                  tested, and compared with each other on two standard
                  benchmarks.  Our experimental results reveal the
                  advantages and disadvantages of both the approaches.}
}

@InProceedings{Hillah2011,
  author =	 {Hillah, Lom-Messan and Kordon, Fabrice and Lakos, Charles and
                  Petrucci, Laure},
  title =	 {Extending {PNML} Scope: the Prioritised {Petri} Nets
                  Experience},
  crossref =	 {|PNSE2011},
  pages =	 {92-106},
  year =	 2011,
  abstract = 	 {The Petri net standard ISO/IEC 15909 comprises 3 parts.
                  The first one defines the most used net types, the second
                  an interchange format for these --- both are published.
                  The third part deals with Petri net extensions, in
                  particular structuring mechanisms and the introduction of
                  additional, more elaborate net types within the standard.

                  This paper focuses on the latter issue: how should a new
                  net type be added, while guaranteeing the compatibility
                  with the current standard.  The extension of Petri nets
                  with static or dynamic priorities is studied, showing
                  design choices to ensure the desired compatibility.  The
                  result is integrated within the standard companion tool,
                  PNML Framework.  Then, the approach is generalised so as
                  to be used at a later stage for other Petri nets
                  extensions.}
}

@InProceedings{Choppy2011,
  author =	 {Choppy, Christine and Desel, J{\"o}rg and Petrucci, Laure},
  authorplain =	 {Choppy, Christine and Desel, Joerg and Petrucci, Laure},
  title =	 {Specialisation and Generalisation of Processes},
  crossref =	 {|PNSE2011},
  pages =	 {109-123},
  year =	 2011,
  abstract = 	 {In data modelling, one of the most important abstraction
                  concepts is specialisation, with generalisation being the
                  converse.  Although there are already some approaches to
                  define generalisation for process modelling as well,
                  there is no generally accepted notion of generalisation
                  for processes.

                  In this paper, we introduce a general definition of
                  process specialisation and generalisation.  Instead of
                  concentrating on a specific process description language,
                  we refer to labelled partial orders.  For most process
                  description languages, behaviour (if defined at all) can
                  be expressed by means of this formalism.  We distinguish
                  generalisation from aggregation, and specialisation from
                  instantiation.  For Petri nets, we provide examples  and
                  suggest associated notations.

                  Our generalisation notion captures various previous
                  approaches to generalisation, for example ignoring tasks,
                  allowing alternative tasks and deferring choices between
                  alternative tasks.  A general guideline is that a more
                  general process contains less features and/or less
                  information than a more specific one.

                  In the conclusion, we also consider the question of
                  common generalisation of a set of processes.  Finally, we
                  suggest a generalisation concept that goes beyond
                  labelled partial orders, including additional behavioural
                  constraints and process data generalisation.}
}

@InProceedings{Hewelt2011,
  author =	 {Hewelt, Marcin and Wagner, Thomas and Cabac, Lawrence},
  title =	 {Integrating Verification into the {PAOSE} Approach},
  crossref =	 {|PNSE2011},
  pages =	 {124-135},
  year =	 2011,
  abstract = 	 {The PAOSE approach to software engineering combines Petri
                  nets with the paradigm of agent-orientation and utilises
                  the agent metaphor to structure large software systems
                  and their development.  Up until now the PAOSE approach
                  only exhibited aspects of verification in a rudimentary
                  way.  This is due to the complexity of the systems to be
                  verified on the one hand, and the expressiveness of the
                  employed Petri net formalism of reference nets on the
                  other hand.  This contribution deals with enhancing the
                  tool support for PAOSE in this regard.

                  We present how we technically integrate the functionality
                  of LoLA, a sophisticated verification tool, into Renew,
                  the development and runtime environment that backs PAOSE.
                  Furthermore we sketch how structural aspects of
                  multi-agent systems developed with the agent framework of
                  Mulan can be exploited for verification.  The results of
                  the integration are applied in the context of distributed
                  network security for the Herold research project.}
}

@InProceedings{Wang2011,
  author =	 {Wang, Shengyuan and Wu, Weiyi and Zhang, Yao and Dong, Yuan},
  title =	 {Transitions as Transactions},
  crossref =	 {|PNSE2011},
  pages =	 {136-151},
  year =	 2011,
  abstract = 	 {As newly developed transactional memory technology has
                  received significant attention as a way to dramatically
                  simplify shared-memory concurrent programming, user-level
                  transactional concurrent programming models have become a
                  very interesting topic in the programming community.
                  However, the fact is that, in existing transactional
                  concurrent programming models, user-level mechanisms have
                  not been well developed.  The dilemma is how to make a
                  balance between the performance and correctness of a
                  program.  Explicit concurrency among cooperative
                  transactions can undoubtedly decrease the rate of
                  conflicts and improve the performance, but it is harmful
                  to the correctness.  In this paper, a transactional
                  concurrent programming approach, based on Petri nets, is
                  presented, which can easily specify concurrency among
                  transactions and do not aggravate programmers remarkably
                  in writing correct transactional concurrent programs.  In
                  this approach, a special Petri net system with transition
                  markings is developed.  Although such a Petri net system
                  is not defined conventionally, it is shown that its
                  behavior can be simulated through a conventional net, so
                  existing analysis and verification approaches for usual
                  Petri nets can be applied indirectly.}
}

@InProceedings{Bera2011,
  author =	 {Bera, Debjyoti and van Hee, Kees M. and van Osch, Michiel and
                  van der Werf, Jan Martijn},
  title =	 {A Component Framework where Port Compatibility Implies
                  Weak Termination},
  crossref =	 {|PNSE2011},
  pages =	 {152-166},
  year =	 2011,
  abstract = 	 {The design and verification of an asynchronous
                  communicating system can be very complex.  In this paper
                  we focus on weak termination: in each reachable state,
                  the system has the option to eventually terminate.  We
                  present a component framework and construction method
                  that guarantees weak termination.  In the framework,
                  communication between components is modeled by portnets,
                  a special class of workflow nets.  A basic component
                  defines the orchestration of the portnets.  For weak
                  termination, the orchestration should accord to each of
                  the portnets.  A composite component is built from basic
                  components that offer some service via a portnet.  We
                  provide sufficient conditions to guarantee weak
                  termination for composite components.  Furthermore, we
                  present a refinement-based construction procedure to
                  derive a weakly terminating composite from an
                  architectural diagram of the system.}
}

@InProceedings{Betz2011,
  author =	 {Betz, Tobias and Cabac, Lawrence and G{\"u}ttler, Matthias},
  authorplain =	 {Betz, Tobias and Cabac, Lawrence and Guettler, Matthias},
  title =	 {Improving the Development Tool Chain in the Context of
                  {Petri} Net-Based Software Development},
  crossref =	 {|PNSE2011},
  pages =	 {167-178},
  year =	 2011,
  abstract = 	 {Modern, collaborative software development projects are
                  highly supported by a variety of tools.  Aside from the
                  pure code development that is nowadays well supported by
                  integrated development environments (IDEs) such as
                  Eclipse, also other activities receive increasing
                  attention in the matter of tool support.  Recent
                  improvements in tool support for source code management
                  (SCM), process management and documentation management
                  are driven by the changing demands of increasing
                  distribution and agility of development projects.
                  Moreover, the integration of tool support systems into
                  integrated project management environments (IPMEs)
                  increase the usefulness of each emerging tool support,
                  especially for agile approaches.  The Petri net-based
                  agent-oriented software engineering (PAOSE) is highly
                  influenced by agile methods and combines the agile
                  concepts with aspects from model driven development.  We
                  have achieved increased efficiency by the adoption of
                  IPMEs into the PAOSE development approach.  However, the
                  introduced tool set integration lacks in support for the
                  model driven part of PAOSE, i.e. the tool integration for
                  graphical (model-based) source code is missing.  In this
                  work we present an approach for an appropriate tool
                  support of agile methods and model driven development.
                  As a prototypical implementation of the concepts we
                  present a Web service-based framework and plugin-based
                  extension for Redmine as representative of open source
                  IPMEs, which is currently in use in the context of the
                  PAOSE approach.}
}

@InProceedings{Simonsen2011,
  author =	 {Fagerland Simonsen, Kent Inge},
  title =	 {On the use of Pragmatics for Model-based Development of
                  Protocol Software},
  crossref =	 {|PNSE2011},
  pages =	 {179-190},
  year =	 2011,
  abstract = 	 {Protocol software is important for much of the computer
                  based infrastructure deployed today, and will remain so
                  for the foreseeable future.  With current modelling
                  techniques for communication protocols, important
                  properties are modelled and verified.  However, most
                  implementations are being done by hand even if good
                  formal models exist.  This paper discusses some of the
                  challenges in modelling and automatically generating
                  software for protocols.  The challenges are discussed
                  using the Kao-Chow authentication protocol as a running
                  example by outlining an approach for generating protocol
                  software for different platforms based upon Coloured
                  Petri Nets (CPN).  The basic idea of the approach is to
                  annotate the CPN models with pragmatics which can be used
                  in a code generator when mapping the constructs of the
                  CPN model onto the target platform.}
}

@InProceedings{Saadallah2011,
  author =	 {Saadallah, Nejm and Daireaux, Benoit},
  title =	 {A Goal Based Approach on top of {Petri} Nets},
  crossref =	 {|PNSE2011},
  pages =	 {193-195},
  year =	 2011,
  abstract = 	 {This poster presents ongoing work and mainly proposes a
                  way to model goals on a Petri net model.  We consider
                  that the basic functioning of many machines can be
                  captured in a Petri net model, while the environment
                  where the machine is deployed is often too complex to be
                  modelled in Petri nets.  We handle the influence of the
                  environment on the choice of operations by the so-called
                  external agents, and show how these agent's goals could
                  be studied before real deployment.}
}

@InProceedings{Wu2011,
  author =	 {Wu, Weiyi and Zhang, Yao and Wang, Shengyuan and Dong, Yuan},
  title =	 {{PNTM} -- Integration of {Petri} Nets and Transactional Memory},
  crossref =	 {|PNSE2011},
  pages =	 {196-199},
  year =	 2011,
  abstract = 	 {PNTM demonstrates a new concurrent programming model,
                  providing explicit concurrency among cooperative
                  transactions with correctness.  It integrates a special
                  Petri net and transactional memory, and improves the
                  performance of transactions by decreasing the rate of
                  conflicts.  The GUI part of PNTM environment is based on
                  PNK, the compiler is a modified GJC, and the runtime is
                  based on DSTM2.}
}

@Proceedings{|PNSE2011,
  title =	 {{Petri} Nets and Software Engineering.
		  International Workshop PNSE'11,
		  Newcastle upon Tyne, UK, June 2011.
		  Proceedings},
  booktitle =	 {{Petri} Nets and Software Engineering.
		  International Workshop PNSE'11,
		  Newcastle upon Tyne, UK, June 2011.
		  Proceedings},
  editor =	 {Duvigneau, Michael and Moldt, Daniel and Hiraishi, Kunihiko},
  month = 	 jun,
  year = 	 2011,
  volume = 	 723,
  series = 	 {CEUR Workshop Proceedings},
  ISSN = 	 {1613-0074},
  publisher =    {CEUR-WS.org},
  url = 	 {http://CEUR-WS.org/Vol-723},
  urn = 	 {urn:nbn:de:0074-723-C}
}
