Forem: yashaswi

I Had 12 Unpublished Articles Sitting in Drafts. An MCP Server Fixed That.

yashaswi — Tue, 17 Mar 2026 02:57:28 +0000

I'm a developer who learns by writing. The problem is I almost never finished writing.

The graveyard of half-finished articles on my hard drive tells the real story: 12 drafts I genuinely intended to publish. Topics I found interesting, problems I'd solved, things I thought were worth sharing. Each one abandoned somewhere between "rough idea" and "good enough to post."

It wasn't writer's block. It was friction. The research to figure out what's already been covered. The back-and-forth between editor, Dev.to, and my notes. The formatting, the tags, the series selection. None of it is hard — but all of it adds up to enough resistance that your brain finds something more immediately rewarding to do instead. Like fixing one more bug. Or reading one more article someone else already finished.

I work with AI tools every day. Claude Code handles the heavy engineering work. I gave it my codebase and it refactored, debugged, and planned alongside me. But when it came to writing — the thing I kept saying I wanted to do more of — I was still doing everything by hand.

So I built a bridge. An MCP server that connects Claude directly to Dev.to, turning the whole publish workflow into a conversation.

It didn't just help me publish faster. It changed the psychology of publishing entirely.

What Changes When the Friction Disappears

The biggest thing I noticed wasn't speed. It was that I stopped talking myself out of it.

Before: I'd have an idea, open a blank doc, start typing, realise I didn't know if someone had already written this exact thing, open Dev.to in another tab, spend 20 minutes searching, lose the thread, close the tab, tell myself I'd come back to it. I usually didn't.

After: I'd have an idea, open Claude Code, and say "search Dev.to for articles about X — what's already been covered and what's missing?" Thirty seconds later I have a map of the topic. I know exactly where my angle fits. The blank page problem evaporates because I'm not starting from nothing — I'm starting from a conversation.

That research step alone was the thing that killed most of my articles before they started. Removing it changed everything.

The drafting is also different. I'm not writing into a void and hoping it lands. I describe what I want to say, Claude drafts it, I reshape it into my voice, and the structure is already there. I'm editing, not starting. Editing is easy. Starting is hard. This shifts the work from the hard thing to the easy thing.

And once it's drafted — publishing is literally one message. "Looks good, publish it." Done.

The Workflow in Practice

Here's what an actual session looks like, from idea to published:

Me: "I want to write about setting up a local MCP server for Outlook.
     Search Dev.to — what's already covered on this topic?"

Claude: [searches Dev.to]
        "There are a few articles on MCP setup generally, but nothing
         specifically about Outlook or email automation workflows.
         Strong gap to write into."

Me: "Good. Check my existing series — does this fit anywhere?"

Claude: [checks my articles and series]
        "You have an 'AI-Powered Developer Workflows' series.
         This fits perfectly as the next entry."

Me: "Write it. Focus on the local server setup and the automation
     angle. Keep it practical, not theoretical. Draft it on Dev.to."

Claude: [writes article, creates draft]
        "Draft created. ID: 3341092. Ready for your review."

Me: "The setup section needs more detail — add the exact
     config file path and a sample rule."

Claude: [updates the draft]

Me: "Perfect. Publish it."

Claude: [publishes]
        "Live at https://dev.to/themeticulist/..."

Start to published: one conversation. No tab switching. No copy-pasting. No context loss.

The article that came out of that session? It's sitting on my Dev.to profile right now with reactions and comments. It wouldn't exist otherwise — it would have been draft number 13.

How to Set This Up Yourself

The server is open source at yashaswiyogeshwara/devto-mcp. Here's how to get it running.

1. Get your Dev.to API key

Go to Dev.to → Settings → Extensions → DEV Community API Keys → Generate a new key. Keep it — you'll need it in a moment.

2. Clone and build

git clone https://github.com/yashaswiyogeshwara/devto-mcp.git
cd devto-mcp
npm install
npm run build

3. Create your `.env` file

