CONCEPTBASE
             RELEASE NOTES for Version 7.1

   Manfred Jeusfeld, Christoph Quix, Matthias Jarke
                   ConceptBase Team

    http://www-i5.informatik.rwth-aachen.de/CBdoc/
                 http://conceptbase.cc

                     28-May-2008


ConceptBase is a multi-user deductive object manager developed at 
RWTH Aachen and Tilburg University. This document lists the changes from
ConceptBase 7.0 to ConceptBase 7.1. 

Databases created by ConceptBase 7.0 should be readable by ConceptBase 7.1.
We recommend however to extract the frame definitions of the objects via
the SaveModule utility (published in the CB-Forum, see section Notes below)
and to store the frames to a fresh ConceptBase 7.1 database.

The release notes of ConceptBase 7.0 are attached at the end of this file.


Highlights of Version 7.1

* Improved meta formula support
  The new predicates (x [in] mc)  and (x [m] y) allow to query objects from
  the meta class level. The code generated from meta formulas is now attached to
  the classes where the meta formulas apply. 

* Functional expressions
  Functional and arithmetic expressions are now fully supported. It is
  also possible to recursively define new functions, e.g. for computing
  the length of the shortest path between two nodes in a graph.

* Easier Telos coding
  The syntax of Telos is more flexible and allows various shortcuts. 
  The plug-in facility for extending the functionality is now based
  on an easy-to-use programming interface. 

Besides, a couple of bugs have been corrected. The memory footprint
and the system performance are comparable to version 7.0. We have 
stopped support for the Mac OS-X (PowerPC) platform. There is however
a pre-release version of ConceptBase 7.1 available for Mac OS-X via
the ConceptBase-Forum.


Detailed Changes
================


71-01 Support for Java 6

  Java 6 runtime environments are now supported by ConceptBase. The older
  environments Java 5 (1.5) and Java 1.4 are also supported.
  (Ticket 127)

71-02 Predicates (x [in] mc) and (x [m] y)

  The two new predicates (x [in] mc) and (x [m] y) are now supported by ConceptBase.
  Among others they allow to query a database from the meta class level bypassing
  definitions at the class level. 
  (Tickets 124,138)

71-03 Linux64 library issue fixed

  The Linux64 variant was not statically linked to the necessary libraries. This shortcoming
  made the Linux64 variant unusable on systems that did not have all libraries installed.
  Since we now link all required libraries statically to the CBserver binary code, the
  problem is now solved.

71-04 Variable ranges in meta formulas

  The use of the range Proposition for a variable x in meta formulas could prevent some
  meta formulas from being compiled. A problem occured when some predicates
  like (x m y) in the formula referred to an attribute m, which is not an attribute
  of Proposition but of some other class of x. The problem has now solved by
  a more intelligent lookup of the best possible variable range for x.
  (Ticket 138)

