#                                                              -*-org-*-
#+TITLE: Dezyne NEWS – history of user-visible changes
#+STARTUP: content showall
#+OPTIONS: toc:nil
#+OPTIONS: num:nil
#+OPTIONS: ^:nil

* Changes in 2.13.0 since 2.12.0
** Simulation
  - Interactive use is now supported, it is started when invoked without
    input trail.
  - The input trail may now be sparse, only the input needed to resolve
    non-deterministic choices is required.
  - The split-arrows trace format is now used by default.  It includes
    the provides port trace.
  - The eligible events are printed at the end of the trace.
  - Invalid input (garbage) on the trail is marked as an error.
  - All verification problems are detected and reported, notably:
    + async livelock,
    + failures model refusals,
    + forking a call from one provides port to another provides port,
    + a second async req, while a previous ack is still pending,
    + a reply on a modeling event in an interface.
  - A provides port that uses silent events is now supported.
** Commands
  - The `dzn trace' command has two new output formats:
    + --format=json provides P5 output for integration with Dezyne-IDE,
    + --format=ascii provides an trace diagram.
  - The JSON output for the state diagram now produces actions and state
    as structured data.
** Verification
  - Enum literals in the verification trace now use a colon as separator
    between the enum-type and enum-field.  This resolves a long standing
    ambiguity in the trace format.
  - The verification standard output is now adds the model name next to
    the trace.
  - The trace is now marked with a <label> indicating the problem found
    during verification.
  - Verbose output is written to standard error.
  - The `--json' option has been removed.
  - Async livelocks, i.e., defer.ack () => defer.req () are now
    detected and reported.
** Code generation
  - The C++ code generator has been updated to support the new enum
    literal representation.
  - The C# runtime has been updated to support the new enum literal
    representation.
  - The experimental C code generator now properly supports systems,
    foreign components and namespaces.
  - The C# runtime now defines a generic async interface; async
    interfaces are no longer generated.