# devto-mcp/.env
DEVTO_API_KEY=your_key_here

4. Add it to Claude Desktop

Open %APPDATA%\Claude\claude_desktop_config.json and add:

{
  "mcpServers": {
    "devto": {
      "command": "node",
      "args": ["C:/path/to/devto-mcp/dist/index.js"],
      "env": {
        "DEVTO_API_KEY": "your_key_here"
      }
    }
  }
}

Restart Claude Desktop. The Dev.to tools appear automatically in the MCP panel.

5. For Claude Code users

Add the same block to your claude_mcp_config.json (usually at %APPDATA%\Claude\claude_mcp_config.json). Claude Code picks it up on next launch.

What the Server Can Do

Eight tools cover the full cycle:

Research — search_articles finds what's already published on any topic. Filter by tag, author, or popularity. Run this before you write a word.

Planning — list_my_articles and list_series show your existing content so Claude can suggest where a new article fits, and flag if you're about to repeat yourself.

Writing — create_draft saves directly to Dev.to with published: false. You review in your browser before anything goes live. update_article lets you iterate — "make this section more concrete", "cut the intro", "add a code example" — all without leaving the conversation.

Publishing — publish_article is a deliberate, separate step. One message to ship. The separation matters: you always know when something is about to go live.

Tracking — get_article_analytics returns reaction counts and comments for any article.

One Gotcha Worth Knowing

If you're building on top of this or customising it: don't put YAML frontmatter in your article body. The Dev.to API has a quirk where frontmatter in body_markdown silently overrides your JSON parameters — your tags get replaced, your series disappears. The server already guards against this and throws a clear error if it detects frontmatter, but it's worth knowing why.

What Actually Changed for Me

I've published more in the past month than in the previous year. That's not because I suddenly have more ideas or more time — it's because the step between "I should write about this" and "this is published" shrank from a multi-session ordeal to a single conversation.

The tool doesn't write the articles for me. My voice, my examples, my perspective — that still has to come from me. But it handles everything around the writing. The research, the structure, the formatting, the publishing mechanics. It turns writing from a project into a conversation.

If you've got a graveyard of unpublished drafts, that's the thing worth fixing.

This article was drafted using the MCP server it describes.

How to build a local MCP server for outlook and create email automation

yashaswi — Sat, 14 Mar 2026 09:04:23 +0000

Here's a conversation I had with my AI assistant last Tuesday morning:

Me: Read my inbox. What needs me today?

AI: You have 43 unread emails. 3 need a reply. 2 contain action items. The rest are notifications and CC'd threads.

Me: Draft a reply to Sarah. Tell her to restart the service, I'll push a fix today.

AI: Done. Here's the draft. Want me to send it?

Me: Send it. What should I work on today based on those emails?

AI: 1. Fix the staging bug Sarah reported. 2. Address Mike's review comments. 3. Confirm the client license renewal by Friday.

I didn't open Outlook. I didn't Alt-Tab. I didn't copy-paste a single thing. My inbox was processed, my replies were sent, and my day was planned â€” all before 9:15.

This isn't a mockup. This is my actual morning now. And the thing that makes it work took an afternoon to build.

The Dumbest Moment That Started This

I was three hours into debugging a race condition. Deep focus. The kind where you're holding six things in your head and one interruption resets all of them.

A Slack message popped up: "Sent you the stack trace on email."

So I did what every developer does twelve times a day. Minimized the IDE. Opened Outlook. Scrolled past newsletters, build alerts, a meeting reschedule, three CC'd threads I didn't care about. Found the email. Selected the stack trace. Copied it. Switched back to the IDE. Pasted it.

And then sat there for four minutes trying to remember what I was doing before.

My AI assistant was right there in the editor the entire time. It can search through 10,000 files in my codebase. It can refactor an entire module. But it couldn't read one email sitting in the application running right next to it.

That felt dumb. So I fixed it.

The Three-Line Secret

Outlook on Windows has a built-in interface called COM. PowerShell speaks it natively. The entire connection:

