Mercury [] also generates artifact-based notifications for collaborators but displays them within the context of the artifact and automatically determines the users who receive them based on the artifacts they are manipulating. The artifacts are programs comprised of distributed modules, with a single programmer responsible for a module. The system allows different programmers to simultaneously view and modify different modules of the program, but allows a particular module to be viewed and modified by only its owner.
Mercury is derived from the technology of language-based editors. These editors understand the structure, syntax, and semantics of the underlying program and inform users incrementally about syntax and semantic errors. Mercury extends this notion by incrementally informing the, possibly distributed, programmers responsible for a program about errors in the interfaces of the modules they are editing. When a programmer makes a change to the interface exported by a module that is inconsistent with an importing module being viewed by another programmer, Mercury incrementally informs the latter about the error. Mercury also supports ``what-if'' scenarios that allow programmers to see if changes made by them would cause errors in the modules of others.
Mercury puts a ``firewall'' around a module that is in an inconsistent state and does not check its consistency with other changing modules
until the module is committed by its owner. As a result, spurious error messages will not be generated if two programmers simultaneously make changes that are individually but not collectively inconsistent with the original program. If an interface change in one module causes an error in a module whose machine is not connected or whose owner is not viewing it, then Mercury stores the information and displays the error message the first time the module is viewed by its owner after the connection is reestablished.