DEV Community: Summiya ali

Fighting the Fog: A Guide to Focused Productivity While Fatigued

Summiya ali — Tue, 12 May 2026 13:17:52 +0000

This article provides a framework for students and professionals who struggle with low energy and daytime sleepiness. You will learn how to structure your day using energy-based scheduling and specific cognitive tools to maintain momentum when your brain feels slow.

What This Article Covers

Techniques to bypass the "brain fog" that leads to random distractions.
A hierarchy for goal setting (Primary, Secondary, and Maintenance).
Strategic use of the Pomodoro technique and Brain Dumps.
A case study implementation for a multi-tasking graduate.

What This Article Does Not Cover

Medical advice for chronic sleep disorders or insomnia.
Deep-dive tutorials on specific project management software.

Prerequisites

A dedicated "Brain Dump" notebook or digital page.
A basic timer (phone or browser-based).
A list of your current active projects or subjects.

1. Use the Pomodoro Technique

When you are sleepy, a four-hour block of study looks impossible. Your brain will naturally seek "micro-escapes" like checking WhatsApp.

The Fix: Set a timer for 25 minutes of work, followed by a 5-minute break.

During the 25 minutes: Focus only on the task.
During the 5 minutes: Stand up and move. Physical movement is the best "wake-up" call for a sleepy brain.

2. Categorize Your Goals

Stop treating all tasks as equally important. Divide your workload into three buckets:

Primary: High-stakes tasks that require deep logic .
Secondary: Important but less taxing (e.g., Job applications, Research).
Maintenance: "Admin" tasks that require little thought (e.g., Calling for errands, checking deadlines, organizing lists).

3. Set Up Three Focus Sessions

Instead of a marathon, use three distinct sprints based on your energy levels:

Deep Study Session: For your Primary task. Do this when you are most awake.
To-Do Session: For Secondary tasks. Do this when you have moderate energy.
Maintenance Session: For Maintenance tasks. Do this specifically when you feel the most sleepy.

Pro Tip: Do not waste high-energy hours on maintenance tasks like "sorting files" or "checking messages."

4. Block Your Distractions

Sleepiness makes you crave "low-effort" dopamine, leading to random searches or texting.

The Rule: If you are in a Deep Study session, your phone stays in another room.
The "Later" List: If you feel the urge to search for something unrelated, write it down in your Brain Dump notebook and ignore it until your Maintenance session.

5. The One Daily Priority Rule

Every morning, ask yourself: "If I complete ONLY ONE meaningful thing today, what should it be?"
Write this down. You are not allowed to feel guilty about the day as long as this one task is finished.

6. The Brain Dump Notebook

Whenever a random thought appears ("I need to call someone," "I wonder if xyz website updated the portal"), dump it into the notebook immediately. This clears your "mental RAM," allowing you to return to the task at hand without the fear of forgetting.

7. Case Study: The Juggling Graduate

The Profile

Current State: Preparing for exam, Government jobs , and private job hunting.
The Problem: High energy at 5 AM, but a massive slump between 11 AM and 6 PM. Sleepy during studies and exam prep.

The Implementation Strategy

Time Block	Energy Level	Recommended Task Type	Specific Action
05:00 - 07:00	High	Primary (Deep)	This is your exam prep time. Your brain is fresh; do the hardest reading now.
11:00 - 13:00	Slumping	Maintenance (Admin)	This is when you "sort small things." Call for errands, check deadlines, and list tasks. Do not do this at 5 AM!
14:30 - 17:00	Very Low	Active Maintenance	Instead of fighting while sleepy, do your job search. These involve clicking and reading, which is easier than solving math.
18:00 - 20:00	Rising	Primary (Practice)	Use this burst of energy for deep study or government job prep

Conclusion

Sleepiness is often a signal that your brain is overwhelmed by the number of choices, not just the workload. By assigning specific tasks to specific energy "buckets"—and using a Brain Dump to catch distractions—you can maintain progress even on your tiredest days. Pick one priority for tomorrow and start there.

Building a Scalable RAG Pipeline on Google Cloud Using Vertex AI and Cloud Run

Summiya ali — Mon, 16 Mar 2026 07:13:26 +0000

Organizations generate large volumes of unstructured information, including technical documentation, knowledge-base articles, manuals, policies, and internal procedures. Although cloud storage makes these documents easy to store, finding relevant information across large document collections can be difficult.

