Cognitive dimensions of notations

The cognitive dimensions of notations (CDN) framework is an analytical tool developed to evaluate the usability of notational systems—such as diagrams, programming languages, spreadsheets, and visual interfaces—by assessing how their design influences users' cognitive processes during tasks like creation, comprehension, and modification.^[1] Originating from work by Thomas R. G. Green in 1989, the framework emphasizes trade-offs in notation design rather than prescriptive rules, providing a lightweight method to identify strengths and weaknesses without requiring formal usability testing.^[1] At its core, CDN identifies 14 primary dimensions that capture common cognitive challenges in interacting with notations, each representing a spectrum of design choices that affect user efficiency and error rates.^[1] These include viscosity, which measures resistance to local changes (e.g., how many edits are needed to alter a single element); visibility, the ease of viewing relevant notation parts simultaneously; and error-proneness, the likelihood of user mistakes due to ambiguous or misleading structures.^[1] Other key dimensions are abstraction (availability of higher-level hierarchies to simplify complexity), diffuseness (the verbosity or spatial demands of expressing ideas), secondary notation (support for informal annotations like comments or layout), and progressive evaluation (the ability to assess partial work incrementally without full completion).^[1] Additional dimensions cover aspects like premature commitment (restrictions on task sequencing), hidden dependencies (unobvious links between elements), role-expressiveness (clarity in inferring component purposes), closeness of mapping (alignment with real-world domains), consistency (uniform treatment of similar features), provisionality (flexibility in tentative actions), and hard mental operations (demands on working memory or inference).^[1] The framework has been applied extensively in human-computer interaction (HCI) and cognitive science to compare notations in domains such as software engineering, education, and design tools, revealing trade-offs like high visibility in graphical notations versus the abstraction power of textual code.^[1] For instance, analyses have shown that flowcharts excel in visibility for procedural tasks but suffer from high viscosity for modifications, while spreadsheets offer strong progressive evaluation through immediate feedback.^[1] Since its formalization in the 1990s, CDN has influenced over 50 research publications and practical evaluations at institutions like the University of Cambridge and companies including Microsoft, aiding the iterative improvement of user interfaces and educational materials.^[2]

Introduction

Definition and origins

The cognitive dimensions of notations framework comprises a set of high-level properties designed to evaluate the usability of notational systems, user interfaces, and programming languages by emphasizing cognitive aspects, such as how users mentally process and interact with the notation, rather than low-level ergonomic or physical interface details.^[3] This approach provides a vocabulary for analyzing how notations support user tasks like comprehension, modification, and abstraction, focusing on structural features that influence end-user cognition.^[1] The framework originated with Thomas R. G. Green's 1989 chapter "Cognitive dimensions of notations" in the proceedings of the HCI '89 conference, where he outlined initial dimensions to assess notations as information structures.^[1] It was further expanded and formalized in collaboration with Marian Petre through their 1996 paper, which applied the framework to evaluate visual programming environments like LabVIEW and Prograph, establishing it as a practical tool for usability analysis.^[4] Key milestones include Green's foundational 1989 work, which laid the groundwork by drawing from psychological studies of programming cognition, and the 1996 publication in the Journal of Visual Languages and Computing, which refined the dimensions for broader application.^[5] Early applications extended to information visualization, such as analyzing software visualization tools for exploratory tasks, highlighting issues like visibility in complex representations.^[1] At its core, the framework treats dimensions as a trade-off space for notation design, where improving one aspect (e.g., abstraction) may compromise another (e.g., consistency), rather than as absolute metrics for scoring usability; it prioritizes supporting end-user cognitive processes in creating and using notations.^[3]

Purpose and scope

