Part I: Studying for IRIS Developer Professional Certification with the "Ask Developer Community AI"

The "Ask Developer Community AI" tool is an excellent resource for studying for the certification. I asked it about each topic that will be covered in the test and the results are below.
Note: I classified each answer by the assertiveness that I consider as good, average and bad.

Note 2: The article has 4 parts, each one for an exam area.

1.    Best practices: Architecture
1.1 Determines database storage strategy in InterSystems IRIS

[GOOD] Determines which databases should be included in a namespace

A namespace in InterSystems IRIS is a logical entity that provides access to data and code stored in multiple databases. Typically, a namespace includes:
1.    A default database for storing code, known as the routines database.
2.    A default database for storing data for persistent classes and any globals created, known as the globals database.
3.    A default database for temporary storage.
4.    Mappings that provide access to additional data and code stored in other databases. These mappings can refer to routines, class packages, entire globals, and specific global nodes in non-default databases. [1]
In a simple configuration, one namespace uses one database. However, it is often beneficial to separate the code and data into different databases for maintainability. For example, a namespace can be configured to use one database for routines (code) and another for globals (data). Additionally, mappings can be created to access specific globals from other databases. [2]
To create a namespace and assign databases to it, you can follow these steps:
1.    Create the databases you need.
2.    Create a new namespace and assign the databases for routines and globals.
3.    Optionally, configure mappings to access additional data or code from other databases. [3]

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Orientation for Programmers > Namespaces and Databases
2.Databases only appear in Classes Section of Management Portal
3.How to separate source code and data in different databases

 

[GOOD]  Recommends database architecture based on expected data growth

To recommend a database architecture based on expected data growth, consider using InterSystems IRIS’s sharding capabilities. Sharding is a horizontal scalability feature that partitions data storage and caching across multiple servers, forming a sharded cluster. This approach provides flexible, inexpensive performance scaling for queries and data ingestion while maximizing infrastructure value through efficient resource utilization. Sharding is particularly beneficial for applications involving large amounts of data retrieval, complex data processing, or high-volume, high-velocity data ingestion. By distributing query processing and caching across multiple systems, sharding allows near-linear scaling of compute and memory resources, enabling the design and maintenance of a cluster tailored to your workload. [1]

Sources
1.InterSystems IRIS Data Platform 2024.3 > Architecture > Scalability > Scalability Guide > Scale for Data Volume

 

[GOOD]  Structures data to support global mappings  

To structure data to support global mappings in InterSystems IRIS, you need to follow these steps:
1.    Defining Databases: Create a local database by logging into the Management Portal, navigating to System Administration > Configuration > System Configurations > Local Databases, and using the Database Wizard to create a new database. [1]
2.    Defining Namespaces: Create a namespace that uses local databases by logging into the Management Portal, navigating to System Administration > Configuration > System Configurations > Namespaces, and using the wizard to create a new namespace. [1]
3.    Mapping a Global: To map a global to a specific database, log into the Management Portal, navigate to System Administration > Configuration > System Configurations > Namespaces, select Global Mappings for the desired namespace, and create a new global mapping. Specify the global database location and the global name. [1]
4.    Subscript-Level Mapping: You can map parts of a global (subscripts) to different databases. This allows data to span multiple disks. For example, you can map ^x to one database and ^x(1) to another. [2]
5.    Programmatic Mapping: You can also define global mappings programmatically using the appropriate classes and methods provided by InterSystems IRIS. [3]
By following these steps, you can effectively structure your data to support global mappings across different databases.

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Orientation for Programmers > Useful Skills to Learn
2.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Multidimensional Storage > Mapping
3.How do we map Globals (holds data which spreads across different DBs) to multiple Databases

 

[GOOD]  Identifies implications of mirroring on application performance and availability