$outlook = New-Object -ComObject Outlook.Application
$ns      = $outlook.GetNamespace("MAPI")
$inbox   = $ns.GetDefaultFolder(6)

No API keys. No sign-ups. No cloud portal. Outlook is already running on your desktop â€” this just lets another program talk to it.

To make my AI understand this, I used MCP â€” Model Context Protocol. It's a standard for giving AI assistants new abilities. You define a function like "read inbox," and the AI can call it whenever it needs to.

The bridge between the two is a small Node.js server:

Me (in IDE) â†’ AI â†’ MCP Server â†’ PowerShell â†’ Outlook

const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");

const mcpServer = new McpServer({ name: "outlook-com", version: "1.0.0" });

async function main() {
  const transport = new StdioServerTransport();
  await mcpServer.connect(transport);
}
main().catch(() => process.exit(1));

Ten lines. One npm package. One config file to tell the IDE where to find it:

{
  "mcpServers": {
    "outlook": {
      "command": "node",
      "args": ["mcp-servers/outlook-com-mcp/server.js"]
    }
  }
}

Restart the IDE. That's the whole setup.

What I Actually Do With It Every Day

Morning scan. "Read my last 20 emails. What needs a reply, what's FYI, what can I skip?"

Reply (3): Sarah â€” staging bug. Mike â€” PR questions. Client â€” license renewal.

FYI (5): Build alerts, sprint update, meeting reschedule.

Skip (12): Newsletters, CC'd threads, automated noise.

Three emails that need me. Not forty-three.

Replies. I tell the AI what to say. It reads the full email for context, drafts the reply. I tweak a line, say "send it." No window switching. No losing my train of thought.

Todo list. "Based on what you just read, what should I work on today?" Done. My day is planned from my inbox.

Friday cleanup. This one I found by accident. "Search for all automated notifications from the last 7 days. Group by sender." â€” 14 from Jira, 9 from CI/CD, 6 newsletters I never read. I unsubscribed from four on the spot. Now I do this every Friday. Two minutes. Mailbox stays clean.

Build This Today

Windows + Outlook + Node.js. That's the whole requirements list.

mkdir mcp-servers/outlook-com-mcp && cd mcp-servers/outlook-com-mcp
npm init -y && npm install @modelcontextprotocol/sdk
Write server.js â€” skeleton above + a function that runs PowerShell scripts
Write your .ps1 scripts â€” each starts with the same three-line Outlook connection
Add the config file, restart

Fifteen minutes. One dependency. Your AI reads, searches, sends, and replies to email.

Start with email. Once it works, you'll realize the same pattern connects anything on your machine â€” calendar, contacts, Excel. Same bridge. Same config. Same afternoon.

If you build something with this, tell me in the comments. I'll be reading them from my IDE.

From Overwhelmed Team Lead to AI Orchestrator: How I Took Back Control of My Dev Life

yashaswi — Sun, 08 Mar 2026 15:50:06 +0000

13 years building .NET products. Team lead. This is what the last 8 months taught me.

The Anxiety Phase

13 years as a .NET engineer. I thought I had seen everything.

Then May 2025 happened and my team started using Cursor.

Before that my week was fine. 1 maybe 2 stories, a couple of PR reviews, some back and forth with business. This is what my week looked like.

Then almost overnight it wasn't.

Stories went from 1-2 per week ** to **1-2 per day. PRs went from a couple a week to 3-5 queued at any given time. Communication items - Slack threads, business questions, QA back and forth - just kept stacking. Every morning I'd open Slack and already feel behind before I'd done anything.

The reason was my team had picked up Cursor.

Juniors who used to write 20 lines and check with me, were now shipping whole features. Which sounds great right! It isn't great when you're the one reviewing it. I went from leaving 3-5 comments per PR to 10, 20, sometimes 30. Because Cursor was directing them, not them directing Cursor. Every architectural call, every pattern decision, every naming choice the tool made - that all landed in my queue.

And the sprint numbers looked incredible from the outside. 10 stories per sprint became 25 stories per sprint. Leadership was happy. I was not.

