antipatterns ├── Anti-pattern: advanced messaging systems ├── Anti-patterns ├── Anti-pattern: defer critical decisions ├── Anti-pattern: distributed dead-lock detection ├── Anti-pattern: distributed transactions ├── Anti-pattern: entity-attribute-value (EAV) ├── Anti-pattern: EDA message notifications at enterprise level ├── Comments on Enterprise Integration Patterns ├── Anti-pattern: excessive frameworks ├── Anti-pattern: excessive loose coupling ├── Approaches for high performance distributed workloads in CEDA ├── Anti-pattern: horizontal slicing with n-tier architectures at large scales ├── Anti-pattern: inadequate Persistence System ├── Anti-pattern: interleaving computation and I/O ├── Kafka ├── Anti-pattern: location transparency ├── Anti-pattern: messages types are public interfaces ├── Anti-pattern: more is less ├── Multiplexing pattern ├── Anti-pattern: O/R Mapping ├── Anti-pattern: orthogonal persistence ├── Anti-pattern: persist state machines ├── Reliable messaging talk by Udi Dahan ├── Sales,invoice,shipping services example ├── Antipattern: Service Oriented Architecture (SOA) ├── Anti-pattern: state machine instead of datatype ├── Anti-pattern: synchronous IPC messages ├── Antipattern: test internals ├── Anti-pattern: thread-safe data types ├── Anti-pattern: unnecessary persistence └── Anti-pattern: using OO where the RM is more appropriate
ceda ├── CEDA ├── Embedded database ├── Notes ├── build-system │ └── cmake │ └── How cmake is used to build ceda based projects ├── cache │ ├── Object caching in CEDA │ ├── Client-server model │ └── Peer to peer model ├── constraints │ ├── Availability of services │ ├── Constrained variables cannot be edited in-place │ ├── Constraints ⇒ slow updates │ ├── Constraints ⇒ hide problems │ ├── Constraints ⇒ risk deadlocks │ ├── Constraints ⇒ fallible updates │ ├── Constraints ⇒ OT is intractable │ ├── Constraints ⇒ can't record partial information │ ├── Constraints ⇒ can't record conflicts │ ├── Constraints ⇒ drafts not managed by DBMS │ ├── Constraints ⇒ complex updates │ ├── Constraints │ ├── CQRS │ ├── Data warehousing │ ├── Conventional approaches to editing data with complex constraints │ ├── Events database │ ├── In-place data entry │ ├── Incremental computing on the derived variables │ ├── Long running business processes │ ├── MVCC │ ├── No race conditions │ ├── Non-canonical representations │ ├── Optimise both read and write performance │ ├── Driving variables through a complicated space │ ├── Reactive programming │ ├── Security │ ├── Simplicity of in-place editing of unconstrained base variables │ ├── Stale reads │ ├── Validation of forms │ └── Which variables to materialise? ├── data-centric-principle │ └── The Data-Centric Principle ├── demos │ ├── CEDA Demonstration programs │ ├── jigsaw │ │ └── Drawing instructions │ └── multiresimage │ └── MultiResImage ├── deployment │ └── Deployment ├── downloads │ ├── CEDA downloads │ ├── Emscripten tests │ ├── java │ │ ├── JNI for the ceda namespace │ │ ├── Generating JNI with a python script │ │ ├── Java development with CEDA │ │ ├── Java Development Kit (JDK) │ │ └── JNI example │ ├── linux │ │ ├── Check CEDA SDK │ │ ├── Ceda SDK for Ubuntu Linux │ │ └── Set up Linux Virtual Machine │ ├── python │ │ └── pyceda │ ├── test │ │ └── Test 1 │ ├── test2 │ │ └── Test 2 │ ├── test3 │ │ └── Test 3 │ ├── test4 │ │ └── Test 4 │ ├── test5 │ │ └── Test 5 │ ├── test6 │ │ └── Test 6 │ ├── test7 │ │ └── Test 7 │ └── windows │ ├── Building boost for android │ ├── CMake build phases │ ├── How CEDA cmake config supports multiple platforms │ ├── Targeting Android on a Windows development machine │ ├── Using clang compiler with Visual Studio │ └── Ceda SDK for Windows ├── fallacies │ ├── CAP Theorem │ └── The fallacies of distributed computing ├── libs │ ├── CEDA Core Libraries │ ├── CEDA Core public header files │ ├── cxLss │ │ ├── Assumptions on the hard-disk │ │ ├── Backup and hot standby for the LSS │ │ ├── Check pointing │ │ ├── Cleaning │ │ ├── Clustering │ │ ├── CreateOrOpenLSS │ │ ├── Durability │ │ ├── IContiguousSerialElement │ │ ├── ILogStructuredStore │ │ ├── ILssTransaction │ │ ├── Lazy writer │ │ ├── CEDA LSS API │ │ ├── LSS - Under the hood │ │ ├── Log structured store versus Write ahead logging │ │ ├── Log Structured Store (LSS) │ │ ├── LssApplyDeltas.exe │ │ ├── LssCompare.exe │ │ ├── LssDumpSettings │ │ ├── LssSettings │ │ ├── LssStats │ │ ├── MSSN │ │ ├── Reading serial elements │ │ ├── ReadOnlyBuffer │ │ ├── Seid allocation │ │ ├── Seid │ │ ├── Serial element │ │ ├── Writing serial elements │ │ └── performance │ │ ├── Kyoto Cabinet ingestion rate measurement │ │ ├── Kyoto Cabinet without tuning │ │ ├── LSS performance measurement code │ │ ├── CEDA LSS versus Oracle BerkeleyDB │ │ ├── NuoDB ingestion rate measurement │ │ └── LSS Performance │ ├── cxMessage │ │ ├── BufferedMessageWriter │ │ ├── cxMessage library │ │ ├── IMessageReader │ │ ├── IMessageWriter │ │ ├── IMultiplexedMsgHandler │ │ ├── Iocp │ │ ├── ISocketConnectionAcceptor │ │ ├── ITcpEndpoint │ │ ├── ITcpMsgHandler │ │ ├── MessageReaderSettings │ │ ├── MessageWriterSettings │ │ ├── MsgReader │ │ ├── MsgWriter │ │ ├── MultiplexedMsgConnection │ │ ├── TcpClient │ │ ├── TcpMsgConnection │ │ └── TcpServer │ ├── cxMessage2 │ │ ├── cxMessage2 library │ │ ├── EEndPointFailureType │ │ ├── EProtocol │ │ ├── ESessionFailureType │ │ ├── IoContextPool │ │ ├── ITcpMsgEndPoint │ │ ├── ITcpMsgSession │ │ ├── ITcpMsgSessionHandler │ │ ├── MessageReaderSettings │ │ ├── MessageWriterSettings │ │ ├── MsgReadBuffer │ │ ├── MsgWriteBuffer │ │ ├── TcpMsgClient │ │ ├── TcpMsgServer │ │ ├── TcpMsgSession │ │ ├── TcpMsgSessionSettings │ │ ├── TcpSettings │ │ └── WriteMessageResult │ ├── cxObject │ │ ├── Basic types │ │ ├── cxObject library │ │ ├── Library and executable versioning │ │ ├── Metadata on reflected types │ │ ├── cspace │ │ │ ├── $new │ │ │ ├── Create a CSpace │ │ │ ├── CSpace DGS functions │ │ │ ├── CSpace Garbage Collector │ │ │ ├── CSpace GC extent │ │ │ ├── CSpace GC roots │ │ │ ├── CSpace in thread local storage │ │ │ ├── CSpace Mutex │ │ │ ├── CSpace │ │ │ ├── CSpaceLock │ │ │ ├── CSpaceRelinquishLock │ │ │ ├── CSpaceTxn │ │ │ ├── ECSpaceLockMode │ │ │ ├── Exceptions thrown while lock a CSpace │ │ │ ├── gcroot │ │ │ ├── LockInfo │ │ │ ├── Locking multiple CSpaces │ │ │ ├── TransferCSpace │ │ │ └── Object visiting │ │ ├── dgs │ │ │ ├── Cache Functions │ │ │ ├── Dependency Graph System (DGS) │ │ │ └── Using the observer pattern to update dependent variables │ │ └── reflection │ │ ├── CreateClassVariableFn │ │ ├── EReflectedClassBits │ │ ├── EReflectedVectorCode │ │ ├── Fully qualified name │ │ ├── FunctionPointer │ │ ├── Generate operations on reflected vectors │ │ ├── Get reflected type │ │ ├── IBiDirIterator │ │ ├── IKeyType │ │ ├── IReflectedException │ │ ├── IXMap │ │ ├── IXSet │ │ ├── Print reflected type │ │ ├── PrintTypeSettings │ │ ├── PtrMapOrSetFns │ │ ├── Reflected vectors │ │ ├── ReflectedArg │ │ ├── ReflectedAttribute │ │ ├── ReflectedClass │ │ ├── ReflectedClassMethod │ │ ├── ReflectedDepField │ │ ├── ReflectedEnum │ │ ├── ReflectedField │ │ ├── ReflectedFunction │ │ ├── ReflectedFunctor │ │ ├── ReflectedGlobalFunction │ │ ├── ReflectedGlobalVariable │ │ ├── ReflectedInterface │ │ ├── ReflectedInterfaceMethod │ │ ├── ReflectedModelField │ │ ├── ReflectedReturnType │ │ ├── ReflectedTypedef │ │ ├── ReflectedVariant │ │ ├── Reflection │ │ ├── TypeOps │ │ ├── byte-code │ │ │ ├── Byte code representation of types │ │ │ ├── EByteCodeQualifier │ │ │ ├── ETypeByteCode │ │ │ ├── Grammar for byte code representation of reflected types │ │ │ ├── Metadata byte code │ │ │ ├── ReflectionByteCode │ │ │ └── String table to support byte code │ │ ├── fn │ │ │ ├── Assign reflected variables │ │ │ ├── Coerce reflected variables │ │ │ ├── Construct reflected variables │ │ │ ├── Copy construct reflected variables │ │ │ ├── Deserialise reflected variables │ │ │ ├── Destruct reflected variables │ │ │ ├── Equality comparison on reflected variables │ │ │ ├── Operations on reflected variables │ │ │ ├── Less than comparison on reflected variables │ │ │ ├── Print reflected variables │ │ │ ├── Scan over serialised reflected variables │ │ │ └── Serialise reflected variables │ │ └── registry │ │ ├── ENameSpaceError │ │ ├── Reflected │ │ ├── Reflection registries │ │ └── Reflected │ ├── cxOperation │ │ ├── Airline Reservation Example │ │ ├── Custodians │ │ ├── cxOperation library │ │ ├── DataSetId │ │ ├── DeltaRW │ │ ├── Drawing Example │ │ ├── IMoreToSend │ │ ├── In-process synchronisation between working sets │ │ ├── Open a WorkingSetMachine │ │ ├── ROD Objects │ │ ├── RodSession │ │ ├── Site Identifiers │ │ ├── Universal Tree │ │ ├── UTRoot │ │ ├── Working Set │ │ └── WorkingSetMachine │ ├── cxPersistStore │ │ ├── Class name translation │ │ ├── Context of object │ │ ├── Exception safety and persistence │ │ ├── Implement an IPersistable object │ │ ├── cxPersistStore library │ │ ├── IPersistable │ │ ├── OID │ │ ├── OID space │ │ ├── OidSpaceMap │ │ ├── Open a PersistStore │ │ ├── Orthogonal persistence │ │ ├── Persistent object trees │ │ ├── PersistStore │ │ ├── PersistStoreSettings │ │ ├── PersistStoreTxn │ │ ├── prefs and crefs │ │ ├── PSpaceLockMode │ │ ├── Reserved OIDs │ │ └── PSpace │ │ ├── Allocate OIDs to new objects in the PSpace │ │ ├── PSpace Async Bind Methods │ │ ├── IAsyncBindRequestHandler │ │ ├── PSpace │ │ ├── MAsyncBind │ │ ├── PSpace named roots │ │ ├── Deleting objects in a PSpace │ │ ├── PSpace in thread local storage │ │ └── PSpace synchronous bind methods │ ├── cxPython │ │ ├── Python bindings - ADTs │ │ ├── Python bindings - arrays │ │ ├── cxPython library │ │ ├── Python bindings - exceptions │ │ ├── Python bindings - global functions │ │ ├── Python bindings - global variables │ │ ├── Python bindings - int32 variable │ │ ├── Python bindings - interfaces │ │ ├── Python bindings - models │ │ ├── Python bindings - namespaces │ │ ├── Pizza deliveries database Example │ │ ├── Python bindings - pointers │ │ ├── Python bindings - reflection │ │ ├── Python bindings - values versus variables │ │ ├── Python bindings - variants │ │ └── Python bindings - vectors │ ├── cxRmi │ │ ├── cxRmi Performance Test Code │ │ ├── CreateRmiCallee() │ │ ├── CreateRmiCaller() │ │ ├── cxRmi library │ │ ├── Interface to define a message protocol │ │ ├── IRmiCallerHandler │ │ ├── Issuing calls through the stub │ │ ├── cxRmi Performance │ │ ├── RmiCaller │ │ ├── Throttling the producer │ │ ├── Use of MultiplexedMsgConnection │ │ └── zeroc-ice │ │ └── Code for performance testing with ZeroC Ice │ ├── cxThread │ │ ├── cxThread library │ │ ├── ITaskExecuter │ │ ├── IThreadPool │ │ └── ThreadPoolTask │ ├── cxUtils │ │ ├── Archive │ │ ├── Variable length serialisation of integers │ │ ├── ConstStringZ │ │ ├── cxUtils library │ │ ├── EOpenMode │ │ ├── InputArchive │ │ ├── OutputArchive │ │ ├── Serialisation performance │ │ ├── Serialisation │ │ ├── SizeArchive │ │ └── Stream interfaces │ └── cxWorkingSetIpc │ ├── cxWorkingSetIpc library │ ├── IMwsipcSessionHandler │ ├── MwsipcSession │ ├── Single working set IPC functions │ ├── WsipcHostInfo │ └── WsipcSessionProtocolId ├── messaging │ ├── ATMs │ ├── Preventing double spending without consensus │ ├── Bank transfers without distributed transactions │ ├── Making an on-line purchase │ ├── Messaging done right │ ├── Multiple producer and consumer generalisation of a persistent queue │ ├── Not materialising the persistent queue │ ├── Producer/consumer with a persistent queue │ ├── Queued Transactions │ ├── Long running transactions (sagas) │ ├── SQL Server Service Broker │ └── Transient message queues ├── ot │ ├── Assignment │ ├── Amount of information in a value │ ├── Mapped values │ ├── Operational Transformation │ ├── Selective undo │ ├── lattice │ │ ├── Hasse Diagram of a finite poset (mathematics) │ │ ├── The lattice of database states │ │ ├── Lattice (mathematics) │ │ ├── Partially ordered set (mathematics) │ │ └── Infimum and Supremum (mathematics) │ ├── ot-control │ │ ├── Apache Wave │ │ └── Operational Transform Control Algorithms │ └── ot-on-text │ └── Operational Transformation On Text ├── papers │ └── Papers ├── presentation-2007 │ └── CEDA Presentation 2007 ├── samples │ ├── Ceda sample programs │ ├── exCedaScript │ │ └── exCedaScript │ ├── exLss │ │ └── exLss │ ├── exObject │ │ └── exObject │ ├── exOperation │ │ └── exOperation │ ├── exPersistStore │ │ └── exPersistStore │ ├── exPython │ │ └── exPython │ ├── exPython2 │ │ └── exPython2 │ ├── exRmi │ │ └── exRmi │ ├── exThread │ │ └── exThread │ └── Pizza │ ├── ConsoleTest │ ├── Shape, Time and Pizza - Xc++ libraries built with CMake │ ├── Pizza sample program │ ├── Pizza library │ ├── pypizza python package │ ├── Shapes library │ └── Time library ├── Xc++ │ ├── String data types │ ├── Xc++ warning codes │ ├── Xc++ │ ├── $adt │ │ └── $adt │ ├── $class │ │ ├── $class and $struct │ │ ├── Default constructors │ │ └── Directives │ ├── $enum │ │ └── $enum │ ├── $function │ │ └── $function │ ├── $functor │ │ └── $functor │ ├── $interface │ │ ├── Abstract Base Classes │ │ ├── Advantages of interfaces over abstract base classes │ │ ├── CDPlayer example │ │ ├── Interface Inheritance │ │ ├── Interfaces - Under the hood │ │ ├── $interface │ │ ├── IObject │ │ ├── Poor performance of C++ virtual inheritance │ │ └── unique_interface_ptr │ ├── $mixin │ │ ├── Anonymous Mixins │ │ ├── CRTP For Static Polymorphism │ │ ├── Mixin Chain │ │ ├── Mixin On Delegators │ │ ├── Mixin Pros And Cons │ │ ├── Mixins and CRTP │ │ ├── Mixins for Model-View-Controler │ │ ├── Mixins in straight C++ │ │ └── $mixin │ ├── $model │ │ └── $model │ ├── $type │ │ └── $type │ ├── $typedef │ │ └── $typedef │ ├── $var │ │ └── $var │ ├── $variant │ │ ├── Free functions on value types │ │ ├── Geometry Model Examples │ │ ├── Shape Union Type Example │ │ ├── A square is a rectangle │ │ ├── CEDA Union Types │ │ └── $variant │ ├── extern │ │ └── <<extern>> │ └── preprocessor │ ├── @() directive │ ├── @@ directive │ ├── @assert directive │ ├── @assertfails directive │ ├── @def directive │ ├── @defpython directive │ ├── @fail directive │ ├── @for directive │ ├── @if-@else directive │ ├── @import directive │ ├── @let directive │ ├── @nakeddef directive │ ├── @print directive │ ├── @quote directive │ ├── @relativepath directive │ ├── @runpython directive │ ├── @scope directive │ ├── @str directive │ ├── @strx directive │ ├── @unstr directive │ ├── @while directive │ ├── @[] directive │ ├── Expressions │ ├── Xcpp preprocessor grammar │ ├── Macro variables │ ├── Xc++ Macro Preprocessor │ └── Recursive macros └── xcpp ├── Logical Path ├── Versioning of source files ├── Virtual Tree ├── Xcpp console application ├── Xcpp ├── android │ ├── Ceda development on Android │ ├── Build boost for Android │ ├── Building CEDA core libraries under Windows │ ├── Building CEDA core libraries to target Android │ ├── CEDA SDK for targeting Android │ ├── Filter ABI │ ├── long and int64 overloads │ └── Using boost for Android ├── build-artefacts │ ├── Build Artefacts │ ├── Build folder │ ├── Chained builds │ ├── Export folder │ ├── Include folder │ └── Lib folder ├── linux │ ├── Using the Code Blocks IDE │ ├── Dump Ceda Namespace │ ├── How to package up an SDK for building ceda based applications on Ubuntu │ ├── Installing the pyceda module │ ├── Ceda development on Linux │ ├── Open and close a ceda PersistStore in Python │ ├── Packaging pyceda for Ubuntu 16.04 using distutils │ ├── Package pypizza for Ubuntu 16.04 using distutils │ ├── Python class to open a ceda database │ ├── Set up CEDA core library development for Ubuntu Linux │ ├── Set up Linux Virtual Machine │ ├── CEDA SDK on Ubuntu x64 │ ├── Using pypizza datetime │ ├── Using pypizza │ ├── Using pypizza shapes │ └── Using the pyceda module ├── msvs │ ├── Double clicking on a workspace file to generate a solution │ └── Microsoft Visual Studio Integration ├── windows │ └── Windows ├── xcpj │ ├── Compiler Switches │ ├── Configurations │ ├── Directories Filter │ ├── General Settings │ ├── xcpj file grammar │ ├── Import directives │ ├── Linker switches │ ├── Post-build events │ ├── Pre-build events │ ├── Pre-link events │ ├── Project Directory │ ├── Resource compiler switches │ ├── ROOT_TO_PROJDIR │ ├── Source files │ ├── Sub-projects │ ├── Target Type │ ├── Tool Files │ ├── Variables │ └── Ceda Project (xcpj) Files ├── xcpp │ ├── Compiler │ ├── mode │ └── Xcpp Configuration Files └── xcws └── Ceda Workspace (xcws) Files
cmake ├── Build events ├── Build rules ├── Build tree ├── Built-in targets ├── CMake build phases ├── CMake ├── Copy file example ├── CTest ├── Custom targets ├── Generate executable which generates a file ├── Generate a Project Build system ├── Library types ├── Math operations in cmake ├── Out-of-source build trees ├── Selecting the compiler ├── Source tree └── Targets
partners └── Existing commercial use of CEDA
relational-model ├── Additional relational operations ├── Asynchronous updates ├── Codd's theorem ├── Compensating actions ├── Conditionally existent L-values ├── The database proposition ├── Two monadic relations with an IND constraint ├── DEE and DUM ├── Events databases ├── Factorisation of supplier and parts database schema ├── Fidelity ├── Formula of the relational calculus ├── Function ├── How to implement long running business processes ├── Independently updatable variables ├── Infinite types ├── Information equivalence classes ├── Interfacing CEDA to a conventional RDBMS ├── Key constraint ├── Logical independence ├── Many simple predicates ├── Matches function to check whether the dbvar has a given dbvalue ├── Maximal decomposition of information ├── Microworlds ├── Musings on the Relational Model ├── Natural language predicates ├── Nested relational databases ├── Objects in two rooms example ├── Using the PCF to select appropriate representations ├── Possreps ├── Principle of Interchangeability ├── Proof of the unique prime Cartesian factorisation of a relation ├── Tuple and relation types as first class citizens ├── Relation ├── Relational Algebra ├── Relational model applications methodology ├── Relational Model ├── The relvar proposition ├── Remove Duplicates ├── Restriction views ├── Relational Database Schema ├── Sets of ordered pairs ├── Summary of relational theory ├── Supplier-and-parts database ├── Database Trigger ├── Tuple types ├── Tuple ├── Two meanings of type constraint ├── Unique prime Cartesian factorisation of a relation ├── Unrolling a predicate ├── Untyped formalism of relational theory ├── Imperative programming language variables ├── View update problem - insert into a restriction ├── Join views ├── View update problem └── View update on projections