Mirroring in InterSystems Caché provides a high availability solution with automatic failover, which can significantly impact application performance and availability. Here are some key implications:
1.    Performance: Mirroring uses logical data replication to keep the backup system synchronized with the primary system. This approach minimizes the risks associated with physical replication, such as out-of-order updates and carry-forward corruption. However, network latency between the failover members is a critical factor in application performance. The physical locations of the failover members and the network connection between them should be chosen to minimize latency to ensure optimal performance [1][2].
2.    Availability: Mirroring provides a robust solution for both planned and unplanned downtime. It allows for rapid, unattended, automated failover between two Caché systems, ensuring high availability. The use of redundant components minimizes the risks associated with shared resources, and the logical data replication helps avoid single points of failure [1][3][4].
3.    Disaster Recovery: Mirroring can be configured with additional async members for disaster recovery. These async members can be geographically dispersed, providing a robust framework for distributed data replication and ensuring business continuity [1][3].
4.    Planned Downtime: Mirroring offers the flexibility to incorporate certain planned downtimes while minimizing the overall impact on the organization’s service level agreements (SLAs). This ensures that maintenance activities can be performed without significant disruption to the application [1][3].
5.    Automatic Failover: The automatic failover mechanism ensures that if the primary system becomes unavailable, the backup system can take over immediately, providing uninterrupted access to the databases without data loss. This is crucial for maintaining high availability and minimizing workflow and user disruption [1][3][2].
Overall, mirroring in InterSystems Caché enhances both the performance and availability of applications by providing a reliable, economical, and robust high-availability solution.

Sources
1.InterSystems Caché: Database Mirroring: A Technical Overview
2.InterSystems IRIS Data Platform 2024.3 > Architecture > Mirroring and High Availability > High Availability Guide > Mirroring Architecture and Planning
3.InterSystems Caché: Database Mirroring: An Executive Overview
4.Caché Mirroring 101: a Brief Guide and FAQ

 

[AVERAGE]  Identifies implications of IRIS upgrades on database architecture

InterSystems IRIS upgrades can have several implications on database architecture, particularly in the context of high availability (HA) and data management:
1.    High Availability Solutions: Upgrading InterSystems IRIS may require careful planning to ensure minimal downtime. For example, InterSystems IRIS mirroring allows for minimal downtime during upgrades if application code, classes, and routines are kept in separate databases from application data. This approach helps maintain high availability and ensures that the system remains operational during the upgrade process [1].
2.    Data Management and Scalability: Upgrades may also impact how data is managed and scaled. For instance, sharding is a significant horizontal scalability feature of InterSystems IRIS that partitions data storage and caching across multiple servers. This can provide flexible and efficient performance scaling for queries and data ingestion. Upgrading to a version that supports or enhances sharding capabilities can significantly improve the scalability and performance of the database [2].
3.    Upgrade Impact Checklist: InterSystems provides an Upgrade Impact Checklist that helps identify and manage the potential impacts of upgrading between different versions. This checklist includes considerations for changes in SQL behavior, data structures, and other critical aspects that could affect the database architecture. Using this tool can help ensure a smooth upgrade process by highlighting necessary adjustments and preparations [3].
These considerations highlight the importance of planning and utilizing available tools and features to manage the implications of IRIS upgrades on database architecture effectively.

Sources
1.InterSystems IRIS Data Platform 2024.3 > Architecture > Mirroring and High Availability > High Availability Solutions
2.InterSystems IRIS Data Platform 2024.3 > Architecture > Scalability > Scalability Guide > Scale for Data Volume
3.Introducing the Upgrade Impact Checklist

 

[AVERAGE]  Identifies implications of security requirements on database architecture

Security requirements have significant implications on database architecture. When deploying an application in a public cloud, it is crucial to follow your organization’s standard security policies or develop new ones specifically for cloud environments to maintain security compliance. Cloud deployments introduce the risk of data being outside client data centers and physical security control. Therefore, using database and journal encryption for data at rest and data in flight with AES and SSL/TLS encryption is highly recommended. Proper encryption key management procedures must be documented and followed to ensure data safety and prevent unauthorized access. Additionally, third-party firewall devices may be required for extra functionality such as intrusion detection and denial of service protection [1].
Furthermore, the security system in InterSystems IRIS is based on applying different security settings for users, roles, services, resources, privileges, and applications. Different security levels (Minimal, Normal, or Locked Down) can be chosen during installation, each with varying degrees of user engagement, available roles and services, and authentication methods. For example, the Locked Down level provides the highest security by disabling many services and requiring authentication for all enabled services [2].
In summary, security requirements necessitate careful planning and implementation of encryption, key management, and appropriate security settings to protect data and ensure compliance with organizational policies and regulations.

