remove index

.gitignore

@@ -0,0 +1,23 @@
+# Build output
+_build/
+
+# Node.js dependencies
+node_modules/
+
+# Python
+__pycache__/
+*.py[cod]
+.ipynb_checkpoints/
+
+# Environment
+.env
+.venv/
+venv/
+
+# IDE
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db

book/00-introduction/05-executive-summary.md

@@ -24,7 +24,7 @@ Unlike Entity-Relationship modeling that requires translation to SQL, DataJoint
 Foreign keys in DataJoint do more than enforce referential integrity—they encode computational dependencies. A computed result that references raw data will be automatically deleted if that raw data is removed, preventing stale or orphaned results. This maintains *computational validity*, not just *referential integrity*.
 
 **Declarative Computation**
-Computations are defined declaratively through `make()` methods attached to table definitions. The `populate()` operation identifies all missing results and executes computations in dependency order. Parallelization, error handling, and job distribution are handled automatically.
+Computations are defined declaratively through make() methods attached to table definitions. The populate() operation identifies all missing results and executes computations in dependency order. Parallelization, error handling, and job distribution are handled automatically.
 
 **Immutability by Design**
 Computed results are immutable. Correcting upstream data requires deleting dependent results and recomputing—ensuring the database always represents a consistent computational state. This naturally provides complete provenance: every result can be traced to its source data and the exact code that produced it.

book/20-concepts/00-databases.md

@@ -25,7 +25,7 @@ Databases are crucial for the smooth and organized operation of various entities
 ## Database Management Systems (DBMS)
 
 ```{card} Database Management System
-A Database Management System is a software system that serves as the computational engine powering a database.
+A Database Management System (DBMS) is a software system that serves as the computational engine powering a database.
 It defines and enforces the structure of the data, ensuring that the organization's rules are consistently applied.
 A DBMS manages data storage and efficiently executes data updates and queries while safeguarding the data's structure and integrity, particularly in environments with multiple concurrent users.
 
@@ -50,7 +50,7 @@ One of the most critical features distinguishing databases from simple file stor
 
 ### Authentication and Authorization
 
-Before you can work with a database, you must **authenticate**—prove your identity with a username and password. Once authenticated, the database enforces **authorization** rules that determine what you can do:
+Before you can work with a database, you must **authentication**—prove your identity with a username and password. Once authenticated, the database enforces **authorization** rules that determine what you can do:
 
 - **Read**: View specific tables or columns
 - **Write**: Add new data to certain tables  
@@ -80,10 +80,10 @@ Modern databases typically separate data management from data use through distin
 
 ### Common Architectures
 
-**Server-Client Architecture** (most common): A database server program manages all data operations, while client programs (your scripts, applications, notebooks) connect to request data or submit changes. The server enforces all rules and access permissions consistently for every client. This is like a library where the librarian (server) manages the books and enforces checkout policies, while patrons (clients) request materials.
+**Server-client architecture** (most common): A database server program manages all data operations, while client programs (your scripts, applications, notebooks) connect to request data or submit changes. The server enforces all rules and access permissions consistently for every client. This is like a library where the librarian (server) manages the books and enforces checkout policies, while patrons (clients) request materials.
 The two most popular open-source relational database systems: MySQL and PostgreSQL implement a server-client architecture.
 
-**Embedded Databases**: The database engine runs within your application itself—no separate server. This works for single-user applications like mobile apps or desktop software, but doesn't support multiple users accessing shared data simultaneously.
+**Embedded databases**: The database engine runs within your application itself—no separate server. This works for single-user applications like mobile apps or desktop software, but doesn't support multiple users accessing shared data simultaneously.
 SQLite is a common embedded database @10.14778/3554821.3554842.
 
 **Distributed Databases**: Data and processing are spread across multiple servers working together. This provides high availability and can handle massive scale, but adds significant complexity. Systems like Google Spanner, Amazon DynamoDB, and CockroachDB use this approach.

book/20-concepts/01-models.md

@@ -244,7 +244,7 @@ Most importantly, spreadsheets provide no referential integrity. If cell B2 cont
 
 The **relational data model**, introduced by Edgar F. Codd in 1970, revolutionized data management by organizing data into tables (relations) with well-defined relationships. This model emphasizes data integrity, consistency, and powerful query capabilities through a formal mathematical foundation.
 
-The relational model organizes all data into tables representing mathematical relations, where each table consists of rows (representing mathematical *tuples*) and columns (often called *attributes*). Key principles include data type constraints, uniqueness enforcement through primary keys, referential integrity through foreign keys, and declarative queries. The next chapter explores these principles in depth.
+The relational model organizes all data into tables representing mathematical relations, where each table consists of rows (representing mathematical *tuples*) and columns (often called *attributes*). Key principles include data type constraints, uniqueness enforcement through primary keys, referential integrity through foreign keys, and declarative query. The next chapter explores these principles in depth.
 
 The most common way to interact with relational databases is through the Structured Query Language (SQL), a language specifically designed to define, manipulate, and query data within relational databases.
 

book/20-concepts/03-relational-practice.ipynb

@@ -1568,15 +1568,7 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": [
-    "## The Path Forward: Databases as Workflows\n",
-    "\n",
-    "**DataJoint extends relational theory by viewing the schema as a workflow specification.** It preserves all the benefits of relational databases—mathematical rigor, declarative queries, data integrity—while adding workflow semantics that make the database **workflow-aware**.\n",
-    "\n",
-    "**Key Insight**: The database schema structure can be identical whether using SQL or DataJoint, although DataJoint imposes some conventions. What's different is the **conceptual view**: SQL sees static entities and relationships; DataJoint sees an executable workflow, where some steps are manual and others are automatic. This workflow view enables automatic execution, provenance tracking, and computational validity—features essential for scientific computing.\n",
-    "\n",
-    "The next chapter introduces DataJoint's Relational Workflow Model in detail, showing how Computed tables turn your schema into an executable pipeline specification.\n"
-   ]
+   "source": "## The Path Forward: Databases as Workflows\n\n**DataJoint extends relational theory by viewing the schema as a workflow specification.** It preserves all the benefits of relational databases—mathematical rigor, declarative queries, data integrity—while adding workflow semantics that make the database **workflow-aware**.\n\n**Key Insight**: The database schema structure can be identical whether using SQL or DataJoint, although DataJoint imposes some conventions. What's different is the **conceptual view**: SQL sees static entities and relationships; DataJoint sees an executable workflow, where some steps are manual and others are automatic. This workflow view enables automatic execution, provenance tracking, and computational validity—features essential for scientific computing.\n\nThe next chapter explores **Data Integrity**—the fundamental constraints that databases enforce to ensure data remains accurate, consistent, and reliable. Understanding these integrity concepts provides the foundation for DataJoint's Relational Workflow Model, which extends integrity guarantees to include workflow validity and computational consistency."
   },
   {
    "cell_type": "code",