71-05 Apostrophe syntax to indicate accesses to new database states in ECA rules

  ConcepBase now supports the shortcut `<pred> in conditions of ECA rules.
  It indicates that the predicate <pred> shall be evaluated against the newest
  database state. The new syntax is an abbreviation for the expression
  new(<pred>). which continues to be supported.

71-06 Improved EQ predicate

  The EQ predicate used to be defined for testing the equality of two numbers
  (or two functional expressions that are evaluated to numbers). We now also support
  that one or both arguments are free variables at the time when EQ is evaluated. 
  As a consequence, the EQ predicate can now be used to evaluate functional
  expressions like in (x = y+z).
  (Ticket 142)

71-07 Improved management of CBserver plug-ins

  CBserver plug-ins (file type *.lpi) can now be stored within the ConceptBase system directory
  and shall then be attached to CBserver process. This allow users to permanently extend the
  capabilities of the ConceptBase server. Moreover, the CBserver plug-ins can now use a
  simplified programming interface to the ConceptBase server. The interface is documented in
  the ConceptBase User Manual, appendix "CBserver Plug-Ins". The programming interface can be 
  used to interface to the operating system, e.g. to store information in a file or
  to e-mail it over the network, or to compute a function that cannot be expressed in O-Telos.
  (Ticket 144)

71-08 Generalized specification of find_classes

  The pre-defined query class find_classes now also finds deduced classes of a given
  object. This improves the functionality of the graph browser, the only tool that uses
  find_classes. As a follow-up consequence, parameters of some pre-defined
  query classes have to utilize the new category 'required'.
  (Tickets 145,146,147)

71-09 New syntax for inequality predicate

  Besides '(x <> y)' we now also allow '(x \= y)' and '(x \== y)'  as
  infix operators to express that x and y are not equal. Functional
  expressions are allowed in both positions. They will be evaluated before
  the inequality is tested.
  (Ticket 148)

71-10 Bug with locking databases resolved

  The ConceptBase server has a provision to prevent two CBserver processes to
  work concurrently on the same database. This provision was not working
  correctly due to a shell script bug. This is now solved.
  (Ticket 149)

71-11 Legacy code for magic set query evaluation removed

  Some of the legacy code for the old magic set evaluator has been removed.
  Since ConceptBase 6.1, the standard query evaluator is based a dedicated 
  algorithm called 'magic cache'.

71-12 UNTELL can no longer crash the CBserver

  Under rare circumstances an UNTELL could crash the CBserver. The problem
  is related to specialization links from attributes to non-attribute classes.
  The bug is now resolved.
  (Ticket 150)

71-13 Users can now be contained in their home module

  It is now possible to define a security policy that prevents users from
  leaving their home module tree. The security policy plug-in is documented in
  the CB-Forum. Unauthorized attempts to switch to read-protected module
  now cause a error message displayed to the user and written to the log file.
  (Ticket 151)

71-14 Partially evaluated sub-formulas as subclasses of the meta formula

  If a meta formula is partially evaluated, then the resulting formulas are
  stored as subclasses of the meta formula. Previously, they were stored
  as instances. This is just a cosmetic change.
  (Ticket 152)

71-15 Graph editor inherits module context from Java workbench CBiva

  The graph editor can be called from the Java workbench CBiva. Up to now,
  the home module of the graph editor was determined from the user name.
  However, the user of CBiva can have altered the current module context.
  This context is now inherited by the graph editor when called from CBiva. 
  (Ticket 153)

71-16 Omega classes not shown with untell mode 'cleanup'

  The so-called omega classes Individual, Attribute, InstanceOf, IsA are not
  shown in a Telos frames when the CBserver parameter untell mode is set to
  'cleanup' (default). This realizes a more natural behavior of the CBserver 
  to users who do not use these classes explicitely. The old behavior is 
  activated by setting the untell mode to 'verbatim'. A detailed description
  is provided by the ConceptBase user manual, see section on ConceptBase Server.
  (Ticket 154)

71-17 Regression of bug #64 solved

  The bug 'Triggers for rules/constraints fetched out of module context' (ticket 64)
  had a regression. Under specific circumstances, ConceptBase would see triggers
  from other neighbor modules. This could cause the issue of wrong error messages
  and prevent the compilation of certain correct models. This bug is now solved.
  (Ticket 155)

71-18 Better readable rule/constraint code generated from meta formulas

  A meta formula such as the definition for the necessary/single categories as partially
  evaluated to simpler forms whenever a class is defined that refers to the generic 
  concepts such as necessary/single. We now make sure that the generated code is made
  visible at a suitable context-specific class and that the formula is first optimized
  before the code is generated. This results in more readable code. The change does
  not effect the functionality but is enhancing the transparency of the 
  handling of meta formulas. It also allows to generate optimized specifications of
  modeling constructs and models with all meta formulas eliminated.

71-19 Functional expresssion in meta formulas

  Functional expressions like COUNT_Attribute[a/attrcat,x/objname] are now 
  supported by the meta formula compiler. The reverse compiler shall
  reproduce the correct functional expression for the formulas generated
  from the meta formula.
  (Ticket 158)

71-20 Triggers for similar rules disambiguated

  Two deductive rules with the same conclusion literal and just one literal in the
  condition were compiled to triggers with the same trigger identifier. This
  behavior led to the invisibility of one of the generated triggers for the
  integrity checker. This bug is now resolved.
  (Ticket 161)

71-21 Extended support for predicate (x m/n y)

  The predicate (x m/n y) is quite powerful within meta formulas when using
  in with variable argument n. However, the predicate wasn't fully supported
  by the meta formula compiler. In particular, it was not used to partially
  evaluate a given meta formula. 
  Besides, the predicate can now be used as conclusion of deductive rules. This
  allows among others to model multi-sets, i.e. derived attributes that may 
  have the same value multiple times.
  (Tickets 160,162,164)

71-22 Empty function bodies

  A function without a body (either a constraint or a Prolog implementation) could
  crash the CBserver. This bug is now resolved.
  (Ticket 163)

71-23 Even/Odd problem resolved

  The standard example EvenOdd.sml from the CB-Forum did not work in CB7.0 due
  to a bug with handling results of arithmetic functions like IPLUS ('+'). The
  bug is now fixed.
  (Ticket 167)

71-24 Parameters of views as computed attributes

  The ConceptBase server could crash or produce incomplete answers when a
  parameter of a View was also declared as 'computed_attribute'. This problem
  is solved now.
  (Ticket 168)

71-25 New command line parameter for setting multi-user mode

  The ConceptBase server can operate either in multi- or single-user mode.
  This option can now also be controlled by the new command line parameter
  -mu (multi-user mode). If the ConceptBase server is started from a shell/terminal
  window, the multi-user mode is set by default to 'enabled'. If the
  ConceptBase server is started from CBiva, the mode is set by default to
  'disabled', i.e. a ConceptBase server started from the CBiva user environment
  disallows by default other clients. The new command line parameter is supposed to
  increase the security. More details are in the user manual, section
  'ConceptBase Server'.

71-26 Old graph types removed

  The old so-called X11 graph types are removed from the release. They were
  necessary to work with the long-outdated Andrew-Toolkit-based graph browser used
  in ConceptBase V5.x and earlier. The current Java-based graph editor uses a 
  different scheme for graphical types. The command line parameter -gt x11 is
  no longer required and thus removed.
  
71-27 Problem with read-only database solved

  If ConceptBase is started from a read-only file system (or directory), e.g. from a CD-ROM,
  then the database is initialized with read-only components. This could cause severe
  problems since ConceptBase expects the database to be writable. The problem did not
  occur with Windows. The problem is now fixed by taking care that write permissions are set.
  (Ticket 170)

71-28 Deferred mode of ECA rules works also with UNTELL

  Deferred ECA rules could not be triggered by an UNTELL operation. This bug is solved.
  (Ticket 171)

71-29 Predicate typing for queries set to strict by default

  The predicate typing (a.k.a. enforcing concerned class) is now set to 'strict' for
  query classes by default. It means that all instantiation and attribution predicates
  must be linked to a unique so-called concerned class. The predicate typing is
  always enforced for rules and constraints. Hence, this change only affects query classes.
  The old more relaxed mode can be activated by using the CBserver parameter -cc off
  when starting the CBserver. More details are in the user manual.

71-30 Result types of functional expressions used for code generation

  Number-valued functional expressions in formulas require to determine the result type
  in order to generate correct executable code. The mechanism is now extended and
  supports now SUM,MIN,MAX in the proper way.
  (Ticket 172)

71-31 Shortcut syntax for function calls

  Functional expressions in rules, constraints and queries can now use the convenient
  shortcut syntax, e.g. F(x,y) instead F[x/p1,y/p2]. Like with the long form,
  functional expressions can be nested such as in F(x,G(y)). Calls of generic
  query classes have similar shortcuts, e.g. Q[x,y] instead Q[x/p1,y/p2]. The function
  COUNT has a particular shortcut #C standing for COUNT[C/class] (= number of instances of
  class C).
  (Ticket 173)

71-32 Arguments of arithmetic functions save-guarded

  An expression like Class+1 could crash the CBserver since the arguments were
  not tested on their type. This is now resolved.
  (Ticket 174)

71-33 Simplifications for active rules

  Active rules can now use the Retell action as an abbreviation of Untell+Tell. Furthermore,
  The syntax for events and actions allows shortcuts like 'Tell (x in c)' instead 
  'Tell((x in c))', which continues to be supported.

71-34 Range test always after function call

  Functions that generate new result objects must be evaluated before the result type is
  tested. ConceptBase now maps all predicates (x in F(y)) to the format (x = F(y)).
  This format makes sure that the result type is tested after the function call.
  (Ticket 176)

71-35 Forward-declaration of query classes

  A system of recursively defined query classes can only be compiled if the signature
  of a query is known before a quary call is compiled. ConceptBase now allows forward-
  declaration of query classes (and functions) for this purpose.
  (Ticket 177)

71-36 Recursive function definitions

  ConceptBase now supports recursive definitions of functions, e.g. for computing the
  Fibonacci numbers, or for computing the length of the shortest path between two nodes.
  This new feature is useful for example to define hierarchical measures on tree-structured
  models.
  (Ticket 175)
   
71-37 'Dirty' query calls regarded as completed

  The recursive query evaluator of ConceptBase has to deal with situations where a query call
  recursively calls itself (with same arguments). Such calls are delayed and marked as
  'dirty'. Under some circumstances such calls could change their state to 'completed' without
  having computed the complete extension. ConceptBase now uses the intermediate state 'pending'
  for dealing with such situation. Subsequent query evaluations will then re-evaluate the
  'dirty' query calls rather than regarding the partial extension as complete.
  (Ticket 179)

71-38 Define function/query signatures within LPI files

  LPI files are used to extend the functionality of the ConceptBase server by user-programmed
  functions and queries. It is now possible to include the Telos frame defining the signature 
  of the new functions/queries within the LPI file by a 'tell' clause. 

71-39 Mac-OS-X (PowerPC) no longer supported

  The platform Mac-OS-X on PowerPC is no longer supported. The last release supporting that
  platform is ConceptBase 7.1 built January 18, 2008. It is available from the 
  ConceptBase Forum.


Issues
======

* Linux and Solaris users need to make sure that libstdc++.so.6 is installed on their
  systems. It is part for example of the Gnu CC 4.1 package but can also be installed
  separately from the Gnu CC package.

* Objects names and attribute labels starting with 'id_' should be
  avoided since ConceptBase uses this prefix to characterize
  internal object identifiers. Likewise, no object name should 
  start with 'xX' since this is used internally to characterize
  variable positions during query evaluation.

* The nodes sizes in the graph editor are not recomputed when the
  graph palette (assignment of graphical types to displayed objects) is
  changed. This can lead to truncation of object labels when the new
  graphical type is smaller than the initial one. You may try the
  operation  'Current connection / Validate and update shown objects' to
  circumvene this behavior.

* When a complex graph (e.g. links from links to other links) is displayed
  and the user moves a node around the windows, the reference points of
  some links can be set to arbitrary locations. 

* The TCP/IP interface between the CBserver and a client has a builtin
  delay that slows down transaction streams (series of many consecutive
  transactions). This makes the start-up of the graph editor a bit slow since
  the graph editor issues long streams of transactions when displaying objects.

* The Solaris version occasionally has problems with passing parameterized
  query calls from a ConceptBase client to the CBserver. Use 'Ask Query Call'
  with an explicit query call like 'Q[x/param]' to circumvene this problem.
  Other platforms do not suffer from this problem.

* Aggregation functions like COUNT should not be used in integrity constraints
  or rules since the incremental constraint checker cannot maintain
  the extension (=set of all ground solutions) of aggregation functions.
  There are however tricks to cope with certain usage patterns. See section
   HOW-TO / Avoid traps with aggregation functions in constraints
  in the CB-Forum.

* The rollback time mechanism (CBiva: Options / Select Version) can be used
  to query past database states. This feature does not work currently under
  Windows when the daylight saving ('summer time') is activated. In countries
  of the northern hemisphere, daylight saving is usually activated between end
  march and end october of the year. 
  Outside this time and on other platforms (Solaris, Linux, Mac OS), there
  should be no problems.

* When ECA rules update the database, ConceptBase will automatically disable the cache-
  based query evaluator. The cache would be invalid because of the update.) 
  Instead, ConceptBase will use the standard Prolog-style query evaluator. Since
  the ON-part of an ECA rule can call the query (literal) evaluator, calls to
  recursive predicates could run into infinite loops. 

* If you terminate a nonpersistent ConceptBase server by Control-C or by killing
  the corresponding process, then the temporary database continues to exist in the
  directory of temporary files (usually /tmp under Unix and C:\Temp under Windows).
  This is as such not a problem but over time the temporary databases can consume
  more and more disk space. We advise to remove every 12 months these dead databases.
  The directories have the names <username><digits> where <username> is the name
  of the user that started the server and <digits> is a sequence of digits and underscores.

* Be carefull with the -r parameter of CBserver under Linux/Unix. It can potentially
  cause an infinite loop when the CBserver executable crashes at startup. 
  Besides, the -r option is very useful if you want a to provide a stable
  service based on ConceptBase. It will restart the CBserver executable whenever 
  it has crashed (crashes are very hard to trigger anyway). The -r option is
  not available under Windows due to the limited scripting support under Windows.

* CBiva does not work if you enable desktop effects (a.k.a. Beryl) with Ubuntu. This 
  is a known bug in Java Swing and not likely to be fixed in the near future.
  We recommend not to use desktop effects.




Notes
=====

The CB-Forum is a workspace where ConceptBase users and developers share
documents, models, and software. The address is
      http://merkur.informatik.rwth-aachen.de/bscw/bscw.cgi/0/187789



Trademarks
==========

All trademarks used in this text are property of their respective owners.


Acknowledgments
===============

We thanks all ConceptBase users for their valuable feedback. 
We thank the SWI-Prolog for their excellent work and support.

  




---
attached: release notes of earlier versions










-------------------------------------------------------------------------------------------------





                C O N C E P T B A S E

            RELEASE NOTES for Version 7.0

                   ConceptBase Team
              RWTH Aachen, Informatik V
               Prof. Dr. Matthias Jarke
                    Ahornstr. 55
                 52056 Aachen, Germany
               Tel.: +49-241-80-21-501
               Fax   +49-241-80-22-321
      email: cb@i5.informatik.rwth-aachen.de
    http://www-i5.informatik.rwth-aachen.de/CBdoc/
                 http://conceptbase.cc



ConceptBase is a multi-user deductive object manager developed at 
RWTH Aachen and Tilburg University. This document lists the changes from
ConceptBase 6.1.2 to ConceptBase 7.0. See instructions at the end of this
document on how to transform Telos source models created with ConceptBase 6.1.2
to comply with ConceptBase version 7.0


Highlights of ConceptBase 7.0
=============================

 * Supports more platforms
   Besides Linux, Solaris, and Windows, we now also support Mac OS-X for PowerPC
   and Linux64 for x64. The support for x64 CPUs has virtually removed the 4GB
   limit for databases.

 * Much faster for most operations
   Query processing is between 30% and 2500% faster. For example, the computation
   of the transitive closure of a graph with 1400 nodes took 300 seconds with
   ConceptBase 6.1. It now just takes 11 seconds on a 3 years old PC. Simple 
   queries to smaller databases enjoy a more moderate speed-up. 

 * More expressive 
   In particular, the active rule component is now fully integrated with the
   integrity checker and its computational model has been changed. You now can
   easily define the dynamic semantics of petri nets as a meta model in Telos! 

 * Small and robust
   While ConceptBase is typically installed on harddisks, you can also install it on
   a memory stick or CD and start it from there without any further installation!
   Numerous bugs and shortcomings are corrected. A complete list is given below.


ConceptBase 7.0 is capable to manage large models with literally hundreds of
thousands of concepts. Earlier versions already greatly supported the meta
modeling of conceptual modeling languages. With the new release, you can also
start to define semantics of dynamic modeling languages and use the configurable
graph editor to visualize models and their use.



Detailed Changes
================


70-01 Support for Mac OS-X and Linux64 added

  Two new platforms are now supported by ConceptBase: Mac OS-X for
  PowerPC CPUs and Linux for AMD64 (EMT64) CPUs.
  The Linux64 variant is virtually lifting the 32bit address space
  limitation that also restricts the maximum database size for
  ConceptBase on 32bit machines. Besides the two new platforms,
  ConceptBase continues to support Linux (i386), Solaris (sparc and i386),
  and Windows XP/2000. All variants are now based on SWI-Prolog. 


70-02 Faster query evaluation

  Query processing under the Linux variants of ConceptBase can be
  about 3 times faster than under version 6.1.2. Particular queries under
  the Linux variants can run up to 25 times faster than under 6.1.2.
  The other variants enjoy a more moderate speed-up ranging from below 10%
  to a factor of 8. Integrity checking is also faster on average.


70-03 Revision of the graph editor

  The graph editor now provides image scaling (zoom-in, zoom-out) as
  well as some auto-layout functionality.


70-04 Bug in incremental meta formula compiler corrected

  Formulas generated from meta-level formulas are now correctly
  removed from the system when the meta-formula is removed.
  Moreover, the system has the same behavior regardless of in
  which sequence the meta-formulas are occurring in a TELL operation.
  Previously, one had to take care of the sequence or split
  definitions of meta-level formulas over several TELL
  operations. (Ticket 45)


70-05 Answer formatting uses internal cache

  The user-defined answer formats are now utilizing an internal cache
  when producing an answer to a query. This speeds up the computation
  of queries that use complex answer formats with repeating fragments.
  You need to set the cache mode (parameter -c) to 'keep' to
  enable this feature.


70-06 Customized error messages for integrity constraints 

  Error messages about integrity violations were using a
  fixed set of domain-independent textual formats. In many cases,
  it is useful to give more detailed information why the violation
  occurred. The feature is also available for meta-level constraints,
  i.e. constraints that define the semantics of user-defined modeling
  constructs like partOf. See ConceptBase user manual for more
  information on customized error messages.
  The predefined error messages were partially rewritten to improve
  readability, and object identifiers are now replaced by object
  names wherever possible. The internal code (like 'IC_NOTSAT') of
  an error message is no longer shown in the ConceptBase user interface.
  It remains visible in the CBserver console if the trace mode is set
  to 'low' or higher. (Ticket 58)


70-07 Variables in nested sub-expressions

  Nested functional expressions like
      COUNT[InputLink[~tr/trans,pl/place]/class]
  can contain variables like ~tr and pl quantified in the formula. In such
  cases, the evaluation led to wrong results since the nested variables
  were not found by the formula compiler. ConceptBase now correctly
  identifies all variables. (Ticket 52)


70-08 Objects can now use attributes of derived classes

  In ConceptBase 6.1.2 and earlier, an object had to be an explicit
  (=stored) instance of a class or one of its subclasses in order to
  instantiate the attributes defined for that class. The only
  exception were the builtin classes Individual, Proposition, and
  Attribute whose instances are derived based on the structure of an
  object. Now, an object can instantiate the attributes of a class
  if it is an instance of the class, regardless whether instantiation
  is explicit or derived by a user-defined rule. If the rule is removed,
  then the instantiation of the attributes stays in the system.
  If you deem this too liberal, you can add a stronger axiom by a
  meta-level constraint that would universally detect if an object
  no longer is an instance of a class. See 
        CB-Forum/How-To/Define your own axioms 
  for an example. (Ticket 61)


70-09 Nested functional expressions in comparison literals

  Expressions like "(COUNT[ToUnit[~this/unit]/class] >= 2)" are now
  allowed in query definitions. Previously, one had to introduce auxiliary
  variables like in
   "exists n/Integer  (n in COUNT[ToUnit[~this/unit]/class]) and (n >= 2)".
  The new treatment of functional expressions improves readability
  of queries. (Ticket 46)


70-10 Quantifiers in deductive rules

  ConceptBase 6.1.2 and earlier imposed a strong restriction on the use of
  quantifiers in deductive rule: the forall-quantified variables of
  a rule had to be exactly the free variables in the conclusion literal.
  This restriction is now relaxed to: the free variables in the conclusion literal
  must be forall-quantified. For example a rule expression like
    $ forall x,y,z/C1 P1(x,y) and P2(y,z) ==> P3(x,z) $
  is now accepted. In ConceptBase 6.1.2 one had to define
    $ forall x,z/C1 (exists y/C1 P1(x,y) and P2(y,z)) ==> P3(x,z) $
  The old style is still accepted and is logically equivalent.
  If you have a meta-level rule with your ConceptBase 6.1.2
  installation that uses the old style for variable quantification,you
  might have to change it to the new style, however. See the HOW-TO section
  of the ConceptBase Forum for examples.


70-11 New infix-style literal (x m/n y)

  The AL literal now has an infix syntax as well. The AL literal is documented
  in the ConceptBase User manual.


70-12 Common syntax for infix literals

  Infix literals like (x < y), (x in C), (x m y) etc. are now required
  to be enclosed on parentheses. Before, one could also omit the
  parentheses like in "x in C and x < 10". The new restriction prevents
  phantom error messages issued by the formula parser.


70-13 Visibility of rules/constraints in modules

  Rules and constraints should only be checked if they are visible
  in the current module context. ConceptBase 6.1.2 missed some cases
  in checking visibility and thus evaluated some rules/constraints
  out of context. This is now resolved. Rules and constraints are
  now fully integrated into the module system of ConceptBase.


70-14 Faulty error messages on satisfied constraints
 
  Under rare circumstances, error messages were generated even though
  a constraint was satisfied. This is now solved. (Ticket 63)


70-15 Disabled popup-menus in graph editor

  The graph editor disabled the pop-up menue 'instance of' for some
  objects. This is now resolved. (Ticket 55)


70-16 Meta formula compiler now also analyzes Label literals 

  If a formula contains a literal like Label(x,m) where m is a
  variable, then ConceptBase treats the formula as a meta-formula,
  i.e. it tries to partially evaluate the formula to versions where
  m is bound to a constant. This behavior is consistent with the
  treatment of predicates (x m y). (Ticket 59)


70-17 COUNT function 10-200 times faster

  By re-implementing the internal code, the COUNT function is
  now much faster.


70-18 Large frames are constructed more efficiently

  Constructing large answer frames consumes less memory and is more
  efficient as well.


70-19 Queries with UNIFIES literals treated more efficiently

  UNIFIES predicates are evaluated as early as possible since they
  bind variables at low cost.


70-20 New function StringToLabel

  There is a new pre-defined function StringToLabel, which can be
  used in formulas. See ConceptBase User Manual for details.


70-21 More efficient data structure for cached literals

  The literal evaluation is in certain cases about 10 times faster
  than before by implementing a better data structure for the
  index of already called literals. Linear queries, i.e. queries
  that theoretically can be answered in linear time O(n), are now really
  answered in linear time. Before, there was a slight 
  quadratic component in the performance of the query evaluation.


70-22 New parameter -e (maxErrorMessages)

  The CBserver has a new command line parameter -e to limit
  number of error messages sent to a ConceptBase client as response
  to a transaction. This feature is useful in situations where
  a single transaction can generate literally hundreds of error messages.
  All error messages will still be displayed in the console window where the
  ConceptBase server has been started as long as the trace mode is set
  to 'low' or higher.


70-23 Removed legacy syntax for some literals

  The literal syntax AttrValue and AttrId is no longer supported.
  Use A or Ai instead.


70-24 Queries now also work with objects generated on the fly

  A query can cause the generation of new objects, in particular in
  combination with functions like COUNT. This disabled the cache-based
  literal evaluator, which was necessary to guarantee termination
  of query evaluation. This bug is now resolved. Objects generated
  on the fly will not disable the cache-based literal evaluator.
  (Ticket 66)

 
70-25 Multiple selection of objects in Display Instances

  The Display Instances dialog of the ConceptBase User Interface (CBiva)
  now allows to select multiple objects to be loaded into the Telos Editor.
  (Ticket 27)


70-26 Linewidth now correctly processed by Graph Editor

  The Graph Editor now correctly processes linewidth attributes defined
  in graphical types for link objects. (Ticket 36)


70-27 No more phantom links in graph editor 

  The graph editor allows to remove objects (including links) from
  the database. Under certain circumstances, it could occur that
  deleted links remained visible. This bug is now solved.


70-28 Old Tcl/Tk user interface removed from the distribution

  The old Tcl/Tk-based user interface CBworkbench has been removed
  from the distribution. CBworkbench is still contained in the
  CB 6.1.2 branch but is no longer fully compatible with CB 7.0 server,
  i.e., a CBworkbench can access a CB 7.0 server but not use all
  the functionality like switching the module context.
  We recommend to switch to the  Java-based user interface CBiva,
  which is the standard user interface of ConceptBase since version 6.1.2.


70-29 Attribute, IsA, and InstanceOf do not specialize Proposition

  The three O-Telos builtin objects Attribute, IsA, and InstanceOf are not
  longer explicit specializations of the object Proposition (being the
  most generic object in O-Telos). In fact, the explicit specialization is
  redundant since all objects (regardless whether an instance of Attribute,
  InstanceOf, IsA or Individual) are automatically also an instance of
  Proposition. As a user, you will not be affected by this change unless
  your application explicitly refers to the removed specialization 
  relationships (Attribute isA Proposition, InstanceOf isA Proposition,
  IsA isA Proposition). (Ticket 73)


70-30 Menues in graph editor context-sensitive

  The popup-menus for displaying incoming and outgoing links are now
  context-sensitive. Only those attribute categories are listed for which 
  the selected object has at least one attribute. This should make browsing
  more comfortable since the menus are much smaller. The added comfort
  comes at the expense of slighly longer reaction times, in particular when
  the operation is invoked the first time. 
  Along with this change comes a change with the predefined queries of
  ConceptBase. You should not access a database created with the old
  ConceptBase software with the graph editor of the new ConceptBase user
  interface. 


70-31 Default cachemode set to 'keep'

  The default cache mode (command line parameter -c) is now 'keep'. It used
  to be 'transient'. The 'keep' mode is more efficient in most cases. 
  You can explicitly set the cache mode to 'transient' if you prefer this
  mode. The maximum cache size has been updated to 50000 (was 15000) to
  cope with complex queries and to reduce the frequency of cache resets.
  See ConceptBase user manual, section on ConceptBase server, for
  more information.


70-32 User-defined functions

  You can now define instances of Function much like instances of
  GenericQueryClass. User-defined functions can then
  occur in functional expressions inside queries. See section
  "HOW-TO/Define Functions" of the CB-Forum for examples.


70-33 Error window in CBiva more readable

  The background color for error messages is now brighter for improved
  readability.


70-34 Comparison literals evaluated before all arguments bound

  Under certain circumstances, comparison literals like (x < y) were
  evaluated before its arguments x,y were bound to values. This
  is now resolved. (Ticket 77)


70-35 Stratification tests re-implemented

  The test on dynamic stratification has been re-implemented. It generates
  error messages if an attempt is made to prove P(x) under the assumption that
  not P(x) is true. The old test was failing to detect certain cases and 
  generated in other cases error messages even when there was no
  stratification violation. (Ticket 79)


70-36 Following derived attributes in graph editor

  Some derived attributes could not be followed in the graph editor.
  The case is linked to ticket 61 (see above: Objects can now use attributes of
  derived classes). If an object like x in instance to a class c by
  means of a rule, then it can use its attributes, e.g. to define a
  deductive rule about such an attribute.
  Precisely these deductive rules were not evaluated when one displayed
  an object like x in the graph editor and tried to follow the
  derived attributes of x. The error did not occur when evaluating
  queries. The problem is now fixed and one can follow derived attributes
  regardless on whether the case of ticket 61 is true or the regular
  case, i.e. x in an explicit instance of c. (Ticket 81)


70-37 Unstratified cache may not be reused

  If a stratification error is detected during query evaluation, the
  cache of derived facts is logically inconsistent (implying for some
  predicate that it is both true and false). In such a case, the cache
  should not be used for subsequent query processing. This regime is now 
  supported in ConceptBase 7.0.


70-38 ECA rules and integrity constraints

  ConceptBase 7.0 now fully integrates ECA rules with integrity checking.
  If an ECA rule updates the database, then this update is subjected
  to integrity checking. If a constraint is violated, the whole transaction
  (incl. the effect of ECA rules on the database) is rolled back. If
  an ECA rule has called an external program, e.g. for sending an email,
  then this part of the action cannot be rolled back. (Ticket 83)


70-39 Mutually dependent recursive rules

  Under certain circumstances, rule sets where one recursive rule R1
  depends on another recursive rule R2 which in turn depends on R1 could lead to
  incomplete answers. This is now solved. See EvenOdd.sml in
  the CB-Forum as example for mutually dependent rules/queries. (Ticket 85)


70-40 Improved Datalog code for queries

  Literals In(x,c) are replaced by c(x) in the Datalog code when c is
  a query class without parameters and retrieved/computed attributes. This
  can significantly improve the efficiency of query evaluation in case of
  recursive queries. (Ticket 86)


70-41 Avoid transformation of non-numerical objects into variables

  Comparison literals (x = y), (x < y) are not only allowed for numbers but
  virtually for any object. If an object has a name like ZERO (i.e. starting with
  a capital character), then ConceptBase transformed it into a variable
  following the Prolog convention for variables. This bug is now resolved.
  The evaluation of comparison literals is now about 10% faster than under
  ConceptBase 6.1.2. (Ticket 88)


70-42 Answer format for queries selectable at the user interface

  The window popping up when asking a query now includes a selection box
  for the answer format. By default, the answer format is set to 'FRAME'
  (=Telos frame syntax). Consult the user manual on how to specify customized
  answer formats. 


70-43 Module content listable

  The predicate A(m,contains,x) as well as (m contains x) can be used to
  check whether an object x is contained in a ConceptBase module m. 


70-44 Floating point numbers in Solaris-sparc variant 

  Floating point numbers in the Solaris-sparc variant are now displayed in
  the same way as in the other platform variants of ConceptBase. They
  are now consistently displayed by the shortest decimal representation
  coded '%g' in the C language, e.g. 19.81 instead of 1.9810000e+001.


70-45 Generic query classes excluded from integrity constraints and rules

  As explained in the user manual, query classes can be referred to 
  in integrity constraints and deductive rules. For technical reasons,
  generic query classes have to be excluded. Otherwise, certain
  integrity violations would not be detected. This exclusion is now
  ensured. (Ticket 90)


70-46 Active rules with more than one free variable

  Active rules (ECA rules) were limited to have at most one free variable
  in the IF part. This limitation is now removed. There is no limit
  in the number of free variables in the IF part. The DO part will be
  executed for any solution of the IF part binding the free variables to
  some constants. Conditions in active rules can now be arbitrary boolean
  expressions (and,or,not) over predicates testing the current and new database state.
  Examples for the new capabilities are in the HOW-TO section of the
  CB-Forum. (Ticket 83)

  
70-47 Depth attribute of active rules correctly interpreted

  Earlier releases of ConceptBase ignored the depth attribute. This bug
  is now corrected. You can now protect your ECA rules against 
  infinite loops if you know a limit for the maximum number of calls
  to an ECA rule within one transaction.

  
70-48 Multiple updates to the same object in one transaction

  ConceptBase now allows to untell/tell the same object (in particular attribute)
  in a single transaction. This feature is only applicable when evaluating
  active rules. Such rules can now untell/tell the same object several times,
  for example due to multiple firings of active rules in one transaction.
  Only the final state of an object will be made persistent after the transaction
  has committed. (Ticket 92)


70-49 FIFO sequencing of ECA rule firings

  ECA rules with modes ImmediateDeferred and Deferred used to by evaluated 
  with a last-in-first-out (LIFO) strategy, i.e. the most recent fired ECA rule would
  be executed first. This strategy can lead to incorrect results since a
  current ECA rule might not have been fully executed when a new ECA rule is
  already started. To avoid this 'racing condition', ConceptBase now enforces
  a strict FIFO sequencing of ECA rule executions. (Ticket 93)


70-50 Hostname included in registration message of ConceptBase client

  A client such as CBiva registering to a ConceptBase server shall now include
  the name of the local host in the registration message (ENROLL_ME). If the
  hostname cannot be retrieved locally, the label "unknownhost" is used.
  This change does not impact the functionality of ConceptBase. The transmitted
  hostname shall be displayed with the corresponding ENROLL_ME message in the
  console window of the ConceptBase server. Besides this, a small bug in checking
  the user name on Windows platforms was solved. (Ticket 95)


70-51 Checking on first/last frame in answer formats

  The answer formatting utility of ConceptBase now adheres to two new predicates
  ISFIRSTFRAME() and ISLASTFRAME(). They can be used in the IFTHENELSE construct.
  (Ticket 30)


70-52 Self-triggering ECA rules evaluated more efficiently

  Active rules whose actions part matches its event can trigger themselves
  or other active rules. Typically such rules (or rule systems) are generating
  a lot of triggers and push ConceptBase to its limits. By several measures,
  the efficiency of the ECA rule evaluator has been improved by up to 20%. Among others, 
  duplicates in the trigger pipeline are avoided, processed triggers
  are garbage-collected and the set-oriented interface of the object store 
  is utilized to get all new objects in a single call. Simple ECA rules do not
  benefit from these improvements. Examples on self-triggering ECA rules
  can be found in the HOW-TO section of the CB-Forum.


70-53 UNTELL now inverse to TELL if UntellMode=cleanup

  There is a new command line option -U (UntellMode) by which the behavior of the
  UNTELL operation can be controlled. If set to 'cleanup', UNTELL will try to remove
  exactly those P-facts inserted by the TELL operation executed on the same frame.
  This type of behavior (UNTELL(x) is the reverse of TELL(x)) is expected by
  many users of ConceptBase. The default value for UntellMode is 'verbatim', i.e.
  only the facts specifically contained in the frame are untold. The ConceptBase user
  manual contains more on this. (Ticket 98)


70-54 Correct handling of nested query calls

  A query call has in general the format Q[x1/p1,...,xn/pn]. It can be that some
  value x is itself a query call. We call such expressions nested query calls.
  ConceptBase did not handle the evaluation correctly when the cache mode was
  'transient' or 'keep'. This is now corrected. (Ticket 99) 


70-55 New predicate Terminated

  The new predicate Terminated(x,t) allows to retrieve the time at which an object
  is no longer visible in the object base. This is the time when the object has been
  untold. It will return "tt(infinity)" if the object has not yet been untold. (Ticket 100)


70-56 ASK can update the database

  Intuitively, a query (ASK) to a database does not change its contents. There are two
  cases where this general does not apply. First, the query can be a so-called builtin
  query, i.e. a query that is implemented by user-definable code. Such queries are allowed
  to do basically any kind of update and the update will remain persistent after the call
  of the query. Second, the call of a query may match the ON part of an ECA rule, hence
  triggering it. The effect of such a triggering can be an update to the database. It
  will be persistent as well. If a query is asked on a historical rollback time (i.e., on
  a past state of the database), then ECA rule triggering is disabled. Furthermore, queries
  that are asked by their frame definition rather than by the query call expression Q[params]
  will also not be allowed to trigger ECA rules. Queries asked as frames are typically
  only defined during the ASK transaction. They should not leave a trace in the database.
  Earlier version of ConceptBase prevented query calls from updating the database persistently.
  (Ticket 102)


70-57 Menu item Ask Objname renamed

  The menu item Edit/Ask Objname of CBiva has been renamed to Edit/Ask Query Call. This is
  a more logical label for the function.


70-58 Unique names for temporary object bases

  When the CBserver is started in nonpersistent mode, it will create a temporary directory
  in the file system of computer running ConceptBase. ConceptBase had been using then process
  identifier to create a unique name for the directory. This is however not unique. The 
  operating system only uses a limited number digits for process ids. Hence, it can happen
  that a CBserver is assigned an existing temporary directory name. To avoid this, ConceptBase
  now uses a different method based on the system clock. This should avoid failures
  to start the CBserver in case of double-used directory names.


70-59 CBserver script now Bourne shell

  The Linux/Unix script CBserver used to be a C-shell script, i.e. it requires that csh
  (or tcsh) is installed on the computer where the CBserver is started. Many OS platforms
  like Linux or Mac OS-X do not have csh pre-installed but only the Bourne shell sh.
  For that reason, we have translated CBserver to a Bourne shell script. Thus, no need
  to install csh or tcsh anymore. The Windows variant is not affected by this change.


70-60 Answers ordered by object identifier

   The answer formatting system of ConceptBase allows to order the answer to a query 
   according to different criteria, e.g. the object name or the value of an attribute.
   ConceptBase 7.0 now allows to order the answer also according to the object 
   identifier. Set the attribute orderBy of the answer format to "this.oid" to
   enable this feature. Since object identifiers are assigned in ascending order,
   ordering by it delivers the objects in the order in which they were created in the
   database. (Ticket 108)


70-61 Additional parameters for answer formatting

   Answer formats can now substitute parameters of the query call inside the head, tail and
   pattern strings. So, if the query call was Q[val/param] then the string {param}
   will be replaced by val. Moreover, there are predefined parameters {user} for the
   name of the current user, {transactiontime} for the time when the current transaction
   was started, {cb_version} for the version number of ConceptBase, plus some more that
   are not documented. 


70-62 Operator .oid can be used as tail of any path expression in answer formats

   In earlier releases of ConceptBase, only this.oid was supported as path expression
   for displaying the oid of an object in an answer format. Now, you can also use it
   in any path expression, e.g. {this.outputattr.oid}.


70-63 Validate shown objects missed retell-case

   The option 'Validate shown objects' of the graph editor missed cases where 
   a RETELL operation had changed the database before. This flaw is now corrected.
   (Ticket 84)


70-64 Derived attributes more readable in graph editor

   Derived attributes were displayed by dotted lined with label 'deduced'.
   This made is difficult to distinguish derived attributes with different
   attribute categories. This is now solved. Instead of 'derived', the graph editor
   now uses the attribute category as the label. (Ticket 82)


70-65 Division by zero hooked at CBserver

   Division by zero, e.g. IDIV[1/i1/0/i2] or DIV[1/r1/0/r2] will no longer crash
   the CBserver. It used to be detected by the underlying Prolog runtime system. Now,
   an attempt to divide by zero is detected by the CBserver and leads to an
   error message sent to the client. (Ticket 115)


70-66 Ordering of generated rules influenced integrity evaluator

   Under rare circumstances, the ordering of clauses generated from deductive 
   rules could have a negative impact on the correct evaluation of integrity 
   constraints, and also on query evaluation. This bug is now solved. (Ticket 119)


70-67 Blanks in directory paths and user names

   Following ISO conventions, directory and file names should not contain special
   characters such as blanks. However, operating platforms like Windows are not 
   following this ISO convention, e.g. like in C:\Program Files. Installing ConceptBase
   into such directories rendered some scripts of ConceptBase un-operational.
   As such file names are becoming more and more frequent, ConceptBase now can operate
   in their presence. Similarily, user names may also contain blanks now. Still, we
   recommend to install ConceptBase into directories whose absolute path does not
   contain special characters, e.g. C:\ConceptBase rather than C:\Program Files\ConceptBase.
   The Linux/Unix versions of ConceptBase must continue to use proper ISO-compliant directory
   paths. (Tickets 109,112,117)


70-68 Problem with special characters like umlauts resolved

   Umlauts and other special characters could cause crashes of the CBserver on some platforms
   like Windows and Linux because they could not be stored on an internal logfile.
   Since the logfile is no longer used by the CBserver, this problem has now vanished.
   (Ticket 121)


70-69 Functions to be evaluated with maximally bound arguments

   Arithmetic functions like PLUS should only be evaluated when all arguments are bound
   to constants. ConceptBase now pushes the evaluation of such functions towards the end
   of the executable Datalog code in order to fulfill this requirement. (Tickets 122,125)


70-70 Second evaluation of arithmetic function could crash the server

   The ConceptBase server could crash under rare circumstances when a query containing
   arithmetic functions was evaluated twice, i.e. in two consecutive ASK operations.
   The reason was that intermediate results were stored as temporary objects and as
   entries in the query cache. While the temporary objects are removed after a transaction,
   the query cache remains active by default. That could lead to inconsistencies and
   attempts to access non-existing memory addresses. The problem is now solved. (Ticket 123)


70-71 Untell in update mode cleanup could crash the server

   Under very rare circumstances, an untell operation could send the server in a loop that
   ultimately ended with a stack overflow. The problem only occurred when the update mode
   mode was set to cleanup and recursive rules with specific patterns were defined before.
   Since the update mode is by default set to 'verbatim', hardly any user ever experienced
   this problem. The bug is now resolved. (Ticket 126)


70-72 View maintenance disabled by default

   The CBserver parameter -v (ViewMaintenanceRules) is set by default to 'off', i.e.
   no view maintenance rules are generated. Normal usages of ConceptBase are not
   affected by this change (except that the Tell operation is faster). You can 
   enable the view maintenance rule generation by starting the CBserver with parameter 
   -v set to 'on'. The view maintenance feature is not yet discussed in the user 
   manual, hence it should be disabled by default.


70-73 Problems to display 'class' attributes in graph editor

   If some attribute was defined as instance of Class (which is an unusual use of
   the object Class), then ConceptBase regarded the object as a class-like object
   in the graph editor. By default such objects are displayed as nodes with blue background.
   However, attributes are links that can not be displayed as nodes. The problem is
   now solved. (Ticket 131)
   



Issues
======

* The new Java 6 runtime environment is not yet fully supported by ConceptBase.
  Use Java 5 (1.5) or Java 1.4 instead.

* Mac OS-X users might have to install the library libreadline.5.0.dylib
  (package readline available thru darwinports) to the directory /usr/local/lib.

* Linux and Solaris users need to make sure that libstdc++.so.6 is installed on their
  systems. It is part for example of the Gnu CC 4.1 package but can also be installed
  separately from the Gnu CC package.

* Objects names and attribute labels starting with 'id_' should be
  avoided since ConceptBase uses this prefix to characterize
  internal object identifiers. Likewise, no object name should 
  start with 'xX' since this is used internally to characterize
  variable positions during query evaluation.

* The nodes sizes in the graph editor are not recomputed when the
  graph palette (assignment of graphical types to displayed objects) is
  changed. This can lead to truncation of object labels when the new
  graphical type is smaller than the initial one. You may try the
  operation  'Current connection / Validate and update shown objects' to
  circumvene this behavior.

* When a complex graph (e.g. links from links to other links) is displayed
  and the user moves a node around the windows, the reference points of
  some links can be set to arbitrary locations. 

* The TCP/IP interface between the CBserver and a client has a builtin
  delay that slows down transaction streams (series of many consecutive
  transactions). This makes the start-up of the graph editor a bit slow since
  the graph editor issues long streams of transactions when displaying objects.

* The Solaris version occasionally has problems with passing parameterized
  query calls from a ConceptBase client to the CBserver. Use 'Ask Query Call'
  with an explicit query call like 'Q[x/param]' to circumvene this problem.
  Other platforms do not suffer from this problem.

* Aggregation functions like COUNT should not be used in integrity constraints
  or rules since the incremental constraint checker cannot maintain
  the extension (=set of all ground solutions) of aggregation functions.
  There are however tricks to cope with certain usage patterns. See section
   HOW-TO / Avoid traps with aggregation functions in constraints
  in the CB-Forum.

* The rollback time mechanism (CBiva: Options / Select Version) can be used
  to query past database states. This feature does not work currently under
  Windows when the daylight saving ('summer time') is activated. In countries
  of the northern hemisphere, daylight saving is usually activated between end
  march and end october of the year. 
  Outside this time and on other platforms (Solaris, Linux, Mac OS), there
  should be no problems.

* When ECA rules update the database, ConceptBase will automatically disable the cache-
  based query evaluator. The cache would be invalid because of the update.
  Instead, ConceptBase will use the standard Prolog-style query evaluator. Since
  the ON-part of an ECA rule can call the query (literal) evaluator, calls to
  recursive predicates could run into infinite loops. 

* If you terminate a nonpersistent ConceptBase server by Control-C or by killing
  the corresponding process, then the temporary database continues to exist in the
  directory of temporary files (usually /tmp under Unix and C:\Temp under Windows).
  This is as such not a problem but over time the temporary databases can consume
  more and more disk space. We advise to remove every 12 months these dead databases.
  The directories have the names <username><digits> where <username> is the name
  of the user that started the server and <digits> is a sequence of digits and underscores.

* Be carefull with the -r parameter of CBserver under Linux/Unix. It can potentially
  cause an infinite loop when the CBserver executable crashes at startup. 
  Besides, the -r option is very useful if you want a to provide a stable
  service based on ConceptBase. It will restart the CBserver executable whenever 
  it has crashed (crashes are very hard to trigger anyway). The -r option is
  not available under Windows due to the limited scripting support under Windows.



Transition of ConceptBase 6.1.2 to ConceptBase 7.0
==================================================

Most Telos source models (*.sml) produced by ConceptBase 6.1.2 should be readable
without change by ConceptBase 7.0. However there are the following restrictions:

R1: The old predicate names AttrValue and AttrId are no longer supported. Use A(x,m,y)
    instead AttrValue(x,m,y) and Ai(a,m,o) instead of AttrId(x,m,o).

R2: All infix predicates need to be enclosed in parantheses. 

      Old              New
      -------------------------
      x in c           (x in c)
      c isA d          (c isA d)
      x < y            (x < y)
      ...              ...

R3: The use of the variable name 'this' without preceding tilde character is
    deprecated in version 7.0. Use '~this' instead of 'this'.

R4: Variables in deductive rules should be universally quantified, i.e.
    instead of
      forall x/C (exists y/D cond(x,y)) ==> P(x)
    your should write
      forall x/C y/D cond(x,y) ==> P(x)
    The old style is still working but may cause problems if the deductive
    rule is a so-called meta-formula.


Binary databases created with version 6.1.2 are not directly processable by
ConceptBase 7.0. You need to extract the concept definitions from the old database
by using ConceptBase 6.1.2 into a Telos source model (*.sml) and then tell
the definitions to the new ConceptBase 7.0. The ConceptBase Forum contains utilities
to partly automate this task, see section "HOW-TO/Save Telos models" in the CB-Forum.





Notes
=====

The CB-Forum is a workspace where ConceptBase users and developers share
documents, models, and software. The address is
      http://merkur.informatik.rwth-aachen.de/bscw/bscw.cgi/0/187789



Trademarks
==========

All trademarks used in this text are property of their respective owners.


Acknowledgments
===============

We thanks all ConceptBase users for their valuable feedback. 
We thank the SWI-Prolog for their excellent work and support.



-------------------------------------------------------------------------------------------------


                    CONCEPTBASE
   RELEASE NOTES for Version 7.1.x (post-release version)

   Manfred Jeusfeld, Christoph Quix, Matthias Jarke
                   ConceptBase Team

    http://www-i5.informatik.rwth-aachen.de/CBdoc/
                 http://conceptbase.cc

                     10-Jul-2008


ConceptBase is a multi-user deductive object manager developed at 
RWTH Aachen and Tilburg University. This document lists the changes 
to ConceptBase 7.1 after the official release on 29-May-2008. 
ConceptBase 7.1.x is available via the ConceptBase-Forum.
      http://merkur.informatik.rwth-aachen.de/bscw/bscw.cgi/0/187789




Detailed Changes
================


P71-01 Bug with optimization of From/To resolved

  The semantic optimizer had a faulty rule for dealing with From/To predicates.
  It could lead under ceryain circumstances to a crash of the system. This is
  now resolved
  (Ticket 180)

P71-02 Value as parameters created as objects

  If a query is called with a value (a number or a string) as a parameter, then
  ConceptBase will first create the value as an instance of its type (Integer,
  Real, String) before evaluating the query. This allows to formulate more
  easily query calls involving values.
  (Ticket 181)

P71-03 ASKquery with more than one parameter in answer formats

  The ASKquery function for answer formats could only support queries 
  with a single argument. This restriction is now lifted.
  (Ticket 182)

P71-04 CBshell can be used in shell pipes

  The CBserver shall now be silent on stdout when the tracemode is set to 'no'.
  This allows the use of CBshell as a filter in Unix pipes. For example, one can
  let ConceptBase generate some XML output and have it automatically passed to
  a subsequent post-processor. Another example is the generation of GraphViz
  specifications (graph layouts).
  (Ticket 183)

P71-05 Print source & destination of elements in answer formats

  The answer transformer can now print the source and destination of an answer element, 
  e.g. {From(x)}, {To(x)} much like for the ASKquery construct. It simplifies
  answer formatting where answer elements are attributes. ConceptBase also supports
  the patterns {Oid(x)} and {Label(x)}. 
  (Ticket 184)

P71-06 Function patterns protected against calls to undefined procedures

   Answer formats may contain so-called function patterns like {F(x)}. If the
   function F is undefined, ConceptBase crashed. This is now resolved.

P71-07 Problems with certain query constraints resolved

   Certain queries with parameters that use an equality predicate in their constraint
   could cause a fatal crash. This is now solved.
   (Ticket 185)

P71-08 Alias for command line parameter -p

   The CBserver script now support -port as an alias for the -p option. The -p option
   continues to be supported. The label -port avoids a minor conflict with the
   underlying Prolog engine.

P71-09 Improved performance for loading Telos models with many formulas

   The efficiency of the parser and integrity checker has been improved for large Telos
   models with many rules and constraints (in the range of thousands of formulas).
   Thanks go to Simone Ludwig for pointing us to the issue.
   (Ticket 186) 

P71-10 More efficient implementation of (x m/l y)

   The predicate (x m/l y) a.k.a AL(x,ml,l,y)  is now implemented more efficiently. It is about
   10% faster for small databases and up to 10 times faster for larger databases.
   As a side-effect, the COUNT_Attribute query enjoys the same speed-up.
   Thanks go to Simone Ludwig for pointing us to the issue.
   (Ticket 164)