Sources
1.InterSystems Example Reference Architecture for Microsoft Azure Resource Manager (ARM)
2.Increasing the Security of the InterSystems IRIS DBMS

 

[AVERAGE]  Identifies costs and benefits of using InterSystems interoperability functionality  

InterSystems IRIS provides powerful interoperability functionality that offers several benefits, including the ability to eliminate data silos, integrate and orchestrate legacy and new services, normalize and transform data, design and implement business processes and rules, and optimize governance and forensics. This functionality supports various data formats and communication protocols, making it highly flexible for different integration needs. Additionally, it allows for the development of custom production components in multiple programming languages, enhancing its adaptability to specific requirements [1].
However, the costs associated with using InterSystems interoperability functionality can include the need for specialized knowledge to configure and manage the system, potential licensing fees, and the resources required for initial setup and ongoing maintenance. The complexity of integrating various systems and ensuring data consistency and security can also add to the overall cost [1].

Sources
1.InterSystems IRIS Data Platform 2024.3 > Connecting Systems

 

[GOOD]  Identifies benefits and tradeoffs for using InterSystems IRIS BI to augment usage of object and relational models

Using InterSystems IRIS BI (DeepSee) to augment the usage of object and relational models offers several benefits and tradeoffs:
Benefits:
1.    Unified Data Platform: InterSystems IRIS provides a comprehensive platform that integrates data management, analytics, and interoperability. This allows for seamless integration of BI capabilities with object and relational models, enabling real-time analytics and insights directly from transactional data [1].
2.    Flexibility: The platform supports multiple data models, including relational, object-oriented, and document-based models. This flexibility allows developers to choose the most appropriate model for their specific use case while leveraging the powerful analytics capabilities of IRIS BI [2].
3.    Real-Time Analytics: IRIS BI enables real-time analytics, allowing businesses to gain insights and make decisions based on the most current data. This is particularly beneficial for applications that require immediate insights, such as financial trading systems or healthcare applications [1].
4.    Scalability: The platform is designed to handle large datasets and high workloads, making it suitable for mission-critical applications that require high performance and scalability [2].
5.    Integration with Business Processes: IRIS BI can be embedded into business processes, enabling programmatic decisions based on real-time analyses. This integration helps automate and optimize business operations [1].
Tradeoffs:
1.    Complexity: Implementing a unified data platform that combines multiple data models and real-time analytics can be complex. It requires careful planning and expertise to ensure that all components work together seamlessly [1].
2.    Resource Intensive: Real-time analytics and the integration of multiple data models can be resource-intensive, requiring significant computational power and storage. Organizations need to ensure they have the necessary infrastructure to support these capabilities [1].
3.    Learning Curve: Leveraging the full capabilities of InterSystems IRIS BI may require a learning curve for developers and data analysts, particularly if they are not familiar with the platform’s features and tools [2].
Overall, using InterSystems IRIS BI to augment object and relational models provides significant advantages in terms of flexibility, real-time insights, and scalability, but it also comes with challenges related to complexity, resource requirements, and the learning curve.

 

[GOOD]  Identifies secure REST API design best practices

To design a secure REST API, consider the following best practices:
1.    Authentication and Authorization: Use methods like Basic Auth or OAuth 2.0 JWT Access Tokens to secure endpoints. Basic Auth involves checking the username and password provided in the HTTP Authorization header, while JWT tokens provide a more secure and flexible way to define privileges via scopes. [1]
2.    Endpoint Security: Secure individual endpoints by specifying which endpoints should allow anonymous access and which should not. This can be managed by defining a Web Application for your REST API and configuring it for unauthenticated access while specifying the required privileges for the application. [1]
3.    CORS Support: Enable Cross-Origin Resource Sharing (CORS) to allow restricted resources on a web page to be requested from another domain. This can be done by adding a parameter to the broker and overriding the OnHandleCorsRequest method to check request origin and allow access only from whitelisted domains. [2]
4.    API Management: Utilize tools for managing the API lifecycle, such as InterSystems API Manager, to handle the complexity of API development and ensure consistent and secure API operations. [2]
5.    Spec-First Development: Develop your APIs using a spec-first approach, which involves defining the API specification before writing any code. This helps in planning and ensuring that the API design meets security and functionality requirements. [2]
6.    Separation of Concerns: Implement a multitier architecture to separate different layers of your application, such as data, terminal API, web API, and client. This separation helps in managing complexity and enhancing security by isolating different parts of the application. [2]
By following these practices, you can create secure, robust, and maintainable REST APIs.

