18 November 2026

🎯Derar Alhussein - Collected Quotes

"A data lakehouse represents a hybrid solution that combines the best aspects of data lakes and data warehouses. Specifically, it integrates the openness, scalability, and cost efficiency of data lakes with the reliability, strong governance, and performance features of data warehouses." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"A data stream represents an unbounded flow of data, often originating from various sources such as sensors, log files, or social media platforms. As new data is generated, it is appended to the stream, making it a dynamic and constantly changing dataset." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025) 

"At the top of the architecture is the Databricks workspace, which serves as the user interface for interacting with the platform. It provides an interactive environment where users can perform data engineering, analytics, and AI workloads using a variety of languages, such as Python, SQL, R, and Scala. The workspace offers a range of services, including notebooks for development, dashboards for visualizing data, and workflow management tools for orchestrating data pipelines." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Clusters in Databricks form the backbone of data processing and analytics on the platform. A cluster is essentially a collection of computers, often referred to as nodes, instances, or virtual machines, working together as a single entity. In the context of Apache Spark, which powers Databricks, a cluster comprises a master node known as the driver and several worker nodes [...]. The driver node is primarily responsible for orchestrating the activities of the worker nodes, which execute tasks in parallel, thereby enabling efficient processing of large-scale data." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Data ingestion [...] refers to the process of loading data from files into Delta Lake tables. One of the significant challenges in data ingestion is the need to avoid reprocessing the same files multiple times. In a traditional data pipeline, each time the pipeline is run, it would reprocess all the files, including those that have already been ingested previously. This approach can be computationally expensive, time-consuming, and can lead to additional deduplication work, especially when dealing with large datasets, and this is where incremental data ingestion comes into play." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Databricks notebooks are interactive development environments that enable you to write, debug, and execute code in a collaborative setting. These notebooks offer advanced capabilities that extend beyond those of traditional environments like Jupyter Notebooks. Databricks notebooks support multiple programming languages, including Python, SQL, Scala, and R. In addition, they integrate seamlessly with Spark clusters, allowing users to leverage distributed computing resources directly from the notebook interface." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Databricks Runtime is a pre-configured virtual machine image optimized for use within Databricks clusters. It includes a set of core components, such as Apache Spark, Delta Lake, and other essential system libraries. Delta Lake enhances traditional data lakes by providing transactional guarantees similar to those found in operational databases, thereby ensuring improved data reliability andconsistency." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"In case of failures, such as node crashes or network issues, the streaming engine is capable of resuming processing from where it left off. This is achieved through the combination of checkpointing and a mechanism called write-ahead logs. They enable capturing the offset range corresponding to the data being processed during every trigger, which makes it possible to recover from failures without any data loss. It’s important to note that this guarantee mainly depends on the repeatability of the data sources. Data sources such as cloud-based object storage or pub/sub messaging services are typically repeatable, meaning that the same data can be read multiple times if needed. This allows the streaming engine to restart or reprocess the data under any failure condition." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025) 