The cognitive dimensions framework serves as a set of lightweight heuristics designed to analyze the usability of notational systems by evaluating their impact on users' cognitive processes, enabling designers to balance inherent trade-offs without relying on extensive user testing or prototyping.^[1] Originating from empirical studies of programmers and visual languages, it provides a pragmatic vocabulary for discussing how notations support or hinder mental activities, such as planning and problem-solving.^[3] This approach emphasizes quick, high-level assessments that inform design decisions early in the development cycle, fostering conscious choices about usability profiles tailored to specific user tasks.^[1] In scope, the framework applies broadly to diverse notational systems, encompassing programming languages, diagrammatic representations, spreadsheets, music notation, and even everyday information artifacts like control panels or user interfaces.^[3]^[1] It focuses on the structural properties of notations and their alignment with user activities, distinguishing itself from detailed cognitive psychology models—such as GOMS or claims analysis—by prioritizing designer-oriented, process-focused evaluation over low-level behavioral simulations or empirical metrics like keystroke times.^[3] This pragmatic orientation makes it particularly suitable for interdisciplinary fields like human-computer interaction and cognitive technology, where rapid iteration is essential.^[1] Among its benefits, the framework facilitates early-stage evaluation by highlighting how notations can enhance cognitive support for activities like transcription, modification, and error recovery, thereby improving overall user efficiency and satisfaction without exhaustive validation.^[3] It encourages the identification of trade-offs, such as trading visibility for abstraction, allowing designers to anticipate user challenges and refine systems accordingly.^[1] However, the framework's scope has limitations: it is not a comprehensive usability methodology and deliberately omits social, collaborative, or physical interaction aspects, focusing solely on individual cognitive dimensions of notation structure.^[3] It also requires supplementary techniques for deeper analysis, as its broad-brush nature may overlook nuanced empirical details or task-specific variations.^[1]

The Cognitive Dimensions

Core dimensions

The cognitive dimensions of notations framework, introduced by Green and Petre, comprises 13 core dimensions that evaluate the usability of notational systems from a cognitive perspective, focusing on how well they support user tasks without requiring detailed empirical studies.^[3] These dimensions are qualitative heuristics derived from analyses of programming environments and other notations, emphasizing trade-offs where improving one aspect may compromise another.^[3] For instance, enhancing abstraction can reduce the effort needed for changes but may obscure dependencies between elements.^[3] Abstraction gradient refers to the range of abstraction levels available in a notation, allowing users to work from concrete details to high-level encapsulations of complex structures.^[3] A wide gradient supports progressive refinement, as seen in object-oriented notations where low-level data bundles can evolve into reusable modules; however, a narrow gradient limits scalability for intricate problems.^[3] This dimension often trades off with hidden dependencies, as deeper abstractions can conceal internal relations.^[3] Closeness of mapping measures how closely the notation aligns with the user's problem domain, minimizing the need to translate real-world concepts into notational forms.^[3] In flowcharts, for example, arrows directly represent sequential processes, facilitating intuitive understanding; poor mapping, like abstract symbols in early word processors, forces mental remapping.^[3] It interrelates with consistency, as domain-aligned elements promote predictable usage across similar tasks.^[3] Consistency assesses the extent to which knowledge of one part of the notation predicts behavior elsewhere, enabling inference and reducing learning curves.^[3] Mathematical notations like algebra exhibit high consistency through uniform operator rules; inconsistencies, such as varying menu behaviors in software, lead to confusion.^[3] This dimension balances with diffuseness, where overly uniform rules might require more verbose expressions.^[3] Diffuseness evaluates the balance between verbosity and terseness, or the number of symbols needed to convey meaning without ambiguity.^[3] Spreadsheets achieve moderate diffuseness by using simple cell references for calculations; highly terse notations like assembly code risk misinterpretation, while verbose ones like COBOL enhance clarity at the cost of efficiency.^[3] It trades off with role-expressiveness, as brevity can obscure element purposes.^[3] Error-proneness gauges the notation's susceptibility to syntactic or semantic errors due to design flaws, such as ambiguous delimiters.^[3] Textual languages with matched brackets, like those in Pascal, heighten error risk from typos; visual notations like diagrams reduce this by eliminating pairing needs.^[3] Lower error-proneness often correlates with higher viscosity, as safeguards add editing overhead.^[3] Hard mental operations quantify the cognitive effort required for inferences or transformations, such as tracking nested structures.^[3] In circuit diagrams, visualizing signal flow demands mental simulation; notations with explicit paths, like dataflow graphs, lessen this burden.^[3] This dimension interlinks with visibility, where poor layout amplifies mental load.^[3] Hidden dependencies concern the visibility of relations between notation elements, such as unindicated links in a structure.^[3] Spreadsheets often hide formula inter-cell dependencies, complicating debugging; explicit arrows in entity-relationship diagrams make them overt.^[3] Reducing hidden dependencies can increase viscosity through added explicit markers.^[3] Premature commitment evaluates flexibility in task ordering, avoiding forced early decisions that constrain later work.^[3] Sketch notations permit provisional layouts before finalizing; rigid templates in form-based systems demand upfront choices.^[3] High premature commitment heightens error-proneness by amplifying guesswork.^[3] Progressive evaluation assesses the ability to obtain feedback on incomplete notations, supporting iterative development.^[3] Spreadsheets enable partial formula testing with immediate recalculation; batch-oriented notations like some compilers require full completion.^[3] This dimension trades off with consistency, as partial checks may bypass full validation rules.^[3] Role-expressiveness measures how clearly the purpose of each element is conveyed without external explanation.^[3] In UML diagrams, icons like diamonds for associations express roles intuitively; ambiguous symbols demand documentation.^[3] It interrelates with diffuseness, where expressive icons add to notational bulk.^[3] Secondary notation encompasses informal uses of layout, color, or spacing to encode additional meaning beyond core syntax.^[3] In code editors, indentation signals structure; plain text limits this to comments alone.^[3] Strong secondary notation enhances role-expressiveness but can introduce hidden dependencies if informal cues are overlooked.^[3] Viscosity captures resistance to local changes, subdivided into repetitive (unnecessary repetitions), knock-on (cascading updates), and role (type mismatches) subtypes.^[3] Editing spreadsheet formulas triggers knock-on effects across dependent cells; modular notations minimize this by isolating changes.^[3] Viscosity often conflicts with abstraction gradient, as encapsulations ease modifications but initial setup resists alterations.^[3] Visibility denotes the ease of locating and apprehending notation elements within the overall structure, including juxtaposability for side-by-side comparisons.^[3] Flowcharts promote visibility through spatially arranged nodes; deeply nested code hierarchies obscure elements.^[3] It trades off with abstraction, as encapsulations may hide details.^[3]