Traditional keyword-based search works best when users know the exact terms a document uses. It becomes less effective when a user's query uses different wording than the source material.

Retrieval-Augmented Generation (RAG) addresses this limitation by combining semantic document retrieval with generative AI. Instead of relying solely on a language model's training data, a RAG system retrieves relevant documents and provides them as context for response generation.

Google Cloud offers services such as Cloud Storage, Vertex AI, Cloud Run, and vector-search infrastructure that developers can combine to build scalable RAG applications.

This article provides a high-level overview of how to design a RAG architecture on Google Cloud, from document ingestion and embedding generation to retrieval, response generation, security, and monitoring.

1. Understanding Retrieval-Augmented Generation

1.1 Limitations of Traditional Language Models

Developers train large language models (LLMs) on large datasets, which lets the models generate natural-language responses. However, these models do not automatically have access to an organization's private documents or newly created information.

When users ask questions about internal company information, an LLM may provide incomplete or inaccurate answers if its training data did not include the required information.

RAG addresses this limitation: the system retrieves relevant information from an external knowledge source before generating a response.

1.2 How RAG Works

A typical RAG workflow follows these steps:

The system converts the user query into a vector embedding.
It searches a vector index for semantically similar document segments.
It retrieves the most relevant segments.
It provides the retrieved content as context to the language model.
The language model generates a response using the retrieved context.

This approach grounds the model's response in organizational documents rather than relying solely on information the model learned during training.

1.3 Typical RAG Workflow

The overall workflow looks like this:

User query → Embedding generation → Vector similarity search → Relevant document retrieval → Context construction → LLM response generation

The quality of the final response depends on factors such as document quality, chunking strategy, retrieval accuracy, and prompt design.

2. High-Level System Architecture

A scalable RAG architecture on Google Cloud typically consists of several components, each handling a specific stage of the workflow.

2.1 Core Components

Cloud Storage — Stores enterprise documents such as PDFs, Word documents, technical manuals, policies, and training materials.
Document processing pipeline — Extracts text from documents, divides the content into smaller segments, and prepares it for indexing.
Vertex AI — Provides embedding models and generative AI capabilities.
Vector search infrastructure — Stores document embeddings and performs semantic similarity searches.
Cloud Run — Hosts the backend API that orchestrates the RAG workflow.
Language model — Generates responses using the retrieved document context.

2.2 Query Processing Flow

When a user submits a question, the system processes it through the following sequence:

The user submits a question through a web interface or chatbot.
The application sends the query to an API deployed on Cloud Run.
The API generates an embedding for the query using Vertex AI.
The system searches the vector index for similar document embeddings.
It retrieves the most relevant document segments.
It adds the retrieved content to the prompt as context.
The language model generates a response.
The API returns the response to the user.

This separation of ingestion, retrieval, and generation into distinct components lets teams scale and manage each one independently.

3. Preparing Enterprise Documents for Retrieval

Before a RAG system can retrieve information, a pipeline must process and index the enterprise documents.

3.1 Document Ingestion

Organizations can store enterprise documents in a centralized Cloud Storage bucket. These documents may include:

PDF files
Word documents
Technical manuals
Policy documents
Training materials

An ingestion pipeline can monitor the storage location and process newly uploaded documents.

3.2 Text Extraction

After the pipeline ingests a document, it extracts the document's textual content.

The extraction method depends on the document type. PDF parsing tools can extract text from structured documents, while Optical Character Recognition (OCR) can recover text stored as scanned images.

3.3 Document Chunking

The pipeline divides large documents into smaller sections, commonly called chunks, before indexing them.

Chunking helps the retrieval system identify the specific portions of a document that are relevant to a user's query.

A typical strategy divides documents into segments of approximately 300–800 tokens. Teams can also use overlapping chunks to preserve context between adjacent segments.

The optimal chunk size depends on the document structure, retrieval requirements, and embedding model.

3.4 Metadata Enrichment

Developers can associate each chunk with metadata such as:

Document title
Author
Department
Creation date

Metadata lets the system apply additional filters during retrieval and makes the document collection easier to manage.

4. Generating Semantic Embeddings with Vertex AI

4.1 Embedding Models

Embedding models convert text into numerical vectors that represent semantic relationships between pieces of content.

Unlike simple keyword matching, embeddings let the system identify content that is conceptually similar even when it uses different words.

4.2 Document Embedding Generation