I still had my own stories to deliver. Business teams still needed answers. QA still needed help with test plans except now there was 2.5x the surface area to cover. Every part of my job got multiplied at the same time.

I don't want to be dramatic about it but those 8 months - from May 2025 to around last month - were genuinely an anxiety phase for me. Every sprint was really a "Sprint" there was no time to relax. Before it was always to hard sprints and one medium sprint were you can relax a bit (Real developer know , this is needed. We cannot constantly run, we are humans and we need breaks.)

The Click

One day I'm sitting there with a PR queue, a stack of Slack threads, 2 stories in progress, a test plan that needs my input - and it just hit me. (This is something that happens with all the developers. It will just hit you. No prepration needed or process to follow. It just hits)

All I had to do was give up my ego.

That was it. That was the whole thing.

I had spent 13 years being the person who understood the codebase, caught the bugs, knew the patterns. And I was holding onto that identity while everything around me had already moved on. I was trying to do the work when I should have been directing something that could do it for me.

The second I made that switch in my head - Cursor is not a tool I use, it is an incredibly capable assistant I manage - I knew exactly what to build.

Step Zero: Building the System

First thing I did. No magic prompts, no clever tricks. Just sat down and built 4 things:

1. MCP Servers

Slack server
ADO server

So Cursor could actually see my world, not just my code.

2. Cursor Rules

13 years of pattern knowledge sitting in my head - SQL CRUD conventions, code flow, project-specific standards. If I have left the same PR comment more than twice it is now a rule. Cursor doesn't guess, it follows. (If you are thinking of building this dont over complicate it, just give curosr the rules you follow in the code. They can be just one or two and ask cursor to create rules. It will do it for you. In next one week, trust me, you will create a document of rules)

3. Cursor Skills

Branch naming, PR structure, commit messages - the repetitive stuff. I created skills so Cursor handles it consistently without me having to specify every time. (Dont complicate this either. what ever repeatable stuff you do in your project, create a skill for each)

4. A Prompt for Every Job

Triage, review, execution, communication, test planning - each one has a prompt. Not vague. Specific. Cursor knows what role it is playing and what I need out of it.

That is the foundation. Everything I am going to walk you through is built on those 4 things.

One Window. That Was the Rule.

Now once the setup was done, I did the same things I have always done, but this time I used Cursor as my only window of operation.

Developers will relate to this - the more we switch windows the more context switching happens - it feels like and it drains energy. So I said Cursor will be my window of operation. That's it.

Now this is how my day looked

As soon as I start working I ask Cursor to look into all posts that mention me or my name in the last 36 hours, give me an analysis of what is expected from me, and break it down into tasks.

Those tasks fall into buckets:

Communication tasks - Cursor spawns separate threads, analyses each one, creates appropriate responses. I review and send.

ADO comment tasks - Based on the item I analyse it and ask Cursor to add the appropriate comments.

Priority ADO stories - This is where it gets interesting. Cursor:

Analyses the story
Creates an execution plan and a test plan
Creates the branch - I have a skill that handles the branch naming convention and the parent branch
Generates the code using Cursor rules that point to SQL table CRUD patterns, code flow based on patterns already in the repo, and other coding conventions
Commits with proper comments
Raises a fresh PR and gives feedback on the changes

Then I manually look into the code, give Cursor the PR comments to fix, it fixes them.

Post merge - I direct Cursor to execute the test plan and ask it to attach test comments and screenshots to the story. I review the testing scenario and if everything looks good I close the story.

For engineering heavy items - I give feedback post code generation. I make sure to ask all the questions, I need on the generated code for my own understanding, and I give Cursor proper correction and feedback. This process over time sharpens Cursor - better code generation, faster delivery, less back and forth.

Things I Discovered Along the Way

Once the core workflow was running I started pushing Cursor further and was genuinely surprised by what it could handle.