"In Structured Streaming, the key idea is to handle live data streams as unbounded, continuously growing tables, where each incoming data item is appended as a new row [...]. This design allows you to apply familiar SQL and DataFrame operations on streaming data in the same way you would with batch data. By unifying batch and streaming operations, Structured Streaming eliminates the need for separate technology stacks and facilitates the migration of your existing batch Spark jobs to streaming jobs." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"It’s crucial to be aware of the limitations associated with tables having foreign data sources - they are not Delta tables. This means that the performance benefits and features offered by Delta Lake, such as time travel and guaranteed access to the most recent version of the data, are not available for these tables. This limitation becomes especially noticeable when dealing with large database tables, potentially leading to performance issues." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Partitioning can significantly enhance the performance of large Delta tables by facilitating efficient data retrieval. However, it’s important to note that for small to medium-sized tables, the benefits of partition may be negligible or outweighed by drawbacks. One significant drawback is the potential emergence of what is known as the 'small files problem'. This problem arises when data partitioning results in the creation of numerous small files, each containing a relatively small amount of data. While partitioning aims to improve query performance by reducing the amount of data scanned, the presence of many small files can prevent file compaction and efficiency in data skipping. In general, partitioning should be selectively applied based on the size and nature of the data." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Spark Structured Streaming is a scalable stream processing engine that revolutionizes the way data streams are processed and queried. It enables querying of infinite data sources, automatically detecting new data as it arrives and persisting results incrementally into target data sinks [...]. A sink is often a durable storage system such as files or tables that serves as the destination for the processed data." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"Time travel is a feature in Delta Lake that allows you to retrieve previous versions of data in Delta Lake tables. The key aspect of Delta Lake time travel is the automatic versioning of the table. This versioning provides an audit trail of all the changes that have happened on the table. Whenever a change is made to the data, Delta Lake captures and stores this change as a new version. Each version represents the state of the table at a specific point in time."(Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"What makes Delta Lake an innovative solution is its ability to overcome such challenges posed by traditional data lakes. Delta Lake provides ACID transaction guarantees for data manipulation operations in the lake. It offers transactional capabilities that enable performing data operations in an atomic and consistent manner. This ensures that there is no partially committed data; either all operations within a transaction are completed successfully or none of them is. These capabilities allow you to build reliable data lakes that ensure data integrity, consistency, and durability." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

"While data lakes are excellent solutions for storing massive volumes of diverse data, they often encounter several challenges related to data inconsistency and performance issues. The primary factor behind these limitations is the absence of ACID transaction support in a data lake. ACID stands for atomicity, consistency, isolation, and durability, and represents fundamental rules that ensure operations on data are reliably executed, as in traditional databases. This absence led to issues such as partially committed data and corrupted files, ultimately affecting the overall reliability of the data stored in the lake." (Derar Alhussein, "Databricks Certified Data Engineer Associate Study Guide", 2025)

🤖Prompt Engineering: Problems (Just the Quotes)

"Chain-of-thought prompting is a method that forces LLMs to reason through a series of steps, resulting in more structured, transparent, and precise outputs. The goal is to break down complex tasks into smaller, interconnected subtasks, allowing the LLM to address each subtask in a stepby-step manner. This not only helps the model to 'focus' on specific aspects of the problem, but also encourages it to generate intermediate outputs, making it easier to identify and debug potential issues along the way. Another significant advantage of chain-of-thought prompting is the improved interpretability and transparency of the LLM-generated response. By offering insights into the model’s reasoning process, we, as users, can better understand and qualify how the final output was derived, which promotes trust in the model’s decision-making abilities." (Sinan Ozdemir, "Quick Start Guide to Large Language Models: Strategies and Best Practices for Using ChatGPT and Other LLMs", 2024) 

"Another problem that can be confusing is that LLMs seldom put out the same thing twice. [...] Traditional databases are straightforward - you ask for something specific, and you get back exactly what was stored. Search engines work similarly, finding existing information. LLMs work differently. They analyze massive amounts of text data to understand statistical patterns in language. The model processes information through multiple layers, each capturing different aspects - from simple word patterns to complex relationships between ideas." (Jeremy C Morgan, "Coding with AI: Examples in Python", 2025)

"AI isn’t just going to be about our digital world. It’s also about our physical world; and applied properly, imagine what AI can do for the pace of discovery and innovation. It’s not just makeup; imagine what it can do for new materials discovery for medicine, energy, climate, and all the other pressing challenges we face as a species - these are the same challenges of makeup, just described with a different 'language'. And quantum computing evolves, we’re bound to see a synergy of these innovations that we can use to tackle these problem domains and more." (Rob Thomas et al, "AI Value Creators: Beyond the Generative AI User Mindset", 2025)

"Despite their impressive capabilities, LLMs are not without limitations. One of the most significant challenges is the problem of hallucination, where an LLM generates factually incorrect or misleading information that appears plausible. This is particularly problematic in domains requiring high factual accuracy, such as healthcare, finance, and legal applications. To mitigate hallucinations and enhance the reliability of LLM outputs,  Retrieval-Augmented Generation (RAG) has emerged as a powerful technique. RAG works by dynamically retrieving relevant information from an external knowledge source (such as a knowledge graph) at inference time, rather than just relying on pre-trained knowledge. This approach ensures that the model has access to up-to-date and accurate data, grounding answers in verified information rather than generating content purely from its internal representations." (Aldo Marzullo et al, "Graph Machine Learning" 2nd Ed., 2025)

"The same difficulties that characterize training deep feedforward networks also apply to RNNs; gradients tend to die out over long distances using traditional activation functions (or explode if the gradients become greater than 1). However, unlike feedforward networks, RNNs aren’t trained with traditional backpropagation, but rather a variant known as Backpropagation through Time (BPTT): the network is unrolled, as before, and backpropagation is used, averaging over errors at each time point (since an 'output', the hidden state, occurs at each step). Also, in the case of RNNs, we run into the problem that the network has a very short memory; it only incorporates information from the most recent unit before the current one and has trouble maintaining long-range context. For applications such as translation, this is clearly a problem, as the interpretation of a word at the end of a sentence may depend on terms near the beginning, not just those directly preceding it." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"Transformers are complex models built like LEGO blocks using multiple smart and specialized components. [...] Briefly, a vanilla transformer model consists of separate stacks of encoders and decoders. Each encoder block includes multi-head self-attention, enabling the model to capture relationships between tokens regardless of their positions. Residual connections help maintain gradient flow, preventing the vanishing gradient problem. Layer normalization ensures training stability, and feed-forward layers introduce non-linearity and learn complex token interactions. Decoder blocks contain the same components but also include an encoder-decoder attention mechanism to incorporate context from the encoder. The model uses embedding layers to convert tokens into a continuous latent space for contextual learning and positional encoding to preserve the order of tokens in the sequence." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"When there are hidden layers between the input and output, the problem becomes more complex: when do we change the internal weights to compute the activations that feed into the final output? How do we modify them in relation to the input weights? The insight of the backpropagation technique is that we can use the chain rule from calculus to efficiently compute the derivatives of each parameter of a network with respect to a loss function and, combined with a learning rule, this provides a scalable way to train multilayer networks." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"While the backpropagation procedure provides a way to update interior weights within the network in a principled way, it has several shortcomings that make deep networks difficult to use in practice. One is the problem of vanishing gradients. [...] As the value of the sigmoid function increases or decreases toward the extremes (0 or 1, representing either 'off' or 'on' ), the values of the gradient vanish to near zero. This means that the updates to and , which are products of these gradients from hidden activation functions , shrink toward zero, making the weights change little between iterations and making the parameters of the hidden layer neurons change very slowly during backpropagation. Clearly, one problem here is that the sigmoid function saturates; thus, choosing another nonlinearity might circumvent this problem." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"A major aspect of the alignment problem is values misalignment: AI systems may lack sufficient understanding of human ethics, cultural norms, or social contexts, making it difficult to translate our values directly into algorithms. For instance, if an AI is programmed to prioritise efficiency without balancing safety or ethical considerations, it might make decisions that, while effective, disregard human welfare. This is further complicated by 'specification gaming', where an AI might exploit loopholes in its programming to achieve objectives in unintended or counterproductive ways. An AI instructed to avoid obstacles, for instance, could redefine what counts as an 'obstacle' and take routes that, while technically following the rule, lead to negative outcomes." (Alan Watkins & G C Cooke, "Smarter than You Winning in Business with Superintelligent AI", 2026)

"As AI systems become more integrated into critical decision-making processes, the 'black box' problem – the inability to understand how a model arrived at a specific output – becomes a major barrier to trust and adoption. For RAG systems, this is particularly crucial; a user needs to know not just the answer, but why the system believes that answer to be true. Transparency and explainability (explainable AI, XAI) are the disciplines focused on making AI reasoning understandable to humans. A transparent RAG system allows users to verify the accuracy of its responses, builds trust by demonstrating a logical process, and enables developers to debug and improve the system. It transforms the AI from an oracle that must be blindly trusted into a tool for augmented intelligence, where the human remains the ultimate arbiter of truth." (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

"As an AI engineer, you can ask a foundational model to directly generate the content your application needs by sending the model an appropriate text input, which is known as a prompt. However, you will face certain common problems - the generated content may not match the style you want, may be missing enterprise knowledge that the model doesn’t know about, or may lack certain capabilities." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"Generative AI has a lot of problems because it needs a lot of data to work. Generative models like GPT and GANs need a lot of training data to learn patterns and make good outputs. This data dependency can cause problems like overfitting, which happens when the model does well on training data but doesn’t work well with new, unseen data. Also, the quality of the content that is generated is directly related to the diversity and representativeness of the training data. This means that biased or incomplete datasets can lead to outputs that are wrong or unfair." (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

"MCP is an open standard that lets AI applications connect to external tools, data sources, and workflows through a consistent, discoverable interface. In practice, MCP enables LLM-powered hosts, such as IDEs, desktops, and cloud services, to discover capabilities at runtime. These hosts can then invoke tools through a shared schema without requiring bespoke adapters for each integration [..]. MCP addresses the long-standing M×N integration problem: without a common protocol, every model ends up integrating separately with every system. MCP collapses this complexity by standardizing how agents discover, call, and exchange context with external capabilities." (Bennie Haelen, "ML and Generative AI in the Data Lakehouse Building and Deploying AI Applications at Scale", 2026)

"Multiagent architectures offer better scalability than monolithic approaches do. Rather than scaling vertically by increasing model size, multiagent systems can scale horizontally by adding more specialized agents as needed. You can update or replace individual agents without having to retrain the entire system, and that allows for more agile development and deployment. Computational resources can also be allocated dynamically based on current needs, with more resources directed to the most critical or computationally intensive subtasks. Multiagent systems are also more robust. Critical capabilities can be replicated across multiple agents to reduce the impact of individual agent failures. Different agents can approach problems with different methodologies, which increases the likelihood of finding effective solutions. Agents can verify each other’s outputs to identify and correct errors that might go undetected in a single-agent system." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"[...] RNNs [...] process tokens sequentially, one at a time, and are known to suffer from the long-range dependency problem. This 'forgetfulness' problem is common in RNNs, where information from earlier parts of the input gradually fades, meaning the model quickly forgets the context of the sentence, making it hard for the decoder to produce meaningful output over longer sequences. It’s sort of like short-term amnesia that results in a loss of coherence as tokens pass by." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The first big innovation in the transformer architecture is its ability to process tokens in parallel rather than sequentially, one at a time. This was a huge breakthrough, as it allowed faster training and effectively overcame the long-range dependency problem. Rather than reading one sentence at a time as humans do, a transformer reads a whole input sequence at once - spanning hundreds of thousands of words in some cases. To be clear, there are still limitations to how much a transformer can read in parallel, known as the context window, but generally this window is very large. The ability to examine words in parallel allows the transformer to understand how words relate to each other, even if they are far apart in the same sentence, paragraph, or even whole book." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The most common form of prompt hacking is prompt injection. This occurs when an attacker embeds malicious instructions inside a seemingly innocuous prompt to override the developer’s intended task. The root of the problem is architectural: current language models treat all text, including system prompts, developer instructions, and user input, as one continuous sequence. There is no built-in notion of 'trusted' versus 'untrusted' input, so a later instruction can supersede an earlier one. The simplest version is direct injection, where the attacker places the malicious directive directly in the user’s input. A classic example exploits the fact that models prioritize more recent or specific instructions [...] Indirect injection hides instructions in external content, such as a web page or document the model is asked to summarize, so the model executes code it wasn’t supposed to see. Specialized variants include code injection, where a code-generation assistant is tricked into outputting malicious commands, and recursive injection, where the output of one model carries an injection to the next in a chain. All of these attacks exploit the model’s inability to separate context from instruction." (Chris Minnick, "A Developer’s Guide to Integrating Generative AI into Applications", 2026)

"The process of deciding which features to include and which ones to ignore is known as feature engineering. It is a critical step in supervised learning. More features can make the model more powerful and accurate, but they also make it more complex, harder to interpret, and slower to train. As in many other parts of AI, deciding the number of features for a particular problem is often a balancing act." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The promise of AI is its ability to process information objectively and at scale. However, this promise is fundamentally threatened by the twin challenges of bias and misinformation. AI systems are not born in a vacuum; they are created by humans and trained on data produced by humans. Consequently, they are prone to inheriting and even amplifying our prejudices, errors, and the systemic inequalities present in that data. In a RAG system, this risk is a two-fold problem: first in the retrieval of information, and second in the generation of a response based on that retrieval. A failure to address these issues doesn’t just lead to technically incorrect outputs; it can perpetuate social harm, erode public trust, and lead to the widespread dissemination of falsehoods. Therefore, understanding and mitigating bias and misinformation is not an optional add-on but a core requirement for any ethically deployed AI system." (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

"Traditional RAG systems 'guide' LLMs in generating responses by providing document chunks that are related to the user’s initial query. Incorporating external knowledge from a document store helps to reduce hallucinations, but its effectiveness relies heavily on the relevance of the retrieved document chunks. This can be problematic if the retrieval step produces irrelevant document chunks or incorrect information. The key goal of corrective retrieval-augmented generation (CRAG) is to detect and correct hallucinations before the LLM attempts response generation. It adds an evaluator to the process that evaluates the quality of the retrieved chunks for a given query before passing on the documents to the response generation step. The evaluator returns a confidence score that triggers different knowledge retrieval actions." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

17 November 2026

🏭🗒️Microsoft Fabric: Capacity Management [Notes]

Disclaimer: This is work in progress intended to consolidate information from various sources for learning purposes. For the latest information please consult the documentation (see the links below)! 

Last updated: 16-Nov-2026

[Microsoft Fabric] Capacity Management

  • {def} process for the administration and governance of the compute resources (CUs) available in a Fabric capacity
  • {concept} capacity 
    • {def} a dedicated set of compute resources that are available at a given time to be used
      • each capacity has fixed compute resources measured in CUs [6]
      • defines the ability of a resource to perform an activity or to produce output
      • resides in a specific region of the buyers’ choice where both the data & compute reside [3]
      • provides the compute and storage for all the workspace artifacts [3]
        • workspaces are assigned to a capacity 
    • shared across:
      • workloads
        • a single capacity provides the computing power for all Fabric workloads, and there is no need to allocate compute separately per engine.
      • projects
        • a capacity typically supports dozens of separate projects, each in its own workspace(s).
      • users
        • every user action that consumes compute (e.g. queries, refreshes, pipeline runs, notebook execution) uses the same capacity pool.
    • priced at a fixed hourly rate 
      • multiple capacities can be purchased, deployed and managed by different owners residing in a single tenant 
        • {benefit} allows each business unit to pay for their own consumption [3]
      • based on CUs provisioned [3]
      • dimensioned as a function of cores: 
        • F2=2^1, F4=2^2, ..., F32=2^5, F64=2^6, ..., F2048=2^11 (powers of 2 from 1..11)
        • ⇐ flexible building blocks for growth
        • with increased Fx it provides
          • better concurrency 
          • lower throttling risk
          • more realistic PoCs
          • better workload isolation
          • increased reliability 
      • purchased either as 
        • PAYG model
        • RI resource
        • F0 
  • {concept} Stock Keeping Unit (SKU)
    • {def} the capacity tier that determines how much compute power, memory, and overall performance a Fabric environment receives
  • {concept} capacity unit (CU) 
    • {def} the standardized measure of computing resources available to a Fabric capacity
      • used to abstract away the actual CPU cores, memory, and infrastructure so that customers can size Fabric workloads consistently
        •  measure the compute power available for each SKU [2]
    • CUs consumption is not a hard limit per SKU
      • based on an average over a 24-hour period
        • gives customers the ability to take advantage of bursting and smoothing
  • {concept} timepoint 
    • {def} internal measurement intervals MF uses to evaluate how much CU consumption is occurring over time and whether the capacity is being throttled
      •  24 hours contain 2,880 timepoints
      •  Fabric automatically manages the amount of consumed CUs in each timepoint [2]
      •  the boundaries are aligned to the Fabric service clock
      •  a workload is charged to whichever 30-second timepoint(s) are active when the work executes
  • {concept} overage
    • the amount of capacity debt that would otherwise cause throttling because a capacity has consumed more compute than its provisioned CUs can support after smoothing
      •  when overages exceed the allowed 10-minute throttling window, they become carryforward CUs [2]
        • carryforward CUs apply to each subsequent timepoint [2]
        • if a timepoint isn't full, the unused CUs reduce the carryforward CUs amount (aka burndown)
  • {operation} provisioning (aka capacity provisioning)
    • provisioned with a certain amount of compute units, analogous to CPU cores
    • there is no authoritative guide to help customers calculate the CUs required by a solution
    • {recommendation} experiment to figure out the best fit
      • allows to find the optimum size for workloads  
  • {operation} configuration (aka capacity configuration) 
    • capacities can be configured in endless ways to meet scale, usage and governance requirements while tuning to minimize TCO and performance goals [3]
  • {mechanism} bursting
    • the ability for a Fabric capacity to temporarily consume more compute resources beyond what the customer purchased, respectively beyond what was allocated for a given job
    • {benefit} job acceleration 
      • allows to speed workloads execution
        • e.g. instead of running a job on 64 CUs in 60 seconds, bursting could use 256 CUs to complete in 15 seconds
    • {benefit} use extra resources
      • allows workloads to use additional compute resources to handle spikes in capacity requirements over short periods of time
        • allows jobs to utilize far more resources than 'face value'
      • improves users’ experience
      • provides a temporary relief, until the burst allowance is eventually exhausted
      • {warning} can hide capacity sizing problems
        • because bursting absorbs occasional overloads
        • potential for future throttling, if not addressed timely
    • {characteristic} automatic 
      • automatically allocates resources as needed to execute at maximum performance [3]
        • regardless of SKU
        • {warning} one query could consume all the quota of a single time window and much more! [3]
      • when the system reasons it can accelerate the job by applying extra resources [3]
        • occurs behind the scenes, acting as a buffer
        • no settings are required [3]
  • {mechanism} smoothing (aka averaging)
    • a mechanism that spreads the CU consumption of operations across future time periods [5]
      • instead of scheduling all consumption immediately [5]
      • run when small usage bursts occur, flattening compute usage over time to help customers avoid being penalized with additional cost [5]
        • operation's utilization type determines the number of timepoints that Fabric uses for smoothing [2]
          • interactive operations are smoothed over a minimum of five minutes, and up to 64 minutes depending on how much CU usage they consume [2]
          • background operations are smoothed over a 24-hour period because [2]
            • they typically have long runtimes and large CU consumption [2]
      • ensures users can enjoy consistently fast performance without throttling [2]
        • only a portion of the CU usage for an operation applies to any individual timepoint, which reduces throttling overall [2]
        •  smoothed CU usage accumulates as operations run [2]
        • future capacity (CUs available in future timepoints) pays for smoothed usage [2]
          • because the capacity runs continuously [2]
    • bursting and smoothing work together
      • let capacities self-manage and self-heal when temporary spikes in usage would otherwise cause other systems to fail or slow down [2]
      • aren't supported when Autoscale Billing for Spark is enabled [2]
        • Spark usage operates in a PAYG mode [2]
    • {benefit} workload stabilization
      • helps capacities self-stabilize by flattening loads with large spikes into a smooth load profile, eliminating temporal spikes [3]
      • pays back that additional compute consumption when the capacity is less in demand 
        • prevents overloads as the smoothing mechanism will always flatten the resource burst [3]  
    • {benefit} scheduling contention elimination
      • large/scheduled jobs are smoothed over 24 hours [5]
        • eliminates the need to decide the timing and order of job execution [5]
        • operations are always executed for maximum performance [5]
    • {benefit} bad actor protection
      • prevents a single actor (user) with a very demanding query from hogging the entire capacity [5]
        • interactive operations are smoothed over several minutes [5]
  • {mechanism} throttling 
    • {def} protection mechanism that activates when a capacity resource consumption exceeds the capacity threshold for the current time window [5]
      • there can be a short delay before throttling begins [6]
      • running too many operations can overload a capacity [2]
        • the capacity automatically throttles new operations when it's overloaded [2]
      • happens in progressive steps [2]
        • helps to minimize the impact on important tasks like data refreshes [2]
      • not applied automatically when a capacity is operating above 100% utilization [2]
        •  see overage protection
      • an indicator that the capacity is experiencing sustained pressure [5]
        • while one capacity, or set of workspaces, might experience reduced performance from being overloaded, other capacities might continue running normally [2]
      • too much throttling can result in a degraded end-user experience [2]
      • applied at the capacity level [2]
    • starts when a capacity uses up all its CU resources for the next 10 minutes, when overage protection ends [2]
      •  
      • {phase} applies 20-second delays to new interactive operations [2]
      • {phase} rejects new interactive operations when a capacity uses up all its CU resources for the next one hour [2]
        • background operations can start and run [2]
      • {phase} rejects all new requests, interactive and background, when the capacity uses up all its available CU resources for the next 24 hours [2]
        •  the capacity continues to throttle requests until you pay off the consumed CUs [2]
      •  its enforcement continues until unused capacity pays off all carryforward CUs [2]
    • consistently high throttling levels indicate the need to either
      • load balance across multiple capacities [2]
      • increase the capacity SKU size [2]
    • {concept} throttling policies
      • {def} rules Fabric uses to slow down or reject workload execution when a capacity is overloaded
      • prevent a capacity from becoming unusable when its smoothed consumption exceeds the available Capacity Units (CUs).
      • refined to deliver multiple benefits [3]
    • reduced throttling for capacities that only experience occasional spikes [3]
    • [monitoring] Fabric capacity metrics app cane be used to confirm throttling
      • via Compute page >> System events table 
        • shows the history of t4hrottling events [2]
      • via Compute page >> Throttling charts 
        • show when smoothed usage exceeds one of the throttling limits [2]
  • {feature} capacity overage (aka overage protection)
    • {def} feature that allows a capacity to continue running when it would otherwise be throttled because the purchased CU where exceeded
  • {feature} surge protection
    • {def} mechanism that helps prevent a Fabric capacity from becoming overloaded by proactively limiting background workloads before the capacity reaches severe throttling
      • interactive operations smoothed over several minutes, preventing a single user with a very demanding query from hogging the entire capacity [3]
  • {capacity size} F0
    • a zero-provisioned capacity SKU 
      • announced at FabCon Europe Sep, 2026
    • {characteristic} billed on demand
      • no upfront compute charge
      • accommodates one billing category workloads
        • e.g. Data Warehouse
      • designed to work with on-demand billing 
        • rather than requiring customers to reserve compute capacity upfront
    • {characteristic} built-in monitoring
      • via Capacity Metrics >> 'On-demand compute' tab⠀
    • {characteristic} supports no smoothing
      • priced as a multiplier of PAYG
        • prices yet to be disclosed 
    • {advantage} start small, scale on demand
    • {disadvantage} steep learning curve
      • especially when no trial capacity is available
    • {scenario} development & testing with minimal workloads
    • {scenario} small proof-of-concepts
    • {scenario} sporadic workloads
    • {scenario} organizations wanting consumption-based billing
  • {capacity size} F2
    • entry-level capacity with access to standard Fabric features
    • best suited for lightweight, low‑volume, or exploratory workloads that don't require parallelism 
      •  useful to prove that solutions work
      • {scenario} proof-of-concepts
      • {scenario} individual usage
      • {scenario} training & testing with minimal workloads
    • can occasionally execute workloads larger than its nominal size
      •  e.g. small notebooks, warehouse queries may complete successfully 
    • {limitation} many workloads require at least F4 
      • e.g. Spark notebooks, Dataflows, Power BI refreshes), while bursting and smoothing provides less benefit; 
    • {limitation} not viable for production environments
      • very limited compute power
      • throttling occurs often 
      • poor fit for concurrent access 
      • limited refresh & ETL throughput 
  • {capacity size} F4
    • first usable production‑grade capacity for light to moderate workloads
      • ideal for PoCs, small production workloads, notebooks, though workloads may run soon into its limitations
    • allows to run concurrent activities
      • e.g. combined BI & Data Engineering 
    • includes all standard F-SKU features (Copilot, Managed Private Endpoints, etc.)
    • can support 
      • Power BI reports
      • small lakehouses
      • Data Factory pipeliness 
  • {capacity size} F8
    • generally considered strong enough for multiple developers, analysts, and BI users working at the same time
    • often support dozens to hundreds of actively used reports 
    • provides a more realistic environment for testing
      • scheduled refreshes 
      • concurrent users
      • automated pipelines
      • engineering workloads
  • {capacity size} F16
    • works well if workloads are light
    • often support dozens to hundreds of actively used reports
    • good for
      • smaller lakehouses
      • scheduled pipelines
      • moderate notebook execultion 
  • {capacity size} F32
    • suitable for mid-sized workloads, though it may be still insufficient for heavy workloads
    • often support hundreds to thousands of actively used reports.
    • good for
      • departmental BI
      • smaller semantic model
      • limited refresh schedules
    • best for
      • departmental Fabric deployments
      • medium-sized organizations
      • initial production rollouts
      • single-team ownership
  • {capacity size} F64
    • first high‑performance, enterprise‑grade Fabric capacities
      • it's designed for advanced workloads, multiple teams, and high‑throughput data operations
    • with it the licensing model for Power BI changes
      •  equivalent to a Power BI Premium-sized capacity
        •  ⇒ free Power BI user consumption 
          •  ⇐ a license is still needed for development
    • often support hundreds to thousands of actively used reports
    • often where organizations begin running
      • larger Spark workloads
      • multiple engineering team
      • more complex medallion architectures
      • heavy ingestion schedule
    • often the capacity where organizations start implementing
      • workspace isolation strategies
      • capacity governance
      • chargeback/showback
      • surge protection policies
      • dedicated engineering and BI workloads
  • {capacity size} F128+ 
    • ideal for scenarios in which multiple business units share a capacity
    • provides more flexibility in workload scheduling
    • can support very large enterprise estates with thousands of reports
    • governance becomes more important than performance 
  • {type} trial capacity
    • automatically created when a user begins to work with Fabric items in the Fabric portal
    • users are prompted to start the trial capacity [4] 
    • users using a non-Fabric-enabled workspace and who are trying to create Fabric-specific item for the first time, are automatically upgraded to a trial license for MF [4]
    • has a limitation of five trial capacities per tenant [4]
    • users can opt out between a F4 and F64 capacity
    • doesn't have access to all features
      • e.g. Copilot requires at least a F2 capacity
    • valid for 60 days from activation
      •  
  • {feature} Microsoft Fabric Capacity Metrics app 
    • allows monitoring the CUs usage to better understand how many CUs are required for operating your solution and whether you might want to consider scaling up or scaling out your Fabric SKU(s)

Previous Post <<||>> Next Post 

References:
[1] Microsoft Learn (2025) Manage your capacities in the Admin portal [link]
[2] Microsoft Learn (2026) Understand the Fabric capacity throttling policy [link]
[3] Benni De Jagere (202x) Understanding Fabric Capacities
[4] Brian Bønk & Valerie Junk (2026) Microsoft Fabric Analytics Engineer Associate Study Guide: Hands-On Practice and Expert Tips for Acing the DP600 Certification Exam
[5] Microsoft Learn (2026) Microsoft Fabric: Advanced Real-Time Intelligence
[6] Capacity overage in Microsoft Fabric [link]

Acronyms:
BI - Business Intellgience
CI/CD - Continuous Integration and Continuous Deployment
CU - Capacity Unit
IDE - Integrated Development Environments
MF - Microsoft Fabric 
PAYG - Pay-As-You-Go
SKU - Stock Keeping Unit 

🤖Prompt Engineering: Rules (Just the Quotes)

"How can a cognitive system process environmental input and stored knowledge so as to benefit from experience? More specific versions of this question include the following: How can a system organize its experience so that it has some basis for action even in unfamiliar situations? How can a system determine that rules in its knowledge base are inadequate? How can it generate plausible new rules to replace the inadequate ones? How can it refine rules that are useful but non-optimal? How can it use metaphor and analogy to transfer information and procedures from one domain to another?" (John H Holland et al, "Induction: Processes Of Inference, Learning, And Discovery", 1986)

"When there are hidden layers between the input and output, the problem becomes more complex: when do we change the internal weights to compute the activations that feed into the final output? How do we modify them in relation to the input weights? The insight of the backpropagation technique is that we can use the chain rule from calculus to efficiently compute the derivatives of each parameter of a network with respect to a loss function and, combined with a learning rule, this provides a scalable way to train multilayer networks." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"Unlike traditional code completion, which operates on predefined rules, generative AI creates a continuous improvement cycle, which includes the following five basic steps: (1) Developer input: You provide source code, comments, or natural language requirements. (2) Context analysis: The model analyzes patterns in your existingcode and requirements. (3) Prediction: Based on training data and your specific context, the model generates probable code. (4) Developer feedback: You accept, modify, or reject suggestions. (5) Model adaptation: The system incorporates your feedback to improve future suggestions." (Jeremy C Morgan, "Coding with AI: Examples in Python", 2025)

"A major aspect of the alignment problem is values misalignment: AI systems may lack sufficient understanding of human ethics, cultural norms, or social contexts, making it difficult to translate our values directly into algorithms. For instance, if an AI is programmed to prioritise efficiency without balancing safety or ethical considerations, it might make decisions that, while effective, disregard human welfare. This is further complicated by 'specification gaming', where an AI might exploit loopholes in its programming to achieve objectives in unintended or counterproductive ways. An AI instructed to avoid obstacles, for instance, could redefine what counts as an 'obstacle' and take routes that, while technically following the rule, lead to negative outcomes." (Alan Watkins & G C Cooke, "Smarter than You Winning in Business with Superintelligent AI", 2026)

"Although GenAI gets most of the attention for its ability to create new content, successful AI applications often combine multiple approaches. Generative models aren’t always the optimal choice for every component of an AI system. Traditional ML models, rule-based systems, and algorithmic approaches can offer significant advantages in speed, accuracy, cost-effectiveness, and reliability when used strategically alongside GenAI." (Chris Minnick, "A Developer’s Guide to Integrating Generative AI into Applications", 2026)

"An alternative future is a more federated open-source AI where commoditised LLM can be run independently by anyone but loosely coordinated between each other if that is mutually advantageous. This requires sophisticated governance of an ecosystem where the rules that maintain the healthy stability of the ecosystem are defined and adhered to. This model allows anyone to put any LLM on a normal computer and plug into the AI. This is the path that already seems most sensible to business leaders and government officials, who recognise that their private data and iterative datasets hold value that can increase productivity and improve the bottom line or assist citizens in their lives." (Alan Watkins & G C Cooke, "Smarter than You Winning in Business with Superintelligent AI", 2026)

"[...] KGs and LLMs can be the foundation for different types of reasoning, complementing each other in intelligent systems. We can use KGs for tasks that require precise, rule-based reasoning and explicit knowledge representation, and LLMs for tasks involving pattern recognition, context understanding, handling ambiguity or incomplete information, and reasoning about graph structures and their derived metrics. However, neither approach inherently possesses common-sense reasoning capabilities comparable to those of humans, and they often fail to make intuitive leaps or understand the implicit context that would be obvious to a person. These limitations underscore the importance of carefully considering the strengths and weaknesses of each approach when designing intelligent systems and potentially developing a powerful hybrid IAS." (Alessandro Negro et al, "Knowledge Graphs and LLMs in Action", 2026)

"Machine learning was a big change because it let systems learn patterns from data instead of having to follow hardcoded rules. AI could generalize better and change to new inputs thanks to techniques like decision trees and support vector machines. These models still needed a lot of work to get the features right, though, and they couldn’t handle high-dimensional data like images or text very well. The breakthrough happened when deep learning, a type of machine learning that uses neural networks with multiple layers to automatically learn hierarchical representations of data, became popular. Convolutional neural networks (CNNs) for processing images and recurrent neural networks (RNNs) for sequential data changed what AI could do. Architectures like GANs and transformers took things even further by making it possible to do things like make images, understand natural language, and more." (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

"ML is a useful - and under-utilized - framework for studying LLMs. For one thing, LLMs are literally composed of simple ML algorithms (linear weighted averages and nonlinear transformations). Furthermore, using ML techniques like regression, classification, and clustering, can help reveal how concepts like grammar rules are represented inside LLMs. And finally, many people find LLMs to be intimidatingly complicated while finding ML to be much more approachable. Thus, using ML to study LLMs involves using simple tools to understand complicated tools." (Mike X Cohen,"50 ML Projects To Understand LLMs", 2026)

16 November 2026

🤖Prompt Engineering: Complexity (Just the Quotes)

"Chain-of-thought prompting is a method that forces LLMs to reason through a series of steps, resulting in more structured, transparent, and precise outputs. The goal is to break down complex tasks into smaller, interconnected subtasks, allowing the LLM to address each subtask in a stepby-step manner. This not only helps the model to 'focus' on specific aspects of the problem, but also encourages it to generate intermediate outputs, making it easier to identify and debug potential issues along the way. Another significant advantage of chain-of-thought prompting is the improved interpretability and transparency of the LLM-generated response. By offering insights into the model’s reasoning process, we, as users, can better understand and qualify how the final output was derived, which promotes trust in the model’s decision-making abilities." (Sinan Ozdemir, "Quick Start Guide to Large Language Models", 2024)

"Large language models (LLMs) are AI models that are usually (but not necessarily) derived from the Transformer architecture and are designed to understand and generate human language, code, and much more. These models are trained on vast amounts of text data, allowing them to capture the complexities and nuances of human language. LLMs can perform a wide range of language-related tasks, from simple text classification to text generation, with high accuracy, fluency, and style." (Sinan Ozdemir, "Quick Start Guide to Large Language Models: Strategies and Best Practices for Using ChatGPT and Other LLMs", 2024) 

"Underfitting in machine learning is a condition in which a model is too simple to capture the underlying patterns in the training data, leading to poor performance on both the training and test data. It typically occurs when the model lacks sufficient complexity or when it is not trained for long enough. In the context of LLMs, underfitting could happen if the model fails to grasp the context or subtleties of the training data, resulting in outputs that are too general, off-topic, or nonsensical in response to prompts." (Sinan Ozdemir, "Quick Start Guide to Large Language Models: Strategies and Best Practices for Using ChatGPT and Other LLMs", 2024)

"A knowledge graph is a data structure that uses nodes to represent concepts and entities and relationships to connect these nodes. [...] Knowledge graphs are highly versatile, capable of storing both structured information (such as employee details, task statuses, and company hierarchies) and unstructured information (such as article contents). This dual capability [...] makes them uniquely suited for complex RAG applications. [...] By integrating structured and unstructured information in the same framework, knowledge graphs enable the seamless blending of both worlds, making them a powerful tool for answering a broad range of questions efficiently and accurately in RAG applications. Moreover, explicit connec-tions between unstructured and structured data unlock advanced retrieval strategies such as linking entities in text to graph nodes or contextualizing structured results with source passages that would be difficult or impossible to achieve using either type of data alone."(Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"Agentic intelligence feels incredibly powerful in demos but breaks in production. Indeed, it is very fragile without solid infrastructure. Every day, I personally see tons of clever orchestrations around dumb prompt chains tied up in a brittle, underused LLMOps infrastructure. But building this infrastructure means acknowledging the costs: performance overhead, strict interface contracts, and state complexity, as well as a need for more LLMOps engineers to create the best practices, tooling, and frameworks to run these systems reliably, safely, and robustly." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"Agentic workflows break when the logic is messy - if, say, the plans don’t decompose or memory is poorly structured. However, infrastructure-level LLM applications introduce even more failure points and complexity. If the protocols don’t sync with each other, or the data flows start leaking, or the model boundaries are unclear... there are far too many failure points to count. While most people have been jumping on the bandwagon to adopt MCPs or A2A, very few are equipped to handle the LLMOps issues these tools introduce." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"An embedding is a way to represent complex data as a set of numbers in a simpler, lower-dimensional space. Think of it as translating data into a format that a computer can easily understand and work with. Embedding models provide a uniform way to represent different types of data. Input to an embedding model can be any complex data, and the output is a vector. For instance, in dealing with text, an embedding model will take words or sentences and turn them into vectors, which are lists of numbers. The model is trained to ensure that these number lists capture essential aspects of the original words, such as their meaning or context." (Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"Another problem that can be confusing is that LLMs seldom put out the same thing twice. [...] Traditional databases are straightforward - you ask for something specific, and you get back exactly what was stored. Search engines work similarly, finding existing information. LLMs work differently. They analyze massive amounts of text data to understand statistical patterns in language. The model processes information through multiple layers, each capturing different aspects - from simple word patterns to complex relationships between ideas." (Jeremy C Morgan, "Coding with AI: Examples in Python", 2025)

"In prompt engineering, we customize the prompts or questions we give the model to get more accurate or insightful responses. The way a prompt is structured has a massive impact on how well a model understands the task at hand and, ultimately, how well it performs. Given LLMs’ versatility, prompt engineering has become an important skill for getting the most out of these models across different domains and tasks. The key is to understand how different prompt structures lead to different model behaviors. There are various strategies - ranging from simple one-shot prompting to more complex techniques like chain-of-thought prompting - that can significantly improve the effectiveness of LLMs." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"LLMs are rapidly improving, not only in their ability to understand and generate language but also in how effectively they can use external tools for data retrieval, transformation, and manipulation. As these models become more capable, they will be able to perform increasingly complex tasks with minimal prompting. However, their effectiveness still depends on the quality, design, and integration of the tools you provide. It’s your job to implement those tools thoughtfully and efficiently, ensuring they are well suited to your system’s goals and constraints." (Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"LLMs are trained on large volumes of data, which inherently provides them with an immense knowledge base and understanding of different languages. Yet, LLMs at their core are complex text completion engines. Since this knowledge and understanding of language is compressed in a very high-dimensional latent space. LLMs end up using these in a very fluid and intelligible way (which often leads to hallucinations). In order to guide LLMs to focus on specific topics or pieces of information to solve certain tasks, (for instance, question-answering from a given piece of text), it is important to provide contextual information explicitly. While most current generations of LLMs have extremely wide context windows, it is recommended to preprocess context into overlapping smaller chunks for better results, reduced latency, and so on. For similar reasons, it is also recommended to preprocess contextual information in clear and task-specific formats. This aspect of context preprocessing is extremely useful in Retrieval-Gugmented Generation (RAG) scenarios." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"LLM deployment failures often trace back not to the model itself, but to the prompts it receives. In production environments, prompts are rarely fixed, handcrafted snippets. Instead, they are dynamically generated, assembled from templates, and parameterized based on upstream data sources or evolving user state. This dynamism introduces complexity and variability that can subtly undermine the system’s performance if not carefully managed." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"Recursive prompting is a systematic approach to achieving higher-quality outputs through iterative refinement. Rather than accepting the first response, it uses a step-by-step process of evaluation and improvement, making it particularly valuable for complex tasks such as code development, writing, and problem-solving. Our example demonstrated how a basic factorial function evolved from a simple implementation to a robust, optimized solution through multiple iterations of targeted refinements." (Jeremy C Morgan, "Coding with AI: Examples in Python", 2025)

"Semantic Kernel is a framework designed to simplify integrating LLMs into applications that require dynamic knowledge, reasoning, and state tracking. It’s particularly useful when you want to build complex, modular AI systems that can interact with external APIs, knowledge bases, or decision-making processes. Semantic Kernel focuses on building more flexible AI systems that can handle a variety of tasks beyond just generating text. It allows for modularity, enabling developers to easily combine different components - such as embeddings, prompt templates, and custom functions - in a cohesive manner." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"The art of mega-prompts spanning multiple written pages and looking like essays has become commonplace for complex tasks when building applications to get things `just right'. Unfortunately, they bring with them lots of issues: errors, portability, complexity, and more. The GenAI world didn’t plan for mega-prompts. They have simply evolved into what they’ve become today because practitioners kept wanting to do more and more complex things, and their only way to express those intents was with a prompt. But step back and look at some of these prompts [...] Lurking just below the surface are a bunch of classical computing concepts like data, programming instructions, control flows, memory, and stora - all the components typically associated with classical computing elements." (Rob Thomas et al, "AI Value Creators: Beyond the Generative AI User Mindset", 2025)

"Transformers are complex models built like LEGO blocks using multiple smart and specialized components. [...] Briefly, a vanilla transformer model consists of separate stacks of encoders and decoders. Each encoder block includes multi-head self-attention, enabling the model to capture relationships between tokens regardless of their positions. Residual connections help maintain gradient flow, preventing the vanishing gradient problem. Layer normalization ensures training stability, and feed-forward layers introduce non-linearity and learn complex token interactions. Decoder blocks contain the same components but also include an encoder-decoder attention mechanism to incorporate context from the encoder. The model uses embedding layers to convert tokens into a continuous latent space for contextual learning and positional encoding to preserve the order of tokens in the sequence." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"When there are hidden layers between the input and output, the problem becomes more complex: when do we change the internal weights to compute the activations that feed into the final output? How do we modify them in relation to the input weights? The insight of the backpropagation technique is that we can use the chain rule from calculus to efficiently compute the derivatives of each parameter of a network with respect to a loss function and, combined with a learning rule, this provides a scalable way to train multilayer networks." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"A solid data foundation is critical for AI success. The foundation can grow in phases, but it needs to be there. AI will add pressure to the data foundation. Modern workloads require data that is connected, interpretable, high quality, and governed. Modern workloads utilize diverse data, and this is especially true with the popularity of GenAI. Trustworthy AI depends on knowing where the data came from and how it has changed. Modern architectures including the lakehouse and the data fabric exist because the traditional ways of managing data no longer fit the scale or complexity of what organizations need to do today. In other words, there is no path toward enterprise AI without a strong data foundation. This was echoed in the expert advices. Experts spoke about the dangers of 'vanity projects', particularly with GenAI, when foundational data issues were ignored. Others described how their companies moved faster specifically because they had already invested in governance, semantic layers, lineage, and observability." (Fern Halper, "Data Makes the World Go 'Round", 2026)

"[...] a transformer is a neural network that uses attention to understand and generate sequences of data efficiently and flexibly, allowing it to capture complex relationships across long inputs. Unlike older models, transformers process all parts of the input in parallel, making them much faster and more scalable than older types of neural networks." (Chris Minnick, "A Developer’s Guide to Integrating Generative AI into Applications", 2026)

"Intelligent systems connect users to AI and ML to achieve meaningful objectives. An intelligent system is one in which intelligence evolves and improves over time, particularly when it improves by watching how users interact with the system.[...] The primary objective of the intelligent system is to support users in accomplishing complex tasks - not by replacing them, but by enhancing their decision-making capabilities. [...] An intelligent system must also have the ability to learn from user interactions and explicit feedback, as well as utilize contextual information. The system should contin-uously develop, use, and maintain an evolving knowledge base. This evolution is driven not only by data sources but also by ongoing interactions with users." (Alessandro Negro et al, "Knowledge Graphs and LLMs in Action", 2026)

"LangGraph handles the perception, reasoning, and action flow while maintaining memory and context across tasks. In this sense, it functions as both the development environment and the orchestration layer - coordinating the steps of perception, reasoning, and action while managing connections to external systems. Underneath this, emerging standards like MCP ensure that agents can connect securely and consistently to tools and data sources, making agentic architectures portable and scalable across platforms. Taken together, the orchestration layer and emerging interoperability standards like MCP form the foundation for scalable agentic AI. They make it possible for agents to perceive, reason, act, and learn in coordinated ways across complex environments, translating autonomous intelligence into practical, enterprise-grade capability." (Fern Halper, "Data Makes the World Go 'Round", 2026)

"Prompt engineering may meet your accuracy requirements, but the prompts end up being extremely long as you encounter more and more corner cases. It’s not unusual for such prompts to amount to two or three pages of detailed instructions. The complex system instructions required to achieve that level of accuracy incur a large token count, and that makes the application too expensive to scale. [...] As your prompts become more detailed, maintenance overhead increases because the overall system is extremely sensitive to the specific wording of prompts. You’ll need to do integration testing every time the foundational model changes, and often even when one of your tools changes." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"Traditional paradigms build systems for specific purposes with structured, homogeneous databases. This approach works for tailored needs but is impractical for complex domains that need to adapt to user characteristics and integrate heterogeneous data. KGs capture connections, enabling relationship discovery through graph pattern matching and traversal. Both the Resource Description Framework (RDF) and Labeled Property Graphs (LPGs) provide machine-readable formats that humans can interpret. KGs emphasize rich, meaningful data representations usable by both humans and machines, enabling a paradigm shift where intelligent behavior is encoded in a unique source of truth." (Alessandro Negro et al, "Knowledge Graphs and LLMs in Action", 2026)

15 November 2026

🤖Prompt Engineering: Meaning (Just the Quotes)

"An embedding is a way to represent complex data as a set of numbers in a simpler, lower-dimensional space. Think of it as translating data into a format that a computer can easily understand and work with. Embedding models provide a uniform way to represent different types of data. Input to an embedding model can be any complex data, and the output is a vector. For instance, in dealing with text, an embedding model will take words or sentences and turn them into vectors, which are lists of numbers. The model is trained to ensure that these number lists capture essential aspects of the original words, such as their meaning or context." (Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"Context is crucial for how language models understand and generate code. The model processes your input by analyzing relationships between different parts of the code and documentation to determine meaning and intent. [...] The model evaluates context by calculating mathematical relationships between elements in your input. However, it may miss important domain knowledge, coding standards, or architectural patterns that experienced developers understand implicitly." (Jeremy C Morgan, "Coding with AI: Examples in Python", 2025)

"Vector databases are designed to store and index highdimensional embeddings - dense numeric vectors that capture the semantic meaning of text, images, audio, or other content. Instead of looking for exact matches, they use approximate nearest neighbor (ANN) algorithms to return the items whose vectors lie closest to a query vector in that multidimensional space. This makes them the engine behind semantic search, recommendation systems, image-or-audio similarity matching, and retrieval augmented generation (RAG) pipelines that supply LLM prompts with relevant context in milliseconds." (Abi Aryan, "LLMOps: Managing Large Language Models in Production", 2025)

"Drift is the phenomenon in which an AI model becomes less accurate over time because of changes in the statistical properties of data in the real world versus the data the model was trained on. For example, a model trained on customer data with a specific age distribution might encounter a different age distribution in the future. This is known as data drift. AI models can also suffer from concept drift, in which the meaning of a term changes over time. Ongoing evaluations are essential for detecting drift, and both human and automated reviews can be used. Hybrid evaluation strategies encourage combining human judgment on output quality (tone, sensitivity, misinterpretations) with automated checks for syntactic correctness and speed." (Chris Minnick, "A Developer’s Guide to Integrating Generative AI into Applications", 2026)

"Embeddings are mathematical representations of text, images, or other input types. They capture semantic meaning by mapping words, phrases, or documents to vectors in a high-dimensional space. LLMs have become exceptionally proficient at creating semantically representative embeddings because this capability forms the foundation for LLM generation. [...] While the latest LLMs provide massive context windows, encoding entire documents in a single embedding vector is often not advisable. You’ll lose the nuances of the different parts of a text, lose critical information, and hinder the RAG system from retrieving relevant information. Plus, it gets very expensive to use large context windows at scale. It’s preferable to chunk documents into information-dense and self-consistent chunks of text." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"Foundational models can manipulate symbols and words effectively, but this may be because they are generalizing from the manipulation they have encountered in the training data, not because they grasp semantic meanings and the logical relationships between them in the way humans do. While you can use foundational models to perform many tasks, that’s because those tasks are similar to the tasks that the foundational model was trained to do." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"Sentence embeddings are dense vector representations of entire sentences or phrases, capturing their semantic meaning in a fixed-dimensional space. Unlike word embeddings, which represent individual words, sentence embeddings are designed to encode the meaning of longer text sequences. Two prominent techniques for generating sentence embeddings are SBERT(sentence-BERT) and dense retriever. [...] SBERT is a modification of the BERT architecture specifically designed for generating sentence embeddings. Traditional BERT outputs contextualized word embeddings, but SBERT fine-tunes BERT to produce fixed-size sentence embeddings by applying a pooling operation (e.g., mean pooling, max pooling, or CLS token pooling) over the token embeddings." (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

"Some word meanings are stable, while others tend to move over time. [...] As meaning changes, so do the vector representations of these words in the embedding space. Depending on which dataset was used to train the embedding model, vector representations can fluctuate as cultures evolve-providing an interesting way to measure the impact of cultural changes over the years. [...] Contextual meaning of words forms another layer of dynamics in embedding models. Some words may not occupy a single point in space but may vary depending on how they are used. [...] The embedding space and semantic laws of language can teach us much. They help explain how language can be stable enough for reliable communication and yet flexible enough for creativity, allowing adaptation as cultures change. Just as physical laws govern how objects move through space, the semantic laws of language govern word meaning and use, allowing words to shift and evolve while maintaining a connection to context." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The foundational form of RAG, often called naive RAG, follows a straightforward pattern. A pipeline retrieves supporting context from external sources such as enterprise documents, knowledge bases, or structured datasets and appends that information to the model’s prompt before inference. In the most common implementation, each document is converted into an embedding, a numerical representation of its semantic meaning, using either the same foundation model or a specialized embedding model. When a user submits a query, the system performs a vector similarity search to find documents whose embeddings most closely match the query’s vector representation, and the retrieved content is concatenated with the user query before being passed to the language model." (Bennie Haelen, "ML and Generative AI in the Data Lakehouse Building and Deploying AI Applications at Scale", 2026)

"The transformer was revolutionary in many ways. At its heart is a powerful mechanism called self-attention, which allows it to understand the context and meaning of not just individual words but entire sequences of words. By learning the context of words for an input of almost any size, a transformer understands the actual meaning of what it reads, and it can also generate new outputs that are rich in meaning, creative, and useful." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

14 November 2026

🖍️Robert Barton - Collected Quotes

"A high learning rate lets the model adjust quickly but risks overshooting the optimal values and getting stuck in a cycle of jumping around without minimizing the error function. A low learning rate will give you better precision but could slow down training and increase computational cost, or it could get the model stuck in a local minimum, where it essentially loses sight of the big picture of what it is trying to accomplish. Choosing the right learning rate is something of a trade-off. It may take many adjustments to find the optimal learning rate if doing so by hand, but the job can also be made easier by optimization algorithms, which try to guess the optimal learning rate. Such methods include Bayesian optimizations and Grid Search, among others." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"All machine learning techniques share the same basic idea: A computer program learns and improves by observing or measuring data. This learning is then used to make predictions when new data is presented to the program. The process involves three key elements that work together: a model, a form of learning (training) that is applied to the model, and actions on the model once it is trained (inference). The type, or family, of AI or machine learning that you are working with depends on the goal of this process. This taxonomy can be a bit complex because technical breakthroughs are sometimes remembered as their own family categories, even though they are simply more efficient ways of achieving some well-known goals. However, the most common way to organize the machine learning families is to distinguish between supervised learning, unsupervised learning, and reinforcement learning techniques." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Clean data is the cornerstone of any successful deep learning project. Noisy or dirty data, which may contain errors, inconsistencies, or irrelevant information, can mislead the model during training, causing it to learn incorrect patterns or fail to converge altogether. A model that does not converge shows poor performance and is unusable. A model that learns incorrect patterns produces erroneous outputs, leading to poor decisions that can be costly in terms of time, money, and resources. Ensuring data quality involves addressing several key issues. First, clean data must be as close as possible to error free. [...] Second, consistent formatting is critical.[...] Finally, handling outliers is an essential step" (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026) 

"Each input element to a neural network [...] is called a feature. The neural network has an equal number of input layer neurons and features. The input layer does not perform any computation but rather sends each feature into the first hidden layer, which operates as the first computational layer. Some features may be more important than others, so each feature is affected by a weight as it is processed by the computational layer. One of the main goals of the training phase is to dynamically determine the right weight for each feature. The weight itself is not a feature; it is a parameter. Features relate to the data, and parameters relate to how the neural network model treats the data." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"If AI as a whole mirrors the human thought process, then reinforcement learning represents its most direct connection to human psychology. RL captures one of our most fundamental learning mechanisms: the ability to learn through experience, guided by rewards and penalties. This is not just a superficial parallel. RL’s core ideas were in fact directly inspired by the study of psychology, and many of the most powerful RL algorithms are remarkably aligned with the psychology of human decision-making." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Monte Carlo methods are designed to solve optimization problems that are modeled as MDPs. However, unlike Bellman-style methods, which require a complete model of the environment up front (that is, well-defined transition probabilities and rewards), Monte Carlo methods are model free, meaning the agent learns the transition probabilities as it explores the environment through each episode. [...] In cases where episodes are very long and produce only sparse data, Monte Carlo methods simply don’t get enough meaningful data to train well. [...] Monte Carlo methods work well in modeling systems that are defined by episodes that are reasonably stable and frequent enough to provide useful data. However, if long episodes and sparse rewards are involved, Monte Carlo struggles to build an optimal policy." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"In deep learning, the quality of the data often works in tandem with the quality of the model. Even the most sophisticated neural network architectures cannot perform well without properly prepared data. Data preparation involves cleaning, organizing, normalizing, and sometimes augmenting the raw data to ensure that it is suitable for training a model. This process is one of the most crucial steps in the machine learning pipeline because it directly impacts the model’s ability to learn meaningful patterns and generalize to new, unseen data." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"In the context of reinforcement learning, Monte Carlo methods are a class of algorithms that evaluate or improve a policy by sampling the output of complete episodes of interaction with the environment. During each episode, actions are taken based on the agent’s current policy, often including random actions to encourage exploration, and then the total return (the sum of the rewards) is recorded. Over many episodes, the algorithm averages these returns and is able to estimate an improved policy. The policy is only updated at the end of an episode, once it completes, and not incrementally during the episode itself." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026) 

"One of the main reasons today’s generative models appear sophisticated is that they build on foundational concepts of neural computation, including layers of artificial neurons, activation functions, weight adjustment through backpropagation, and careful tuning of hyperparameters. These mechanisms free the models from the limitations of linear relationships between input and output. [...] Moreover, deep learning is not just about model architecture; it is also about how these models learn. Training a neural network is a delicate process that is both art and engineering. It involves managing noisy data, fine-tuning hyperparameters, preventing overfitting, and navigating delicate trade-offs between model complexity and generalization. In generative AI in particular, the model’s behavior is only as good as the training dynamics the model underwent. Imperfect training leads a model to hallucinate, collapse into mode repetition, or generate biased and unhelpful outputs." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"[...] RNNs [...] process tokens sequentially, one at a time, and are known to suffer from the long-range dependency problem. This “forgetfulness” problem is common in RNNs, where information from earlier parts of the input gradually fades, meaning the model quickly forgets the context of the sentence, making it hard for the decoder to produce meaningful output over longer sequences. It’s sort of like short-term amnesia that results in a loss of coherence as tokens pass by." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Some word meanings are stable, while others tend to move over time. [...] As meaning changes, so do the vector representations of these words in the embedding space. Depending on which dataset was used to train the embedding model, vector representations can fluctuate as cultures evolve-providing an interesting way to measure the impact of cultural changes over the years. [...] Contextual meaning of words forms another layer of dynamics in embedding models. Some words may not occupy a single point in space but may vary depending on how they are used. [...] The embedding space and semantic laws of language can teach us much. They help explain how language can be stable enough for reliable communication and yet flexible enough for creativity, allowing adaptation as cultures change. Just as physical laws govern how objects move through space, the semantic laws of language govern word meaning and use, allowing words to shift and evolve while maintaining a connection to context." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Supervised learning is broken down into two classes of algorithms: regression and classification. Regression focuses on predicting a continuous value, such as the price of a stock or a house (and takes its name from a common statistical technique used in this context). The learning process is similar to how humans learn: by observation. [...] Classification, on the other hand, is about determining whether a given input belongs to one category or another. The outcome can be binary (for example, yes or no) or drawn from a larger set of predefined classes." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Temporal difference learning is based on a simple but powerful idea:. Instead of waiting until the end of an episode to update its knowledge, it updates its estimates continually—every time the agent takes an action it records the current state and the action it took, and observes how the state changed and what reward was given. As it observes, it makes small adjustments to its guesses about how valuable the current state is." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The depth of an ANN is also why the hidden layers are called 'hidden'. The term does not mean that we seek to hide them from view but simply that we do not consider their individual output directly. The system takes data into a visible input layer and produces a result in the output layer. There may be many layers in between that contribute to that result, but unless you were studying the particular structure of the neural network, you would not examine the results the individual layers produce. Your system would merely use the result as an input into the next layer." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The first big innovation in the transformer architecture is its ability to process tokens in parallel rather than sequentially, one at a time. This was a huge breakthrough, as it allowed faster training and effectively overcame the long-range dependency problem. Rather than reading one sentence at a time as humans do, a transformer reads a whole input sequence at once - spanning hundreds of thousands of words in some cases. To be clear, there are still limitations to how much a transformer can read in parallel, known as the context window, but generally this window is very large. The ability to examine words in parallel allows the transformer to understand how words relate to each other, even if they are far apart in the same sentence, paragraph, or even whole book." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The name of the SVM technique comes from the way it considers the data points. When looking at two groups of points (and searching for their boundary), there are points in one group that are far away from the other group. From the perspective of defining the hyperplane between the groups, these points are not very interesting. The points that are more interesting are the ones closest to the other group. An SVM builds vectors (called support vectors) from these edge points toward the other group. The process involves balancing the size (magnitude) of these vectors on both sides to find a line right in the middle (thus maximizing the space, or margin, to each group), between the two groups, using a mathematical approach called Lagrange multipliers." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The process of deciding which features to include and which ones to ignore is known as feature engineering. It is a critical step in supervised learning. More features can make the model more powerful and accurate, but they also make it more complex, harder to interpret, and slower to train. As in many other parts of AI, deciding the number of features for a particular problem is often a balancing act." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"The transformer was revolutionary in many ways. At its heart is a powerful mechanism called self-attention, which allows it to understand the context and meaning of not just individual words but entire sequences of words. By learning the context of words for an input of almost any size, a transformer understands the actual meaning of what it reads, and it can also generate new outputs that are rich in meaning, creative, and useful." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Training involves feeding a large set of data (called the training set) into the model. [...] This learning phase is somewhat like a brute-force process, where the program tries a large set of numbers until it finds the “least bad” values for the parameters to model the data. We use the expression least bad because in most cases, the training phase does not find perfect numbers." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"Unlike symbolic reasoning, which relies on sets of handcrafted logic rules, machine learning involves training a computer by giving it data; the computer improves automatically as it sees more examples. With machine learning, a computer learns to identify patterns by observing data, allowing it to create rules by itself. As it processes more data, its performance continually improves - often dramatically. With enough data, a model trained this way can accomplish tasks that expert systems could never approach." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"What makes neural networks so powerful is their ability to model not only linear relationships but also complex, nonlinear relationships in data. They can learn from examples in ways that are often impossible for traditional algorithms. Instead of relying on hard-coded rules or shallow statistical approximations, neural networks adjust internal parameters through repeated exposure to data, which allows them to learn patterns, capture nuance, and, ultimately, generate entirely new content. This is the core mechanism behind many generative AI solutions." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

"When training an AI model, you may achieve a higher accuracy rate, but the importance of that accuracy depends on the consequences of being wrong. If the model occasionally issues an alert when none is needed (a false positive), the result may be mild annoyance for the driver. Perhaps they slow down unnecessarily or dismiss the warning. But if the model fails to issue an alert when a real hazard is present (a false negative), the consequences could be severe and result in a collision with another vehicle or an obstacle. This issue highlights a core principle in AI: Acceptable accuracy depends on the cost of mistakes." (Robert Barton & Jerome Henry, "Demystifying Generative AI A Practical and Intuitive Introduction", 2026)

🤖Prompt Engineering: Efficiency (Just the Quotes)

"A knowledge graph is a data structure that uses nodes to represent concepts and entities and relationships to connect these nodes. [...] Knowledge graphs are highly versatile, capable of storing both structured information (such as employee details, task statuses, and company hierarchies) and unstructured information (such as article contents). This dual capability [...] makes them uniquely suited for complex RAG applications. [...] By integrating structured and unstructured information in the same framework, knowledge graphs enable the seamless blending of both worlds, making them a powerful tool for answering a broad range of questions efficiently and accurately in RAG applications. Moreover, explicit connec-tions between unstructured and structured data unlock advanced retrieval strategies such as linking entities in text to graph nodes or contextualizing structured results with source passages that would be difficult or impossible to achieve using either type of data alone."(Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"As with many other deep learning-based approaches, another major challenge is in interpretability. While knowledge graphs provide a structured and transparent way to store relationships, LLMs operate as a black box, making it difficult to understand how specific outputs are generated. [...] Data alignment is also a key issue, as structured knowledge graphs and unstructured text data must be carefully preprocessed to ensure consistency.  Differences in data formats, ontology mismatches, and information redundancy can create inefficiencies when integrating these two paradigms. Developing robust pipelines that seamlessly connect graph-based insights with LLM-generated text remains an open challenge." (Aldo Marzullo et al, "Graph Machine Learning" 2nd Ed., 2025)

"[...] LLMs are pre-trained on large corpora and sometimes fine-tuned on smaller datasets for specific tasks. Recall that one of the factors behind the Transformer’s effectiveness as a language model is that it is highly parallelizable, allowing for faster training and efficient processing of text. What really sets the Transformer apart from other deep learning architectures is its ability to capture long-range dependencies and relationships between tokens using attention. In other words, attention is a crucial component of Transformer-based LLMs, and it enables them to effectively retain information between training loops and tasks (i.e., transfer learning), while being able to process lengthy swatches of text with ease." (Sinan Ozdemir, "Quick Start Guide to Large Language Models: Strategies and Best Practices for Using ChatGPT and Other LLMs", 2024) 

"LLMs are rapidly improving, not only in their ability to understand and generate language but also in how effectively they can use external tools for data retrieval, transformation, and manipulation. As these models become more capable, they will be able to perform increasingly complex tasks with minimal prompting. However, their effectiveness still depends on the quality, design, and integration of the tools you provide. It’s your job to implement those tools thoughtfully and efficiently, ensuring they are well suited to your system’s goals and constraints." (Tomaz Bratanic & Oskar Hane,"Essential GraphRAG: Knowledge Graph-Enhanced RAG", 2025)

"The pre-training step is by far the biggest in terms of data and compute requirements for the whole of the LLM’s lifecycle. Yet fine-tuning is quite resource-intensive when we compare it to traditional machine learning and deep learning workflows. Fine-tuning is also a very important step in improving the quality of the models; hence, it makes sense to understand how we can optimize this step without impacting the performance. Efficiencies in this step also enable us to iterate faster, thereby improving adaptability in many fast-moving domains. In this section, we will focus on some interesting efficient method." (Joseph Babcock & Raghav Bali, "Generative AI with Python and PyTorch" 2nd. Ed., 2025)

"A major aspect of the alignment problem is values misalignment: AI systems may lack sufficient understanding of human ethics, cultural norms, or social contexts, making it difficult to translate our values directly into algorithms. For instance, if an AI is programmed to prioritise efficiency without balancing safety or ethical considerations, it might make decisions that, while effective, disregard human welfare. This is further complicated by 'specification gaming', where an AI might exploit loopholes in its programming to achieve objectives in unintended or counterproductive ways. An AI instructed to avoid obstacles, for instance, could redefine what counts as an 'obstacle' and take routes that, while technically following the rule, lead to negative outcomes." (Alan Watkins & G C Cooke, "Smarter than You Winning in Business with Superintelligent AI", 2026)

"A RAG system needs to identify relevant text chunks from the knowledge base. It does that by building a datastore of chunks and organizing the chunks in a way that makes searching for chunks that are relevant to a query efficient and fast. This preparatory step of building an efficient data store is called indexing, and the runtime step of searching the datastore for relevant chunks is called retrieval. [...] Whenever a query is received, a question-answering pipeline is invoked This consists of two steps: retrieval and generation. In the retrieval step, the retriever finds chunks in the document store that are the most relevant to the query. In the generation step, these relevant chunks are added to the context of the prompt and used along with the user query to generate the answer. In this way, the generated answer is grounded in the relevant information from trusted knowledge sources. The response consists of the generated text as well as the relevant chunks that were used to generate the answer." (Valliappa Lakshmanan & Hannes Hapke, "Generative AI Design Patterns: Solutions to Common Challenges When Building GenAI Agents and Applications", 2026)

"KGs are sophisticated graph structures that represent real-world entities (people, places, diseases, proteins), define meaningful connections between them, and provide context. KGs provide structured, explainable knowledge representation but are challenging to build and query; LLMs offer natural language processing capabilities but suffer from hallucinations, stale information, and a lack of domain-specific grounding. Together, they are a 'killer combination': LLMs can extract entities and relationships from unstructured text to build KGs more efficiently, providing more autonomous and powerful graph querying and analysis. Meanwhile, KGs provide reliable, up-to-date domain knowledge to ground LLM responses and prevent hallucinations." (Alessandro Negro et al, "Knowledge Graphs and LLMs in Action", 2026)

"One of the most important aspects of designing with GenAI is determining when to let the machine act and when to keep a human in the loop. As LLMs and AI agents become increasingly capable of not just generating text but also performing actions (like calling APIs, filling out forms, and triggering workflows), designers and developers face a growing responsibility: deciding what should be automated, not just what can be. Although automation promises speed, efficiency, and scalability, over-automation can lead to unintended consequences and critical errors. This is especially true when actions taken by the AI affect financial, legal, or personal data. The goal of human-centered design isn’t to block AI progress. Instead, it should channel AI in ways that empower users while keeping them informed and in control." (Chris Minnick, "A Developer’s Guide to Integrating Generative AI into Applications", 2026)

"The self-attention mechanism is the cornerstone of transformer models, enabling them to process sequential data like text more effectively than traditional recurrent neural networks (RNNs) or convolutional neural networks (CNNs). Unlike RNNs, which process sequences step-by-step, self-attention allows the model to consider the entire input sequence simultaneously. This parallel processing capability makes transformers highly efficient and scalable. transformers highly efficient and scalable. At its core, self-attention computes relationships between all words in a sentence, assigning higher weights to words that are more relevant to each other" (Saloni Garg et al, "RAG Artificial Intelligence: Retrieval-Augmented Generation in Generative AI", 2026)

Related Posts Plugin for WordPress, Blogger...

About Me

My photo
Koeln, NRW, Germany
IT Professional with more than 25 years experience in IT in the area of full life-cycle of Web/Desktop/Database Applications Development, Software Engineering, Consultancy, Data Management, Data Quality, Data Migrations, Reporting, ERP implementations & support, Team/Project/IT Management, etc.