Extended and proposed dimensions

Following the establishment of the core cognitive dimensions framework by Green and Petre in 1996, subsequent research proposed additional dimensions to address emerging needs in notation design, particularly for creative and large-scale applications.^[6] These extensions aim to fill gaps in the original set, such as support for interpretive flexibility and navigation in complex structures, though they have received less empirical scrutiny and broader validation.^[1] One proposed dimension is creative ambiguity, which measures the extent to which a notation allows multiple interpretations to stimulate innovative thinking.^[6] Originating from studies in design and artistic practices, such as those by Blackwell et al., it rationalizes ambiguity as a deliberate feature in notations for fields like sketching or music composition, where revisiting elements can reveal novel insights.^[1] For instance, in artistic notations, incomplete symbols encourage co-creation between notator and interpreter, fostering creativity beyond rigid semantics.^[1] Unlike core dimensions focused on clarity and efficiency, creative ambiguity prioritizes generative potential but risks confusion if overemphasized.^[6] Indexing addresses the ease of locating specific elements within a notation, especially in expansive or hierarchical systems.^[6] Proposed in post-1996 discussions by Blackwell, it draws from visualization research to support scalability, enabling users to tag or reference parts without exhaustive scanning.^[1] This dimension highlights a limitation in core aspects like visibility, which assume smaller-scale interactions, by emphasizing navigational aids for real-world complexity.^[6] Closely related is synopsis, the ability of a notation to provide an at-a-glance overview of its overall structure, often termed a "Gestalt view."^[6] Introduced by Whitley and Blackwell in 1997 within visualization contexts, it rationalizes the need for holistic comprehension in data-heavy notations, such as diagrams or codebases, where partial views hinder understanding.^[7] This extends beyond core dimensions like secondary notation by focusing on summarization for large artifacts.^[1] Unevenness captures variations in cognitive effort across different parts or operations of a notation, potentially biasing user outputs toward easier paths.^[8] Originating from Stacey's 1995 analysis of design tools, it argues that such inconsistencies distort creative expression, as seen in software where some edits are fluid while others are cumbersome.^[8] In contrast to the uniform assumptions in core dimensions, unevenness underscores scalability issues in unevenly demanding notations.^[6] These proposed dimensions have seen limited integration into the canonical framework, appearing sporadically in niche domains like end-user programming and creative arts rather than widespread adoption.^[1] Their rationales target creativity and large-scale usability gaps overlooked by the originals, yet they lack the rigorous empirical testing that solidified the core set.^[6]

User Activities

Types of activities