Cursor can log into web applications in Chrome, navigate them and do UI testing - and you can watch it happen in real time. It can also connect to Chrome's dev tools, open your website and run UI testing from there. I did a lot of local testing this way and asked Cursor to give me screenshots for validation.

It can analyse logs too. You give it the location where your logs are stored and it gives you root causes behind bugs. It can even look into information logs, analyse performance from the log timestamps and tell you exactly what you should be looking into and why.

Overall Cursor is a very powerful tool. And from what I have seen you should be able to achieve the same workflow using Claude Code as well.

One thing to note - for heavier tasks I use either Claude Opus or Gemini inside Cursor depending on what the task needs.

Never Let Cursor Direct You

This is the most important thing in this entire post.

You are still the one coding. Never forget that.

Senior devs will relate to this. Most of the time before Cursor or Claude, the high was in finding the solution. The labour - the actual typing, the boilerplate, the repetitive implementation - that is what you would delegate to a junior. The problem with delegating to a junior was always making them understand what to do.

That is exactly what you should do with Cursor. Except instead of a junior dev you have an incredibly intelligent assistant at hand. You bring the domain knowledge, the architecture instinct, the product context. Cursor brings the execution. That combination is unbeatable.

You Don't Need a Git Repo to Get Started

I know devs don't want fluff. You want real code, git repos, assets you can clone and run.

I did not intentinally attach this stuff.

Simply ask Cursor to read through this post and ask it to give you a plan on what to set up to streamline your own workflow the way I have done it. Trust me - it will do it. All you have to do is execute that plan.

And just like that you have passed the phase of burnout.

One Last Thing About Prompts

Don't overthink them. A prompt is just your thought process written down - the same step by step thinking you already use to solve your day to day tasks. Just give Cursor that thought process and ask it to create the prompts for you. It will. And they will be better than anything you would have spent an hour writing yourself.

I am writing this after long time. Any comments are more than appriciated.

[Post-4][LINQ] Yield-Performance

yashaswi — Sun, 31 Oct 2021 17:33:53 +0000

[Post-4][LINQ] Yield-Performance

Using yield return has a great performance benefit when querying the data. That is because, the data is returned only when it is iterated.

For example If you have to run multiple queries on a collection, one way is to iterate the collection for each query. The other way is to compile all the queries together and then run them once on the collection. The second way is better in performance and also has less memory footprint.

Lets look into an example to establish the above point. [Source code is provided in the end of the blog as a github gist]. In the example we will filter a list of numbers and get multiples of 6.

Below is the list of numbers from 1 to 20.

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };

Lets do the filtering as a two step process.

First we will filter the numbers that are divisible by 2.
Then, we will filter the numbers that are divisible by 3.

Below are two functions bool DivideBy2(int x) and bool DivideBy3(int x) that return true if the number is divisible by 2 or 3 respectively.

private bool DivideBy2(int x)       
{           
 if (x % 2 == 0)
 {                
   return true;         
 }           
 else 
 {               
   return false;           
 }       
}

private bool DivideBy3(int x)       
{           
 if (x % 3== 0)
 {                
   return true;         
 }           
 else 
 {               
   return false;           
 }       
}

Now lets create the a Filter extension on IEnumerable that filters the given enumerable based on a given predicate.

public static IEnumerable<int> **FilterWithOutYield**(
this IEnumerable<int> **enumerable**, Func<int, bool> **func**)        
{
  IEnumerator<int> **enumerator **= enumerable.GetEnumerator();
  List<int> result = new List<int>();
  **while (enumerator.MoveNext())**
   {
      **if (func(enumerator.Current))**
      {
        **result.Add(enumerator.Current);**
      }
   }
  **return result as IEnumerable<int>;**
}

The above function **FilterWithOutYield **has two parameters

enumerable: The data on which this **FilterWithOutYield **is executed on.
func: This function acts as a filter and helps decide whether the item filtered or not.

So the function is doing 3 things here

Iterating over the enumerable **in the while loop using its enumerator. [while loop**]
Filtering those numbers that satisfy the given predicate func. **[If **]
Adding them to a list and returning them*. [result]*