Sources
1.Securing Individual REST API Endpoints
2.REST Design and Development

 

1.2.    Determines data structures

[GOOD]  Differentiates between registered object, serial object, and persistent classes

In InterSystems IRIS, there are three main types of object classes: registered object classes, persistent classes, and serial classes.
1.    Registered Object Classes: These are subclasses of %RegisteredObject. They represent transient objects that can be created and manipulated in memory but are not saved to disk. Registered objects are useful for temporary data that does not need to be stored persistently. [1] [2]
2.    Persistent Classes: These are subclasses of %Persistent, which itself is a subclass of %RegisteredObject. Persistent classes add the ability to save objects to the database and retrieve them later. This makes them suitable for data that needs to be stored and accessed over time. Persistent objects are automatically projected to SQL tables, allowing them to be queried using SQL. [1] [2] [3]
3.    Serial Classes: These are subclasses of %SerialObject, which is also a subclass of %RegisteredObject. Serial classes are designed to be embedded within other objects, either transient or persistent. They are serialized into a string that represents their state and are typically used as properties within other objects. Serial objects cannot be saved or retrieved independently; they are always part of another object. [1] [2] [4]
Each type of class serves a different purpose and is used in different scenarios depending on whether the data needs to be transient, persistent, or embedded within other objects.

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Defining & Using Classes > Defining Classes
2.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Orientation for Programmers > Objects
3.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Defining & Using Classes > Persistent Objects
4.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Defining & Using Classes > Object-Valued Properties

 

[GOOD]  Determines indexes to add/update to improve performance

To determine which indexes to add or update to improve performance in InterSystems IRIS, you can follow these steps:
1.    Examine Query Performance: Use the SQL Query Optimizer to analyze the performance of your queries. The optimizer generates multiple query plans based on table statistics and chooses the most efficient one. You can use tools like the SQL Performance Analysis Toolkit to profile specific queries in detail [1].
2.    Define and Build Indexes: Indexes are crucial for optimizing SQL queries. You can define various types of indexes such as standard indexes, bitmap indexes, bitslice indexes, and columnar indexes based on the data and query requirements. For example, bitmap indexes are useful for columns with few distinct values, while bitslice indexes are good for range conditions and sums [2].
3.    Tune Table: Use the Tune Table utility to gather statistics about the data in your tables, such as the number of rows, distribution of distinct values, and average length of values. These statistics help the Query Optimizer make better decisions about query plans [1][3].
4.    Query Plan Analysis: Check if your queries are using the defined indexes by examining the query plan. If the plan indicates that the query is reading the master map instead of an index map, it suggests that an index should be created or updated to improve performance [4].
5.    Index Maintenance: Regularly maintain your indexes by rebuilding them if necessary. You can use the %BuildIndices method to build indexes for existing data. Additionally, you can validate indexes using the %ValidateIndices method to ensure they are consistent and functioning correctly [5].
By following these steps, you can identify and implement the necessary indexes to enhance the performance of your SQL queries in InterSystems IRIS.

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > SQL > SQL Performance Overview
2.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > SQL > Defining a High-Performance Schema > Define and Build Indexes
3.The One Query Performance Trick You NEED to Know? Tune Table!
4.A Peek at IRIS Data Platform Performance Strategies
5.Inserting an index without reconstruction

[GOOD]  Describes relationship between globals, objects, and SQL  