The cognitive dimensions framework identifies four primary user activities that notations are designed to support, each presenting distinct cognitive demands on users interacting with notational systems. These activities serve as a lens for evaluating how well a notation facilitates everyday tasks in domains such as programming, diagramming, and modeling. Transcription involves copying or reformulating existing notations, often requiring the transfer of information from one form or medium to another, which can be cognitively taxing if the notation lacks consistency or abstraction granularity. Incrementation refers to the iterative addition of small elements to an existing structure, such as appending lines to a program or data points to a chart, where low viscosity—minimal effort to make local changes—is particularly beneficial to avoid disrupting workflow.^[1] Modification entails altering established structures within the notation, which demands high evaluability to assess the impact of changes without extensive reworking, as users must navigate dependencies and potential ripple effects. Exploratory design, the most cognitively intensive activity, involves trying out ideas, prototyping, and backtracking through trial and error, necessitating strong progressive evaluation to provide rapid feedback on partial designs and low knock-on effects to enable easy reversal of decisions. For instance, incrementation is evident in code editing environments where developers incrementally build functions, while exploratory design occurs in diagramming tools like UML software, where users sketch and refine models iteratively.^[1]^[9] Within the framework, these activities are not intended as an exhaustive task model but rather as representative scenarios that highlight the relevance of specific cognitive dimensions, allowing designers to tailor notations to varying user needs without prescribing a universal structure. By framing activities this way, the approach underscores how cognitive dimensions, such as viscosity and progressive evaluation, influence the ease of performing these tasks across different contexts.^[1]

Relation to dimensions

The cognitive dimensions of notations provide a framework for understanding how notational systems support or impede various user activities, such as incrementation, transcription, modification, and exploratory design. These activities form the basis for mapping dimensions to practical usability concerns, where specific dimensions align with the cognitive demands of each task. For instance, low viscosity facilitates modification by minimizing the effort required to alter local elements without disrupting the overall structure, as seen in textual notations like programming languages that allow quick edits compared to highly interconnected visual diagrams. Similarly, high visibility aids transcription by enabling users to maintain an overview of related elements during copying or reformatting tasks, reducing the need to navigate obscured information. Other mappings highlight targeted support for creative and incremental processes. Progressive evaluation supports exploratory design by permitting partial artifacts to be tested incrementally, allowing users to iterate on ideas without full commitment, which is particularly beneficial in prototyping environments. Role-expressiveness reduces error-proneness in incrementation by making the intended purpose of components immediately apparent, thereby easing the addition of new elements while preserving semantic clarity. However, enhancing support for one activity often involves trade-offs that degrade performance in others. For example, introducing high abstraction to facilitate exploratory design can increase the cognitive load of hard mental operations during transcription, as users must mentally reconstruct low-level details from summarized representations. Such compromises underscore the multidimensional nature of notations, where optimizing for flexibility in modification might elevate viscosity in favor of consistency, or boosting visibility could introduce diffuseness that complicates incrementation. In evaluation, these relations enable an analytical approach by prioritizing dimensions based on the dominant activities in a given context. Analysts first identify the primary tasks—such as transcription in data entry or exploratory design in ideation—and then assess the notation's profile against the ideal configuration for those activities, revealing mismatches qualitatively without relying on numerical models. This activity-driven prioritization guides designers toward balanced improvements tailored to user needs.

Design and Evaluation

Design maneuvers