Lets call the above **FilterWithOutYield **on the list of 20 numbers that we have created in the beginning.

List<int> **numbers **= new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
            List<int> multiplesOfSix =
                (
numbers.FilterWithOutYield(**DivideBy2**) // returns a list 
       .FilterWithOutYield(**DivideBy3**) // returns a list

) as List<int>;

In the above code FilterWithOutYield *is called *twice on the numbers.

First time, **DivideBy2 **is used as the predicate. The function filters all the numbers divisible by 2 and returns a list.
Second time, **DivideBy3 **is used as the predicate. The function filters all the numbers divisible by 3 from the above list of numbers and returns another list.

At last a list of numbers that are divisible by 6 are returned. Here if you observe we are iterating through the collection twice and returning a new List at each stage.

I.e. If FilterWithOutYield is chained n times , the iterations are also proportionately increased and also the number of lists returned.

Now, lets look at a better way of doing the same using Yield. Below is the FilterWithYield *function that filters an enumerable and uses **yield return.*

public static IEnumerable<int> FilterWithYield(
this IEnumerable<int> enumerable, Func<int,bool> func)
{
   IEnumerator<int> enumerator = enumerable.GetEnumerator();
   while (enumerator.MoveNext()) 
   {
     if (**func(enumerator.Current)**)
     {
       **yield return enumerator.Current;**
     }
   }
 }

If you note, in the above method we are not returning any list instead we are doing an yield return.

Lets call this method on an enumerable and see how it works.

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };

IEnumerable<int> multiplesOfSixUsingYield =
numbers.FilterWithYield(**DivideBy2**) // The list is not iterated.
       .FilterWithYield(**DivideBy3**); //Instead enumerator is returned

The above code does not iterate over **numbers, **and therefore does not go into either of **DivideBy2 **or **DivideBy3 **methods. Instead an enumerator is created that uses both **DivideBy2 **and **DivideBy3 **methods to filter the enumerable.

To fetch a collection from the above code, the multiplesOfSixUsingYield *has to be iterated using a **foreach* as below, or using extension methods like **ToList() *or *ToArray()**.

foreach (int x in multiplesOfSixUsingYield) 
{              
   Console.WriteLine(x);
}

Because of yield return, the enumerable is iterated only once irrespective of the number of times the FilterWithYield method is used, improving the time and also decreasing the memory foot print.

Hope, you have liked the article. Keep reading. Thanks.

[Post-3][LINQ] — Yield

yashaswi — Sun, 31 Oct 2021 17:31:00 +0000

Yield in C# is very tricky concept and would take at least a couple of reads to understand its use or purpose. Lets try to de -mystify this concept and understand its use and purpose in this article. Get buckled up for an interesting read.

***Enumerable **and ***Enumerator *are foundational concepts to understanding of **Yield. Any method that does *yield return should return an **Iterator. **For a method to return an Iterator, its return type must of be one of the below types.

IAsyncEnumerable
IEnumerable
IEnumerable
IEnumerator
IEnumerator

If you are wondering what these * *declarations mean, don’t worry, these are part of *Generics, *which will be covered in necessary proportions in the upcoming chapters. For now you can ignore them.

Add breakpoints at line 17 and at lines 22 till 26 then run the code. You’ll notice that the code does not go into *YieldNumber() *method. It bypasses the method and breaks directly at line 17.

The reason behind this functionality is that, yield return does a Lazy evaluation.

Lazy evaluation in this context means that, until the YieldNumber() method is iterated the yield return statements are not executed.

Now uncomment the line from 12 to 16 and execute the program.

Notice that the program now goes into the *YieldNumber *method and breaks at each yield return statement for each iteration of the while loop.

In the next post lets talk about how Yield and LINQ are related and understand performance benefits of LINQ.

The posts in this publication are intentionally kept short for easier learning.

Any comment from you is greatly appreciated. Thanks!!!

[Post 2]LINQ -IEnumerator