During indexing, the pipeline passes each document chunk through an embedding model to generate its vector representation.

The system stores the resulting vector in the vector-search system together with the corresponding text and metadata.

4.3 Query Embedding Generation

When a user submits a query, the application converts the query into a vector using a compatible embedding model.

The system compares the resulting query vector with stored document vectors to identify semantically relevant content.

5. Implementing Vector Search

5.1 Vector Search Options

Vector-search systems efficiently find similar vectors within large collections of embeddings.

Depending on the architecture, developers can use Vertex AI Vector Search or integrate third-party technologies such as Pinecone, Weaviate, or Elasticsearch with vector-search capabilities.

5.2 Similarity Search

Similarity search measures how closely two vectors relate to each other within a high-dimensional space.

Common similarity measures include:

Cosine similarity
Euclidean distance

The system uses these measures to identify and rank the document segments that are most similar to the user's query.

5.3 Retrieval Optimization

Teams can improve retrieval quality through several techniques:

Adjusting chunk size
Combining keyword and semantic search
Applying metadata filters
Ranking results by relevance
Selecting an appropriate number of retrieved results

Improving retrieval matters because the language model can only use the information the retrieval stage provides.

6. Deploying the Query Service with Cloud Run

6.1 API Service Responsibilities

The backend API orchestrates the RAG workflow. Its responsibilities typically include:

Receiving user queries
Generating query embeddings
Performing vector searches
Constructing prompts
Calling the language model
Returning responses to the user

6.2 Containerized Deployment

Cloud Run can host the containerized API service and automatically scale it according to application traffic.

A container might include:

A Python or Node.js application
Vector-search client libraries
Vertex AI SDK integration
Application configuration and dependencies

6.3 Automatic Scaling

Cloud Run can provision additional service instances as request volume increases, so the application handles changing traffic without requiring developers to manage individual servers manually.

7. Prompt Engineering for Contextual Responses

Retrieval alone does not guarantee a useful response. The prompt must present the retrieved information to the language model in an appropriate structure.

7.1 Context Construction

A RAG prompt typically contains three main elements:

Retrieved context
User question
Instructions for the model

For example:

Retrieved context:
[Relevant document segments]