** Noteworthy bug fixes
  - A type mismatch is now also properly reported when attempting an
    enum field access on a boolean ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/19][#19]]).
  - An undefined function is now also properly reported for a function
    call that has arguments ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/18][#18]]).
  - Verification now reports a livelock with async.
  - In the simulator, for a requires out event on a model with multiple
    provides ports, all provides ports are now being updated.
  - In the preprocessor, an off-by-one line count error has been fixed
    for deeply nested imports.
  - Generating code using a calling context for a model that uses
    dzn.async is now supported ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/20][#20]]).
  - Using the same async interface with parameters more than once no
    longer triggers a well-formedness error.
  - The C++ and C# code generators no longer create structs or classes
    for async interfaces with parameters.
  - Using an early return pattern in a function now no longer reports a
    false positive <livelock> or <second-reply> error ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/27][#27]]).
  - The C++ and C# runtime and pump now queue events that are sent to a
    blocked port ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/23][#23]]).
  - The C++ and C# runtime no longer releases collaterally blocked ports
    early, avoiding "component already handling an event" ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/23][#23]]).

* Changes in 2.12.0 since 2.11.0
** Commands
  - A new command 'dzn explore' can be used to create LTSs and accurate
    state diagrams of interfaces, components and systems.
  - A new command 'dzn simulate' provides a basic system simulator.
  - Code completion now supports boolean expressions in (partial) guards
    and (partial) enum field tests.
** Parser
  - The `dzn parse' command has a new option: --list-models.
  - The import file-name now supports relative directories.
** Verification
  - The verification pipeline was refactored and opened-up:
    + The actual pipeline commands are shown when running `dzn -d verify
      ...', ready for use on the command line.
    + The dzn verify command now has a new '--out=FORMAT' option to
      produce intermediate verification output of a certain FORMAT.
** Code generation
  - Code generation has been cleaned-up.
    + Language packs are now supported.
    + The code generators produce less gratuitous whitespace.
    + The code indenter cleans-up orphan parentheses when generating
      Scheme code.
  - The C# code generator (language CS) has been resurrected.
  - The generated code now provides  basic provenance by adding a
    `Generated by dzn code from <file-name>' comment, removing any
    question of copyright.  Protip: for reproducible output, use a
    relative dezyne file name.
  - The json code generator (for the system diagram) now strips
    behaviours and leaf-locations.
** Language
  - Lookup of imports is now supported.
  - Completion of guard expressions and field-tests are now supported.
** Build
  - Building with Guile 3.0.5 and guile-json-4 is now supported.
** Noteworthy bug fixes
  - Unresolved imports are handled ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/6][#6]]).
  - Duplicate imports when using different directory prefixes ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/7][#7]]).
  - A regression has been fixed that caused parsing of a system with
    many imports (> 20) to become very slow ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/8][#8]]).
  - c++ thread_pool support is now off by default, like it should be ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/10][#10]]).
  - Using a synchronous callback in the context of a thread safe shell
    has been fixed for c++ and scheme.
  - A bug has been fixed in parsing verification traces with flushes
    occurring in a namespace ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/11][#11]]).
  - Triggering an illegal using a synchronous callback in the context of
    dzn.async has been fixed ([[https://gitlab.com/dezyne/dezyne-issues/-/issues/12][#12]]).
  - In `dzn language', any line-column separator can be used with the
    `--point=' option; using a comma no longer gives unexpected results.

* Changes in 2.11.0 since 2.10.1
** Commands
  - A new command `dzn language' supports DZN-language completion and
    lookups.
  - The commands `dzn cat and `dzn ls' have been removed.
** Parser
  - A well-formedness check was added for trigger, action, and
    function-call arguments.

* Changes in 2.10.1-thermo-fisher since 2.10.1
** Code generation
  - The C++ runtime now provides an optional thread pool in
    "runtime/c++/thread_pool.cc".
  - The pump in the C++ runtime can now optionally uses a the new
    thread pool by compiling with "-D DZN_THREAD_POOL=1".
  - The language "c++ew" has been added for Thermo Fisher Scientific.

* Changes in 2.10.1 since 2.10.0
** Usability
  - The dzn command now exits gracefully when given an unknown command.
  - The dzn-mode for GNU Emacs is now a major mode called "Dezyne".
** Parser
  - Parse errors in imported dzn-files now show the import inclusion
    path.
  - Using newlines between `dollar'-expressions and toplevel
    `dollar'-statements is now an error.
** Code generation
  - Performance has been improved.
  - The C++ code generator is now prepared for C++20: The
    dzn::port::meta fields are renamed to "provide" and "require".
  - The Scheme code generator uses the "namespace to module" feature.
    This code generator is experimental, and not available in the
    regular binary release.
  - The JavaScript code generator uses the "namespace to module"
    feature.  This code generator is experimental, and not available in
    the regular binary release.
** Documentation
  - The infocenter has been converted to texinfo and is now included in
    the release.
** Noteworthy bug fixes
  - Fixed a regression of using two different types of async interface
    in one behaviour.

* Changes in 2.10.0 since 2.9.1
** Dezyne is now stand alone, client only, serverless, pure GNU Guile Scheme.
  - Removed: server, services, dzn, dzn/daemon
    + 20,000 LOC JavaScript.
    + 800 LOC of Shell
  - Replaced parser and component-interpreter
    + 2,000 LOC flex/bison
    + 86,050 LOC C++
      . of which 32,000 handwritten
      . 50,000 generated by 4,200 LOC of TCL input
    + 2,000 LOC of TCL
    + 4,200 LOC of TCL input
    + 200 LOC of Python
    + 700 LOC of Perl
    with PEG parser and system-simulator by 4,000 LOC of Scheme.
  - The new Scheme-only, client-only (serverless) Dezyne git archive
    was grafted onto the historical development.git; that in turn was
    built on Gaiag (https://gitlab.com/janneke/gaiag), which is still
    at the root of this archive.
** Parser
  - All error messages were changed.
  - "Use before declare" is no longer supported for variables.
  - Toplevel `dollar`-statements used inside a namespace are now
    rejected.
** Code generation
  - C++: The tracing interface was changed, notably the "dzn::trace_in"
    function was renamed to "dzn::trace".
  - C++: Experimental state-variable tracing was disabled.
  - Other languages were dropped.
** Component simulator
  - The component simulator was removed.
*** Noteworthy bug fixes
  - Fixed a bug where function calls immediately following an if
    statement were not considered by the verifier
  - Fixed a bug where an enum-field test used as the expression in a
    reply statement would crash the verifier.
  - Fixed a bug where a boolean "not" used as the expression in a
    reply statement was ignored.
  - Fixed a bug with precedence in deeply nested boolean expresisons
    in generated code.

* Changes in development since 2.9.1
   It contains work in progress and is not intended for evaluation or
   production use.

* Changes in 2.9.1 (since 2.9.0)
** Verification: reduce memory usage by one order of magnitude:
   Allows models with a larger state space to be verified.
** Verification: improved error reporting:
   Internal errors and out of memory error are now reported as such.
** Verification: fix for issue 7547:
   Compliance now succeeds when using async in the middle of two
   provides out events on a single modeling event in the interface.
** Code: fix for issue 7529:
   C++: a reply with a port prefix can be used anywhere, not just in a
   blocking context.
** Code: fix for issue 7527:
   C++: parameterized events can be used with dzn::shell

* Changes in 2.9.0 (since 2.8.1)
** Reintroduction of C#.
** For C++ fix the use of injected in combination with thread safe shell.

* Announcement: discontinuation of 2.7.x
  - 2.7.x has been discontinued as of November 2018
  - With the full verification support in 2.8.0, the 2.7.x was
    declared deprecated.  2.7 was intended as a verification preview
    release series while working on the transition to mCRL2 based
    verification.

* Changes in 2.8.2 (since 2.8.1)
** Code generation
  - C++: fixed 7505 Namespaces and system components
  - C++: fixed 7509 local variables within blocking cause a failure in
    the code generator
  - C++: fixed 7518 System with component with multiple injected
    interfaces generates double component instantiations
  - fixed shadowing a member variable with an interface declared event
    parameter

* Changes in 2.8.1 (since 2.8.0)
** Verification
  - Fixed the combined use of async and blocking

* Changes in 2.8.0 (since 2.7.2)
** Verification
  - Full verification support based on mCRL2 (http://mcrl2.org), see
    https://hosting.verum.com/regression/2.8.0.
  - The async feature has been officially released, see
    https://hosting.verum.com/doc/?searchWord=async.
  - The semantics of silent modeling events is now more strict and
    enforced by a new well-formedness check.
  - The 2.8.0-verification service is implicitly used for previous
    service releases.
** Service selection
  - The dzn COMMAND --version option now also accepts --version=MAJOR
    and --version=MAJOR.MINOR.
  - dzn query command now also shows MAJOR and MAJOR.MINOR service
    versions.
** Code generation
  - C++ code and runtime now embed the service version.
  - Several fixes for usage of foreign components.
  - INTERFACE_ONLY has been removed from the C++ code generators.
  - Skeleton code for foreign components are now generated inline;
    no longer in a separate skel_ file.
** ASD Converter
   - The ASD converter now fixes an issue with shadowing of member
     variables.
** Noteworthy bug fixes
  - Several namespace bugs have been fixed, supported usage includes
    tests in https://hosting.verum.com/regression/2.8.0
     + hello_interface_namespace.dzn
     + hello_namespace_enum.dzn
     + foreign.dzn
     + inner_space.dzn
     + namespace_assert.dzn
     + name_space.dzn
  - Several bugs have been fixed in the --glue=dzn code generator.

* Changes in 2.7.2 (since 2.7.1)
** Verification
  - The verification performance has been improved by a factor 3-4, especially
    for large models. For an interface, the deadlock and livelock checks are
    performed in parallel. For a component, the determinisctic, illegal,
    deadlock, and livelock checks are performed in parallel.
  - The verification results view reports per check the number of states and
    transitions that have been considered.
** Known issues
  - In some corner cases, nested function calls will cause a failing
    verification.
  - The language features blocking, external and
    async are not yet available for verification, see
    https://hosting.verum.com/regression/2.7.2/regression.html.
  - For verification, when selecting version 2.7.0 or 2.7.1, version 2.7.2 is
    used instead.

* Changes in 2.7.1 (since 2.7.0)
** Verification
  - The dezyne verification now supports models with multiple provides ports.
  - Functions with parameters are verified correctly now.
** Code generation
  - Code generation for c++-msvc11 has been fixed.
** Known issues
  - The language features blocking, external and
    async are not yet available for verification, see
    https://hosting.verum.com/regression/2.7.1/regression.html.
* Changes in 2.7.0 (since 2.6.1)
** Verification
  - The Dezyne verification engine has been replaced by mCRL2, see
    http://mcrl2.org.
  - Interface completeness verification is performed as part of the
    deadlock check.
  - Verification counter examples may differ from previous versions.
** Known issues
  - The language features multiple provides, blocking, external and
    async are not yet available for verification, see
    https://hosting.verum.com/regression/2.7.0/regression.html.
  - The verification feature has been discontinued for all older
    releases.
  - Verification performance has not been fully optimized.
** Code generation
  - Performance of the code generator has been improved significantly.

* Changes in 2.6.1 (since 2.6.0)
** Code generation
  - The c++ code now avoids triggering some Visual Studio compiler warnings.
  - Calling context has been enhanced.
** ASD Converter
   - The ASD converter now forwards user-defined includes to DZN.

* Changes in 2.6.0 (since 2.5.3)
  - The interpreter now shows the content of the queues in the
    watch-window.
** Command line client
  - The ‘dzn hello’ command now returns with a dedicated exit status 3
    in case no server connection could be made
** Model verification
  - All models in a DZN file are now verified by default, unless the
    explicit ‘-m,--model=MODEL’ option is used.
  - The --queue_size option (broken since 2.5.0) has been fixed
** Verification view
  - The new verification view displays for each check the number of
    states and transitions the verification engine had to consider.
** Documentation
  - The text of the DZN files in the regression test matrix can now be
    downloaded.

* Changes in 2.5.3 (since 2.5.2)
** Noteworthy bug fixes
  - Globally declared enums which are not used as event reply type
    no longer cause a crash in verification (bug introduced in 2.5.0)
  - dzn convert now has a ‘--glue’ option.  The glue namespace is
    only added when this option is used.
** Code generation
  - c++* only depends on pump when blocking or async are used
  - this relaxes the boost dependency on 1.58+ for coroutine to any
    previous version supporting bind, function and tuple.

* Changes in 2.5.2 (since 2.5.1)
** Code generation
  - c++* fix void event in thread safe shell

* Changes in 2.5.1 (since 2.5.0)
** Code generation
  - c++* thread safe shell now supports enum and subint reply types

* Changes in 2.5.0 (since 2.4.1)
** Code generation
  - The javascript code generator now uses file2file mode.
  - The c++ code generator passes ASD construction parameters via glue.
  - The c++ code generator skips retrieving the pump pointer when
    async is not used.
  - The c++03 code generator now supports thread safe shell, but only
    if there is enough c++11 support available in the compiler.
  - The c, c#, java, java7, python and scheme code generators are not
    available in this release; for these languages please use 2.4.1 or
    earlier.
** ASD Converter
   - The ASD converter produces ‘.map’ files for Components with
     construction parameter information that is used by the glue code
     generator.
** Known issue:
   - Global declared enum not referenced as a reply type not supported
     in verification.
   - The queue_size option gives an error: ‘gdzn: no such option: -q’

* Changes in 2.4.1 (since 2.4.0)
** DZN language
  - Dollar expressions can now be used at toplevel
** Code generation
  - The c++03 runtime now uses a boost-compatible workaround for
    lacking move semantics
  - Using ‘reply()’ in a function called from a ‘blocking’ context
    has been fixed
** Verification
  - The queue_size option has been fixed

* Changes in 2.4.0 (since 2.3.4)
** Code generation
  - The c++ code generators use file2file mode by default
    Generating code for a DZN file ‘model.dzn’ now produces
    ‘model.hh’ and ‘model.cc’
  - The c# runtime now has a ‘check_bindings’ function
  - The interface of the c++ and c++03 runtime has been modified
  - The container interface the c++ languages (‘container.hh’) has been changed
  - The c++03 code generator now supports ‘blocking’
  - The c++03 code now depends on boost 1.58 or newer
** Model verification
  - Verification performance of some models has been improved
** Noteworthy bug fixes
  - Authentication with the dzn client is robust against parallel execution
  - Handle output from model checker where lines are broken in two
    parts (https://zoho.verum.com/7327)
  - Dollar expressions can now contain DZN keywords
    (https://zoho.verum.com/7310)
  - Parameters in on-clauses for unused notification events are no
    longer removed  (https://zoho.verum.com/7309)
  - The ASD converter now renames variables that conflict with DZN
    keywords (https://zoho.verum.com/7308)
  - Type declarations can now appear anywhere at the toplevel of a
    behaviour (https://zoho.verum.com/6747)

* legalese

Copyright © 2017,2018,2019,2020,2021 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
Copyright © 2017,2018,2019,2020,2021 Rutger van Beusekom <rutger.van.beusekom@verum.com>
Copyright © 2018,2019 Rob Wieringa <Rob.Wieringa@verum.com>

  Copying and distribution of this file, with or without modification,
  are permitted in any medium without royalty provided the copyright
  notice and this notice are preserved.

Please send Dezyne bug reports to bug-dezyne@nongnu.org.