yashaswi — Sun, 31 Oct 2021 17:25:28 +0000

[Post-2] [LINQ] IEnumerator

Now that we have talked about *“Enumerable” .Lets talk about *“Enumerator”.

Enumerators are those that make a data structure Enumerable.

I.e. Enumerators help traverse or iterate an Enumerable. IEnumerable and IEnumerator implement the “Iterator Pattern”.

**Iterator** is a behavioral design pattern that lets you traverse elements of a collection without exposing its underlying representation (list, stack, tree, etc.).

Making it simple Iterator pattern asks us to separate the underlying data collection and the functionality to traverse it.

Below are the IEnumerator and IEnumerable interfaces. IEnumerable exposes a method which returns an IEnumerator. IEnumerator provides following methods and properties.

bool MoveNext(): Moves the pointer to next item in the collection and returns true. If the pointer is at the end of collection it returns false.

**object Current: **This property provides the current values of the item the pointer is located at.

**void Reset(): **Although not extensively used or is part of *Iterator pattern *UML diagram, this method sets the pointer to the initial value of the collection.

Look at the below example where different data structures return their Enumerators using which the these are iterated.

If you notice, in the above code we are iterating different data structures using same method “Enumerate”. If you get back to the *Iterator Pattern *definition, irrespective of the characteristics or internal implementation of the data structure we are able to iterate them uniformly.

Although it is not a common practice to use the enumerator for iterating a data structure. [Instead we would use the foreach *loop directly.] Understanding this particular concept helps in understanding **LINQ*.

In the next post lets look into **Yield **and how IEnumerable and Yield are linked together.

Thanks, please subscribe to the publication for more interesting posts.

[References]

Iterator Pattern : *https://www.youtube.com/watch?v=uNTNEfwYXhI*

[Post 1]LINQ -Enumerable

yashaswi — Sun, 31 Oct 2021 17:11:51 +0000

[Post 1]LINQ -Enumerable

Enumerable is a data structures that can be iterated, counted or enumerated. Array, List, Dictionary are some data structures that are Enumerable.

In perspective of C# any Object that implements “*IEnumerable” *interface is an Enumerable. Array, List, Dictionary are some of the data structures that implement IEnumerable.

Every IEnumerable can support the use of “foreach()” *method for iterating the collection. [This post limits itself to the concept of IEnumerable and does not divulge into “*IEnumerable”.]

Documentation

IEnumerable is part of “System.Collections” *namespace. IEnumearble contains only a single method *“GetEnumerator()” *which returns an “*IEnumerator”.[A seperate post is being written on “IEnumerator” *which would be published shortly.]

A series of posts would follow this that talk about *“IEnumerator” , “Iterator Pattern” *and *“LINQ”.

The posts are written small intentionally. The purpose of these posts is to provide information in nuggets for faster assimilation, keeping it short and simple.

Everything you should know about Styles in Angular

yashaswi — Sat, 08 Jun 2019 17:36:56 +0000

In this article we will talk about

How to add styles to components in Angular.
Global styles in Angular.
What is ViewEncasulation property and how does it effect the Component Styles.

So lets get Started!!!

Component Styles in Angular

To understand this lets quickly create an angular application.
> ng new StylesInNg

Below is the app.component.html and its css file. To this component's span element, a blue color style is added.

Now lets add another component and do the same, except, instead of blue this time lets add red color.

And this is how it looks in the Browser.

See, the app.component header span element is blue in color and the info.component header span element is red in color.
Now look into their styles in the same image.




<style>header[_ngcontent-c0]   span[_ngcontent-c0]{
    color: blue;
}</style>

<style>header[_ngcontent-c1]   span[_ngcontent-c1]{
    color: red;
}</style>

<app-root _nghost-c0="" ng-version="6.1.10">
  <header _ngcontent-c0="">
    <span _ngcontent-c0="">This is the header</span>
  </header>
  <p _ngcontent-c0="">This is some paragraph</p>
  <app-info _ngcontent-c0="" _nghost-c1="">
    <header _ngcontent-c1="">
      <span _ngcontent-c1="">This is the header of Info Component</span>
    </header>
    <p _ngcontent-c1="">This is some paragraph in Info Component</p>
  </app-info>