InterSystems IRIS is a multi-model DBMS that supports different data models, including globals, objects, and SQL, and allows you to access the same data through different APIs depending on your needs.
1.    Globals: Globals are the fundamental data storage mechanism in InterSystems IRIS. They are multidimensional key-value pairs that are automatically saved to disk. Globals can be accessed directly for high performance and flexibility, and they are used internally by both the object and SQL models. Globals are particularly useful for tasks requiring fast data access and manipulation without the overhead of SQL or object layers [1][2].
2.    Objects: InterSystems IRIS supports object-oriented programming through persistent classes. When you define a persistent class, it automatically generates a storage structure that maps the class properties to global nodes. This allows you to work with data as objects in your application code while the data is stored in globals. The object model provides a convenient way to encapsulate data and behavior, making it easier to manage complex data structures [3][4].
3.    SQL: InterSystems IRIS also provides a robust SQL engine that allows you to interact with data using standard SQL queries. Persistent classes are automatically projected as SQL tables, where class properties correspond to table columns. This means you can use SQL to perform operations like querying, inserting, updating, and deleting data. The SQL engine translates these operations into global accesses, ensuring efficient data manipulation [1][3][4].
The relationship between these models is seamless, allowing you to choose the most appropriate access method for your use case. For example, you can use SQL for complex queries and reporting, objects for application logic, and globals for high-performance data access. This flexibility is a key advantage of InterSystems IRIS, enabling you to build applications that leverage the strengths of each data model [3][4].

Sources
1.SQL/Non-SQL
2.Globals Are Magic Swords For Managing Data. Part 1
3.Classes, tables and globals - how it all works?
4.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Orientation for Programmers > Persistent Objects and InterSystems IRIS SQL

[GOOD]  Determines when streams are the appropriate data type

Streams are appropriate data types when you need to store extremely large amounts of data that exceed the string length limit. InterSystems IRIS provides several stream classes for different types of data:
1.    Character Streams: Use %Stream.GlobalCharacter for large quantities of text stored in global nodes.
2.    Binary Streams: Use %Stream.GlobalBinary for binary data such as images, audio, or video stored in global nodes.
3.    File Streams: Use %Stream.FileCharacter and %Stream.FileBinary for character and binary data stored in external files, respectively.
4.    Temporary Streams: Use %Stream.TmpCharacter and %Stream.TmpBinary for temporary character and binary data that do not need to be saved.
Streams are useful for handling data types like PDF, spreadsheet, RTF, plain text, CSV, and XML, as they can morph between binary and character streams depending on the type of data being persisted. This flexibility makes streams a good choice for storing documents received from various sources. [1] [2] [3]

Sources
1.Global-Streams-to-SQL
2.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > SQL > Using SQL > Storing and Using Stream Data (BLOBs and CLOBs)
3.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Defining & Using Classes > Streams

[GOOD]  Describes InterSystems IRIS support for JSON and XML

InterSystems IRIS provides robust support for both JSON and XML data formats.
For JSON, InterSystems IRIS includes integrated support within ObjectScript, allowing you to work with JSON data structures as easily as with objects or tables. You can create and manipulate dynamic entities at runtime using classes like %Library.DynamicObject and %Library.DynamicArray. These classes provide methods for JSON serialization and deserialization, enabling conversion between dynamic entities and JSON strings. You can also use JSON string literals or ObjectScript dynamic expressions to define values. [1] [2]
For XML, InterSystems IRIS supports various XML standards, including XML 1.0, Namespaces in XML 1.0, XML Schema 1.0, XPath 1.0, and SOAP encoding. It provides tools for XML canonicalization, encryption, and signature, and includes two XSLT processors (Xalan for XSLT 1.0 and Saxon for XSLT 2.0 and 3.0). The SAX Parser in InterSystems IRIS uses the standard Xerces-C++ library, ensuring compliance with the XML 1.0 recommendation. [3]

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Web Applications & APIs > REST and JSON > Using JSON > Using JSON in ObjectScript
2.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > Web Applications & APIs > REST and JSON > Using JSON > Converting Dynamic Entities to and from JSON
3.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > XML Tools > XML Standards

 

1.3.    Plans data lifecycle

[AVERAGE]  Evaluates strategies for data storage and retrieval (e.g., MDX, SQL, object)