Design maneuvers refer to deliberate modifications in the design of a notation aimed at enhancing one or more cognitive dimensions, typically involving trade-offs with other dimensions to balance usability for specific user activities.^[10] These strategies are informed by the cognitive dimensions framework and focus on proactive adjustments rather than post-hoc evaluation, allowing designers to explore alternative notations systematically.^[3] Common examples illustrate how maneuvers target particular dimensions while incurring costs elsewhere. For instance, reducing viscosity—the resistance to making small changes—can be achieved through modularization, such as introducing subroutines or abstraction mechanisms that encapsulate repetitive code fragments, thereby minimizing knock-on effects from edits; however, this often trades off by increasing the abstraction gradient, as users must navigate higher levels of encapsulation, potentially delaying comprehension for novices.^[3] Similarly, enhancing visibility and juxtaposability—the ease of viewing and comparing related components—might involve implementing hierarchical views or browser tools that unfold nested structures on demand, but this can raise diffuseness by expanding the overall space required for the notation, overwhelming working memory during scanning.^[1] Another approach uses secondary notation, such as indentation or layout conventions, to boost role-expressiveness by clarifying component purposes without altering the primary syntax; yet, inconsistent application risks heightening error-proneness, as users may misinterpret ambiguous spatial cues leading to slips.^[10] Maneuvers can be categorized into local fixes and global redesigns. Local fixes involve targeted syntax tweaks, like simplifying identifier rules to improve consistency—the ease of inferring notation rules from known parts—or adding explicit visual links to reduce hidden dependencies in dataflow representations, often with minimal disruption to the overall structure.^[3] In contrast, global redesigns entail broader changes, such as layering abstraction mechanisms (e.g., object-oriented hierarchies) to lower viscosity and support progressive evaluation of incomplete artifacts, though these may introduce premature commitment if the layers force early structural decisions.^[1] Guidelines for applying design maneuvers emphasize alignment with intended user activities, such as exploratory design or systematic modification, to prioritize dimensions accordingly—for example, favoring low viscosity for iterative tasks while accepting higher diffuseness.^[10] Designers should explicitly document trade-offs, using activity profiles to predict impacts, and iteratively test maneuvers to ensure net usability gains without unintended increases in cognitive load.^[3]

Evaluation techniques

The cognitive dimensions framework employs a suite of practical, lightweight evaluation techniques to assess how well a notation supports user activities, focusing on structural properties rather than exhaustive empirical data. These methods enable designers to diagnose usability issues by generating a "profile" of the notation's strengths and weaknesses across relevant dimensions, facilitating informed design decisions without requiring specialized equipment or large-scale testing.^[5] A core technique is the informal walkthrough, in which evaluators simulate user interactions by mentally stepping through representative tasks, such as incrementing a design or exploring alternatives. For each task step, they rate dimensions using a qualitative scale (e.g., low to high viscosity) and operational questions, such as "How much effort is required to perform a simple edit?" or "Are dependencies between elements overtly visible?" This approach allows rapid identification of cognitive loads, like knock-on effects in modifications, and is particularly useful during early design stages.^[11] User studies extend walkthroughs by incorporating empirical observation, where participants execute activities on the notation while evaluators track performance metrics tied to dimensions, such as time for error correction or frequency of premature commitments. Structured questionnaires, presenting all dimensions for user rating on relevance and ease, elicit subjective insights; for example, studies of visual programming environments have used this to quantify issues like high viscosity, where edit times exceeded 500 seconds in box-and-wire notations compared to under 100 seconds in textual ones, highlighting scalability concerns.^[5] Comparative analysis evaluates multiple notations side-by-side against a shared activity profile, scoring each on dimensions to reveal trade-offs, such as one system's strong abstraction gradient at the cost of reduced visibility. This method, applied to pairs like specification languages, produces tabular profiles that pinpoint relative advantages, aiding selection or hybridization in design contexts.^[12] The standard evaluation process starts with defining the notation's target activities (e.g., exploratory design versus transcription) to prioritize pertinent dimensions, followed by applying operational questions to generate the profile. Strengths and weaknesses emerge from this mapping, informing targeted improvements; for instance, a high rating in hidden dependencies might suggest maneuvers to enhance visibility. Profiles are often visualized as tables linking activities to dimension scores for clarity.^[11] Supporting tools include checklists of operational questions and benchmarks from framework resources, such as the Cognitive Dimensions tutorial, which lists queries like "Does the notation force early decisions on irrelevant details?" for each dimension. These are adaptable to HCI heuristics without formal software, though web-based examples and interactive widgets aid practice. No proprietary tools exist, emphasizing the framework's accessibility for non-experts.^[11] Best practices stress integrating these techniques with complementary usability methods, like GOMS modeling for detailed cognitive modeling, to mitigate inherent subjectivity in ratings. Evaluations should explicitly address trade-offs—e.g., boosting diffuseness for flexibility may increase viscosity—and remain context-specific, avoiding generic application across all notations. Documenting rationales with task examples ensures reproducible, actionable outcomes.^[5]

Applications and Developments

Historical applications