</app-root>

Notice the attributes _nghost-c0 , _ngcontent-c1, that are present on the header, span elements and on their respective styles. These are attributes that angular uses to isolate component styles from one another. This is called as Emulated Shadow DOM.

In summary, by default all the elements of a component will have a specific attribute given by angular and the same attributes are set to their styles, thereby creating Style Isolation in components.

For a deeper dive on this you can look here.

Global styles in Angular.

Any, .css or .sass style sheet added in the styles[] in angular.json is considered as a global style. By default, styles.css sheet is present in this array.

Some points on Global styles.

You can use @import statements in styles.css to add styles sheets to global styles.
Adding style sheets in styles[] or in styles.css will make them global and there is no difference between these two.
Global styles do not have angular attributes attached to them unlike the component styles.
Component styles override the global styles.

ViewEnapuslation.

Lets understand ShadowDom first. Add a date element to info.component and open Chrome Dev Tools > Elements > Settings and check the Show user agent shadow dom option. Inspect the date element in the dev tools.

via GIPHY

Notice, <input type="date"> element has a whole new DOM inside it, this is called Shadow dom.

A parallel DOM created by the browser that encapsulates the markup, style, and behavior (DOM manipulation) of an HTML element.

Angular emulates the shadow dom concept, where it encapsulates the markup, style, and behavior of the component by default and this is called Emulated type of encapsulation.

A component decorator contains a property called encapsulation that sets the ViewEncapsulation value.

There are three modes of encapsulation.

1.ViewEncapsulation.Emulated:[The default value] Angular creates a emulated shadow dom here and isolates the component styles. However, the components can still inherit the global styles in this mode.

2.ViewEncapsulation.Native:In this mode the component does not inherit the global styles and also the component styles are isolated.

3.ViewEncapsulation.None: In this mode the component styles become global and their is no more isolation.

Below is app.component.html code.



<header>This is header</header>
<p>This is paragraph</p>
<app-content>
   <app-info></app-info>
</app-content>

Note, a component cannot inherit styles of its parent. In the above html code the <app-content> component can not inherit the styles of app.component and also <app-info> component can not inherit the styles of <app-content> component

Forem: yashaswi

I Had 12 Unpublished Articles Sitting in Drafts. An MCP Server Fixed That.

What Changes When the Friction Disappears

The Workflow in Practice

How to Set This Up Yourself

1. Get your Dev.to API key

2. Clone and build

3. Create your .env file

4. Add it to Claude Desktop

5. For Claude Code users

What the Server Can Do

One Gotcha Worth Knowing

What Actually Changed for Me

How to build a local MCP server for outlook and create email automation

The Dumbest Moment That Started This

The Three-Line Secret

What I Actually Do With It Every Day

Build This Today

From Overwhelmed Team Lead to AI Orchestrator: How I Took Back Control of My Dev Life

The Anxiety Phase

The Click

Step Zero: Building the System

One Window. That Was the Rule.

Now this is how my day looked

Things I Discovered Along the Way

Never Let Cursor Direct You

You Don't Need a Git Repo to Get Started

One Last Thing About Prompts

I am writing this after long time. Any comments are more than appriciated.

[Post-4][LINQ] Yield-Performance

[Post-4][LINQ] Yield-Performance

[Post-3][LINQ] — Yield

[Post 2]LINQ -IEnumerator

[Post-2] [LINQ] IEnumerator

[Post 1]LINQ -Enumerable

[Post 1]LINQ -Enumerable

Documentation

Everything you should know about Styles in Angular

In this article we will talk about

Component Styles in Angular

Global styles in Angular.

Some points on Global styles.

ViewEnapuslation.

A parallel DOM created by the browser that encapsulates the markup, style, and behavior (DOM manipulation) of an HTML element.

3. Create your `.env` file