User question:
[User's question]

Instructions:
Answer the question using only the provided context.

7.2 Grounded Response Generation

An instruction such as the following can encourage the model to rely on the retrieved information:

Answer the question using only the provided context.

Clear instructions can reduce unsupported claims, although prompt design alone cannot guarantee that every response will be accurate.

8. Security and Governance

Enterprise RAG systems may process confidential or sensitive information, so teams should consider security and access controls throughout the architecture.

8.1 Identity and Access Management

Teams can use Google Cloud Identity and Access Management (IAM) to control access to resources such as storage, AI services, and application infrastructure.

Only authorized users and services should access protected enterprise documents.

8.2 Data Protection

Security measures can include:

Encrypting stored data
Securing API communication
Controlling service-to-service access
Applying appropriate identity and permission policies

The specific controls required depend on the organization's security and compliance requirements.

8.3 Audit Logging

Teams can use Cloud Logging to record system activity such as application requests, retrieval operations, and other relevant events.

These logs support:

Debugging
Compliance monitoring
Performance analysis
Incident investigation

9. Monitoring and Observability

Production RAG systems require continuous monitoring to maintain reliability and identify performance issues.

Cloud Monitoring provides visibility into metrics such as:

Request latency
Error rates
Request volume
Resource utilization

Teams can configure alerts for when selected metrics exceed expected thresholds.

Monitoring also helps teams identify opportunities to improve retrieval quality, system performance, and response behavior.

10. Example Enterprise Use Case: AI Knowledge Assistant

Consider an organization with thousands of internal documents covering policies, procedures, and engineering guidelines.

Employees may spend significant time searching for specific information, which can increase support requests and reduce productivity.

A RAG-based knowledge assistant offers an alternative workflow:

An employee submits a question through a chatbot integrated with the company intranet.
The system converts the question into an embedding.
The retrieval system identifies relevant internal documents.
The system provides the retrieved content to the language model.
The assistant generates a response based on the retrieved information.
The application can provide references or links to the original documents.

This architecture makes organizational knowledge easier to discover while maintaining a connection to the underlying source documents.

11. Conclusion

Retrieval-Augmented Generation combines semantic retrieval with generative AI to build applications that can answer questions using information from external knowledge sources.

A Google Cloud-based RAG architecture can combine Cloud Storage for document storage, Vertex AI for embeddings and generative AI, vector-search infrastructure for retrieval, and Cloud Run for the application layer.

A reliable implementation requires more than connecting a language model to a vector database. Document preparation, chunking, retrieval quality, prompt design, security, and monitoring all contribute to the quality and reliability of the resulting system.

As organizations continue to accumulate large collections of internal information, RAG offers a practical architecture for making that information more accessible through AI-powered knowledge applications.

Building a Knowledge Base using SharePoint and AI Search

Summiya ali — Mon, 16 Mar 2026 06:46:38 +0000

Introduction

Organizations generate large volumes of documents every day, including policies, project documentation, technical manuals, and support guides. While Microsoft SharePoint is widely used as a document management platform, finding the right information quickly can still be difficult when content grows at scale.

Traditional keyword-based search often fails when users do not know the exact terms a document uses. This is where AI-powered search can significantly improve the experience.

By combining SharePoint's document storage capabilities with AI search technologies, organizations can build intelligent knowledge bases that let employees retrieve accurate information through natural language queries.

This article demonstrates how to design and build a knowledge base using SharePoint Online and AI-powered search services, enabling faster knowledge discovery across enterprise content.

Why Build a Knowledge Base with SharePoint

SharePoint already acts as a centralized repository for enterprise documents. However, its default search capabilities may not always provide context-aware results.

A knowledge base built on top of SharePoint can provide:

Centralized document storage
Structured knowledge organization
AI-powered semantic search
Faster access to internal knowledge
Improved employee productivity

Organizations commonly use such systems for:

IT support documentation
HR policies and guidelines
Onboarding resources
Technical documentation
Internal training materials

High-Level Architecture

An AI-powered knowledge base typically consists of the following components:

SharePoint Online — Stores enterprise documents such as PDFs, Word files, policies, and guides.
Document Indexing Pipeline — Extracts text content from documents stored in SharePoint.
AI Search Engine — Processes and indexes the extracted content to enable semantic search.
Application Interface — Lets users query the knowledge base using natural language.

A simplified architecture looks like this:

Users
   ↓
Web Portal / Chatbot
   ↓
AI Search Engine
   ↓
Indexed Content
   ↓
SharePoint Document Libraries

The AI search layer lets users ask questions such as:

"What is the company policy for remote work?"

Instead of searching manually through documents, the system retrieves the most relevant knowledge from SharePoint.

Setting Up SharePoint as a Knowledge Repository

The first step is organizing enterprise documents inside SharePoint.

1. Create a Knowledge Base Site

In SharePoint Admin Center:

Create a new Team Site or Communication Site
Name it something like: Company Knowledge Hub

2. Organize Document Libraries

Create structured document libraries such as:

HR Policies
IT Support Guides
Training Materials
Technical Documentation

Proper organization improves both search performance and knowledge management.

3. Use Metadata for Better Search

Metadata helps AI systems understand document context. For example:

Metadata Field	Example
Category	HR Policy
Department	Human Resources
Document Type	Guideline
Last Updated	2026

These metadata fields help AI models deliver more accurate results.

Extracting Data from SharePoint

To enable AI search, developers must retrieve and process documents from SharePoint.

Developers typically use the Microsoft Graph API to access SharePoint data programmatically.

Example request to retrieve documents from SharePoint:

import requests

endpoint = "https://graph.microsoft.com/v1.0/sites/{site-id}/drive/root/children"

headers = {
    "Authorization": "Bearer ACCESS_TOKEN"
}

response = requests.get(endpoint, headers=headers)

documents = response.json()

print(documents)

This API call retrieves files stored in a SharePoint document library. The AI search engine then processes and indexes these extracted documents.

Building the AI Search Layer

AI search engines let users query information using natural language rather than exact keywords.

Common technologies include:

Azure AI Search
Elasticsearch with AI plugins
Vector databases
LLM-powered retrieval systems

The search engine typically performs three steps:

Document processing
Embedding generation
Semantic search retrieval

Example: Creating Vector Embeddings

AI search works by converting document text into numerical representations called embeddings.

Example using Python:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

text = "Company employees are allowed to work remotely two days per week."

embedding = model.encode(text)

print(embedding)

These embeddings let the system measure semantic similarity between queries and documents.

Implementing Semantic Search

Once the pipeline indexes documents, the system can answer user queries intelligently.

Example user query:

"What is the leave policy for employees?"

The system processes the query as follows:

Convert the query into an embedding
Compare it with stored document embeddings
Retrieve the most relevant knowledge sections

Example simplified search logic:

query = "What is the remote work policy?"

query_embedding = model.encode(query)

# Compare query embedding with stored document embeddings
results = vector_database.search(query_embedding)

print(results)

The system returns the most relevant document passages stored in SharePoint.

Building a User Interface for the Knowledge Base

Employees can access the knowledge base through several interfaces:

Web applications
Internal portals
Chatbots
Microsoft Teams bots

For example, a chatbot interface can let employees ask questions like:

"How do I reset my corporate password?"

The AI system retrieves the answer from SharePoint documentation instantly.

Security and Access Control

Enterprise knowledge systems must enforce strict security policies.

SharePoint Permissions

Use SharePoint's built-in role system:

Site owners
Members
Visitors

Ensure sensitive documents remain accessible only to authorized users.

API Security

When accessing SharePoint programmatically, teams should:

Use Azure AD authentication
Implement OAuth tokens
Enforce least privilege permissions

Data Encryption

Protect enterprise knowledge with:

HTTPS communication
Encrypted document storage
Secure API access

These controls ensure compliance with enterprise security policies.

Practical Use Case: Enterprise IT Knowledge Assistant

Consider an internal IT support system built using this architecture.

Employees can ask questions such as:

"How do I connect to the company VPN?"
"Where can I download company security policies?"
"What is the process for requesting new software?"

The system retrieves relevant instructions directly from SharePoint documentation and presents them to users. This reduces support tickets and improves employee productivity.

Benefits of AI-Powered Knowledge Bases

Organizations adopting AI-powered knowledge bases gain several advantages:

Faster knowledge discovery
Reduced time spent searching for documents
Improved employee productivity
Scalable knowledge management
Intelligent enterprise search capabilities

As enterprise data continues to grow, intelligent knowledge systems become increasingly essential.

Conclusion

SharePoint provides a strong foundation for enterprise document management, but integrating it with AI-powered search significantly enhances its capabilities.

By combining SharePoint Online, AI search engines, and semantic retrieval techniques, organizations can build powerful knowledge bases that let employees access information quickly and efficiently.

As generative AI and enterprise search technologies evolve, AI-powered knowledge systems will become a core component of modern digital workplaces.

Implementing such systems enables organizations to transform static document repositories into intelligent knowledge platforms that support faster decision-making and better collaboration.

Understanding Gradient Descent for Beginners: The Core of Neural Network Learning

Summiya ali — Wed, 11 Jun 2025 21:21:32 +0000

Gradient Descent is an optimization algorithm that helps neural networks learn by adjusting weights to reduce errors in predictions.

What Is Gradient Descent?
A Simple Analogy
Why Is It Important in Neural Networks? (Cat vs. Dog Example)
The Gradient Descent Formula Explained
Why the Negative Sign? Why "Descent"?
Types of Gradient Descent
Drawbacks of Gradient Descent
Conclusion: Smarter Alternatives Today

What Is Gradient Descent?

Gradient Descent is a method that helps neural networks reduce prediction errors by changing the internal weights (which act like settings) in the direction that minimizes the loss function — a formula that measures how wrong a prediction was.

A Simple Analogy

Imagine you're blindfolded and standing on a hill, and your goal is to reach the lowest point in the area (like finding the least error). Here's how the key terms relate:

Loss Function → the shape of the hill (how high or low you are, based on error)
Gradient → the steepness and direction of the hill at your feet
Step size (learning rate) → how big a step you take with each move
Gradient Descent → the process of slowly moving down the hill (to reduce error)

You feel the slope under your feet and always take small steps downhill. You don't want to go uphill, where the error increases, so you move in the opposite direction of the gradient.

Why Is It Important in Neural Networks? (Cat vs. Dog Example)

Imagine you're training a neural network to recognize cats and dogs in images.

At first, your model might classify a cat as a dog. That's an error.

Gradient Descent helps the model learn from its mistakes by:

Measuring how wrong the prediction was (loss)
Calculating the direction to adjust the weights (gradient)
Updating the weights to improve future predictions

With every image it sees, whether cat or dog, the model gets a bit better by moving closer to the correct answer, step by step.

Without Gradient Descent, or a similar method, the network would have no way to improve itself.

The Gradient Descent Formula Explained

w = w - η · (dL/dw)

Here's what each term means:

w = weight (the value the model is trying to adjust)
η (eta) = learning rate (how big each update step is)
dL/dw = the gradient — how much the loss changes when the weight changes

The idea: the model checks how much a given weight contributed to the error, then adjusts it slightly to make the error smaller next time.

Why the Negative Sign? Why "Descent"?

The gradient, dL/dw, tells you the direction in which the loss increases.

But the goal is not more error — it's less error.

So the model moves in the opposite direction of the gradient, which is why the formula includes a minus sign.

The model is always moving downhill on the loss curve, which is why the technique is called "Gradient Descent."

Types of Gradient Descent

There are three main versions, based on how much data the model uses to update weights at each step:

Batch Gradient Descent
Uses the entire dataset to calculate the gradient before updating. It is very accurate but slow when the dataset is large.

Stochastic Gradient Descent (SGD)
Updates weights using one data point at a time. It is much faster but noisier and may fluctuate.

Mini-Batch Gradient Descent
Uses small groups of data (for example, 32 samples) to update weights. It combines the strengths of both approaches — efficient and relatively stable — and is the most widely used method in practice.

Drawbacks of Gradient Descent

Despite being powerful, Gradient Descent has some key challenges:

Slow Convergence
Training deep neural networks can take a long time to reach good performance.

Local Minima
The algorithm might get stuck in a small dip (a local minimum) and miss the best solution (the global minimum).

Oscillations
If the learning rate is too high, the algorithm may overshoot the minimum and bounce back and forth without settling.

Conclusion: Smarter Alternatives Today

Gradient Descent is the foundation of how neural networks learn, but it isn't perfect.

Today, practitioners often use improved versions such as:

Momentum — keeps the update moving in a consistent direction to avoid getting stuck
Adam Optimizer — adapts the learning rate based on past steps
RMSProp, Nesterov Accelerated Gradient, and others

These methods all build on the core idea of Gradient Descent, adding extra mechanisms to make learning faster and more stable.

5 Common Flutter Errors and How to Fix Them (2025)

Summiya ali — Fri, 23 May 2025 09:26:48 +0000

Flutter is powerful, but even experienced developers encounter unexpected bugs. In this post, I walk through five real Flutter issues I encountered, what caused them, and how I resolved them. Whether you're new to Flutter or in the middle of a complex build, these solutions can save you significant debugging time.

When you start working with Flutter, you quickly realize it is both impressive and, at times, frustrating. The "hot reload" feature feels magical, but some bugs are considerably harder to resolve.

Here are five real bugs I encountered while working with Flutter, along with how I solved them. I hope this saves you hours of troubleshooting.

1. `The method 'receiveGuardedBroadcastStream' isn't defined for the class 'EventChannel'`

What Happened

After updating some Firebase packages, I started seeing this error related to EventChannel.

Root Cause

Older versions of Firebase packages called the receiveGuardedBroadcastStream method, which Flutter has since removed.

Solution

Upgrade all FlutterFire packages to versions compatible with the latest Flutter SDK:

flutter pub upgrade --major-versions

Also, clean your cache to remove corrupted or outdated packages:

flutter clean
flutter pub get

2. `Error: The system cannot find the path specified` When Importing `_flutterfire_internals`

What Happened

My build failed due to missing files, even though the package was installed.

Root Cause

My .pub-cache was corrupted or only partially downloaded.

Solution

Force Flutter to re-fetch the package:

flutter pub cache repair

If that does not resolve the issue, delete the specific directory:

rm -rf ~/.pub-cache/hosted/pub.dev/_flutterfire_internals-*
flutter pub get

3. `accentColor` Is Deprecated

What Happened

Using accentColor in my ThemeData produced a deprecation warning.

Root Cause

Flutter moved from accentColor to the ColorScheme API with Material 3.

Solution

Use colorScheme.secondary instead:

colorScheme: ColorScheme.fromSeed(
  seedColor: Colors.teal,
  secondary: Colors.amber,
),

And when styling widgets:

color: Theme.of(context).colorScheme.secondary

4. Custom `ThemeData` Not Applying to Widgets

What Happened

Despite setting a custom textTheme, my Text widgets still displayed the default style.

Root Cause

I was overriding styles directly in individual widgets instead of relying on the theme.

Solution

Avoid this:

Text('Hello', style: TextStyle(fontSize: 18, color: Colors.black))

Do this instead:

Text('Hello', style: Theme.of(context).textTheme.bodyLarge)

Make sure the style is defined in your ThemeData:

textTheme: const TextTheme(
  bodyLarge: TextStyle(fontSize: 18.0),
),

5. `RenderFlex` Overflow on Smaller Devices

What Happened

My layout looked correct on my emulator but broke on smaller phones.

Root Cause

Hardcoded height or padding values caused the layout to overflow on smaller screens.

Solution

Use flexible layouts:

Expanded(
  child: ListView(
    children: [...],
  ),
)

Or wrap the content with SingleChildScrollView if needed:

SingleChildScrollView(
  child: Padding(
    padding: const EdgeInsets.all(16),
    child: Column(
      children: [...],
    ),
  ),
)

Test your layout on different device sizes using Flutter DevTools, or run this command with a specific device ID:

flutter run -d <device-id>

You can find available device IDs by running flutter devices.

Final Thoughts

Each of these bugs taught me something useful:

Use the latest stable package versions
Rely on theme-aware styling instead of hardcoded values
Trust Flutter's layout system rather than fixed dimensions
Keep your cache and dependencies clean

If you have encountered similar issues or solved them differently, I would be glad to hear about your experience in the comments.

DEV Community: Summiya ali

Fighting the Fog: A Guide to Focused Productivity While Fatigued

What This Article Covers

What This Article Does Not Cover

Prerequisites

Table of Contents

1. Use the Pomodoro Technique

2. Categorize Your Goals

3. Set Up Three Focus Sessions

4. Block Your Distractions

5. The One Daily Priority Rule

6. The Brain Dump Notebook

7. Case Study: The Juggling Graduate

The Profile

The Implementation Strategy

Conclusion

Building a Scalable RAG Pipeline on Google Cloud Using Vertex AI and Cloud Run

1. Understanding Retrieval-Augmented Generation

1.1 Limitations of Traditional Language Models

1.2 How RAG Works

1.3 Typical RAG Workflow

2. High-Level System Architecture

2.1 Core Components

2.2 Query Processing Flow

3. Preparing Enterprise Documents for Retrieval

3.1 Document Ingestion

3.2 Text Extraction

3.3 Document Chunking

3.4 Metadata Enrichment

4. Generating Semantic Embeddings with Vertex AI

4.1 Embedding Models

4.2 Document Embedding Generation

4.3 Query Embedding Generation

5. Implementing Vector Search

5.1 Vector Search Options

5.2 Similarity Search

5.3 Retrieval Optimization

6. Deploying the Query Service with Cloud Run

6.1 API Service Responsibilities

6.2 Containerized Deployment

6.3 Automatic Scaling

7. Prompt Engineering for Contextual Responses

7.1 Context Construction

7.2 Grounded Response Generation

8. Security and Governance

8.1 Identity and Access Management

8.2 Data Protection

8.3 Audit Logging

9. Monitoring and Observability

10. Example Enterprise Use Case: AI Knowledge Assistant

11. Conclusion

Building a Knowledge Base using SharePoint and AI Search

Introduction

Why Build a Knowledge Base with SharePoint

High-Level Architecture

Setting Up SharePoint as a Knowledge Repository

1. Create a Knowledge Base Site

2. Organize Document Libraries

3. Use Metadata for Better Search

Extracting Data from SharePoint

Building the AI Search Layer

Example: Creating Vector Embeddings

Implementing Semantic Search

Building a User Interface for the Knowledge Base

Security and Access Control

SharePoint Permissions

API Security

Data Encryption

Practical Use Case: Enterprise IT Knowledge Assistant

Benefits of AI-Powered Knowledge Bases

Conclusion

Understanding Gradient Descent for Beginners: The Core of Neural Network Learning

Table of Contents

What Is Gradient Descent?

A Simple Analogy

Why Is It Important in Neural Networks? (Cat vs. Dog Example)

The Gradient Descent Formula Explained

Why the Negative Sign? Why "Descent"?

Types of Gradient Descent

Drawbacks of Gradient Descent

1. `The method 'receiveGuardedBroadcastStream' isn't defined for the class 'EventChannel'`

2. `Error: The system cannot find the path specified` When Importing `_flutterfire_internals`

3. `accentColor` Is Deprecated

4. Custom `ThemeData` Not Applying to Widgets

5. `RenderFlex` Overflow on Smaller Devices