The cognitive dimensions framework, introduced by Thomas Green in the late 1980s, saw its first major applications in the 1990s through evaluations of visual programming languages (VPLs). A seminal case study was Green and Petre's 1996 analysis of two commercial dataflow VPLs, LabVIEW and Prograph, which demonstrated the framework's utility in identifying usability strengths and weaknesses.^[5] In LabVIEW, for instance, the notation excelled in closeness of mapping by resembling electronic schematics, facilitating intuitive understanding for engineers, but suffered from high viscosity, where simple modifications like adding air resistance to a simulation required repositioning multiple elements and rewiring connections, taking over 500 seconds.^[4] This evaluation highlighted trade-offs inherent in early VPLs, such as prioritizing schematic fidelity at the expense of editability, and established the framework as a practical tool for broad-brush usability assessments rather than exhaustive empirical testing.^[5] Beyond VPLs, the framework was applied to diagram notations in software engineering during the late 1990s and early 2000s, particularly in assessing tools for modeling complex systems. For example, Kutar, Finney, and Sommerville's 2002 study used cognitive dimensions to compare two UML diagram notations—sequence diagrams and collaboration diagrams—revealing issues like low visibility in collaboration diagrams due to dispersed elements, which hindered comprehension of interactions.^[13] These analyses influenced the iterative refinement of diagrammatic tools, including UML, by emphasizing dimensions like diffuseness and secondary notation to reduce cognitive load in professional workflows.^[13] Concurrently, spreadsheet usability studies in end-user programming contexts adopted the framework to probe notation limitations; early work, such as that referenced in PPIG workshops, examined how spreadsheets' grid-based structure promoted abstraction for formula reuse but imposed high error-proneness through implicit dependencies, leading to frequent calculation errors in non-expert use.^[14] The framework's integration into early HCI conferences further amplified its historical reach, with presentations at events like the BCS HCI Conference in 1998 showcasing its application to information visualization notations.^[10] There, Green's tutorial illustrated how dimensions like progressive evaluation could evaluate visualization tools for exploratory tasks, aiding designers in balancing exploratory freedom against conservatism to prevent unintended data alterations.^[10] These conference discussions, alongside the 1996 Petre and Green paper's focus on programming environments, cemented the framework's role in end-user programming research, where it became a standard for demonstrating real-world trade-offs—such as the high viscosity in early visual languages that slowed iterative development despite their intuitive appeal.^[5] By the early 2000s, these applications had shaped tool designs like UML diagrams, promoting notations that mitigated cognitive bottlenecks in software engineering and visualization practices.^[13]

Modern extensions and criticisms

Since the early 2010s, the Cognitive Dimensions of Notations (CDN) framework has been extended to evaluate emerging domains such as no-code platforms, where it assesses usability in drag-and-drop interfaces for progressive evaluation. For instance, a 2023 analysis applied CDN to three state-of-the-art no-code editors, highlighting strengths in low viscosity for rapid prototyping but weaknesses in abstraction gradients for complex logic.^[15] Similarly, integration with cognitive models appeared in 2022 software engineering studies, such as evaluations of cross-platform frameworks like Flutter and React Native, where CDN complemented user studies to quantify dimensions like consistency and error-proneness.^[16] More recently, 2025 proposals have incorporated AI-assisted notations, with tools like NaturalEdit using CDN to design adaptive summaries and intent-driven synchronization, addressing viscosity and visibility in natural language-code interactions.^[17] Criticisms of the CDN framework center on its inherent subjectivity in dimension ratings, as it relies on heuristic discussions rather than standardized metrics, leading to varied interpretations across evaluators.^[18] Additionally, while influential, the framework lacks comprehensive empirical validation for several dimensions, with a 2016 systematic review of over 1,600 citations finding only limited experimental support and frequent misapplications in summative evaluations.^[19] The original framework is also seen as outdated for multimodal or adaptive interfaces, overlooking gesture-based interactions and dynamic UIs, though recent extensions like sketched notations for UI design have begun addressing these gaps by emphasizing abstraction and AI-driven adaptability.^[20] Furthermore, it provides limited handling of collaborative use, prompting calls for supplementary dimensions focused on shared editing and communication.^[21] Recent developments show sparse major updates to the core framework, with CDN remaining a staple in HCI literature for exploratory design but without revolutionary overhauls; a 2024 tool like PUX Explorer builds on it interactively for notation critique.^[22] Suggestions include adding dimensions for adaptability in dynamic UIs to better suit modern contexts.^[19] Looking ahead, future directions emphasize developing quantitative metrics for dimensions and AI-enhanced evaluation tools to reduce subjectivity and improve empirical rigor.