InterSystems IRIS supports various strategies for data storage and retrieval, including MDX, SQL, and object access. ObjectScript, the procedural programming language used in IRIS, allows you to access data directly from globals, which are persistent multidimensional sparse arrays. Additionally, you can access data through its native object and SQL support, providing flexibility in how you manage and retrieve your data [1].
For example, you can use SQL for structured queries, MDX for multidimensional data analysis, and object access for working with data in an object-oriented manner. Each method has its own use cases and advantages depending on the specific requirements of your application.

Sources
1.InterSystems IRIS Data Platform 2024.3 > Embedded Language Development > ObjectScript
2.Newbie's Corner Index

[GOOD]  Manages data life cycles (aka CRUD)

InterSystems IRIS provides robust support for managing data life cycles, commonly referred to as CRUD (Create, Read, Update, Delete) operations. Here are some key points on how IRIS handles these operations:
1.    API for Table Operations: The application provides a REST API to interact with the data stored in the user’s tables. The API supports five basic operations:
o    Get All Records by Condition: Retrieve records from a table based on specific conditions or filters.
o    Get All Records: Fetch all records from a table without any filters.
o    Save: Add new records to a table.
o    Update: Modify existing records in a table.
o    Delete: Remove records from a table. [1]
2.    RESTForms Project: This project provides a generic REST API backend for modern web applications, allowing CRUD operations over exposed classes. It includes features such as:
o    CRUD over exposed class: Get class metadata, create, update, and delete class properties.
o    CRUD over object: Get, create, update, and delete objects.
o    R over object collections (via SQL): Protected from SQL injections.
o    Self-discovery: Get a list of available classes and their metadata, and perform CRUD operations based on that metadata. [2]
3.    Example Implementation: In a practical example, a REST service can be created to handle CRUD operations for a class. This involves creating methods to handle GET, POST, PUT, and DELETE requests, which correspond to reading, creating, updating, and deleting records, respectively. [3]
These features and tools make it straightforward to manage data life cycles within InterSystems IRIS, providing both flexibility and security for data operations.

Sources
1.Inside Database Management Tool
2.RESTForms - REST API for your classes
3.Let's write an Angular 1.x app with a Caché REST backend - Part 9

[AVERAGE]  Describes expected application performance as a function of data volumes, users, and processes

Application performance can be influenced by various factors such as data volumes, the number of users, and the processes involved. To manage and optimize performance, it is essential to monitor and analyze system metrics continuously.
1.    Monitoring Tools: InterSystems provides several tools for monitoring application performance. For example, the Caché pButtons utility generates a readable HTML performance report from log files it creates, which includes metrics like Caché setup, performance metrics, operating system resource metrics, and more. Regularly collecting and reviewing these metrics can help identify performance issues early [1].
2.    Application Performance Management (APM): APM focuses on monitoring performance from the users’ perspective, measuring business transactions, and response times. It helps in understanding how well the application is performing and identifying areas of concern. This approach complements system performance monitoring by providing insights into the level of service provided to users [2].
3.    Distributed Caching and ECP: For scaling applications to handle increased user volume and data, InterSystems IRIS uses distributed caching with the Enterprise Cache Protocol (ECP). This allows the application to distribute the workload across multiple application servers, each maintaining its own cache. This setup helps in efficiently managing user requests and maintaining performance by reducing the load on a single server [3][4].
4.    Capacity Planning: Proper capacity planning is crucial for ensuring that the system can handle the expected load. This involves sizing the system’s CPU, memory, and storage requirements based on the application’s needs. For example, using SPECint benchmarks can help translate CPU usage between different processor types, aiding in right-sizing the hardware for the application [5].
By leveraging these tools and strategies, you can effectively manage and optimize application performance as data volumes, user numbers, and processes scale.

Sources
1.InterSystems Data Platforms and performance – Part 1
2.What is APM?
3.Data Platforms and Performance - Part 7 ECP for performance, scalability and availability
4.InterSystems IRIS Data Platform 2024.3 > Architecture > Scalability > Basics: Distributed Caching
5.InterSystems Data Platforms and performance – Part 3: Focus on CPU