<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ashwin Sathian on Medium]]></title>
        <description><![CDATA[Stories by Ashwin Sathian on Medium]]></description>
        <link>https://medium.com/@ashwinsathian19?source=rss-6382b37e6343------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sQ68uUaP6wRWXwmZkiFB6w.jpeg</url>
            <title>Stories by Ashwin Sathian on Medium</title>
            <link>https://medium.com/@ashwinsathian19?source=rss-6382b37e6343------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 00:25:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ashwinsathian19/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why ngx-runtime-i18n treats the active language as a signal, not an Observable]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">The idea of building @ngx-runtime-i18n came from my personal experience and if I may daresay frustration at the popular options when it&#x2026;</p><p class="medium-feed-link"><a href="https://levelup.gitconnected.com/why-ngx-runtime-i18n-treats-the-active-language-as-a-signal-not-an-observable-73c8f9efa3b5?source=rss-6382b37e6343------2">Continue reading on Level Up Coding »</a></p></div>]]></description>
            <link>https://levelup.gitconnected.com/why-ngx-runtime-i18n-treats-the-active-language-as-a-signal-not-an-observable-73c8f9efa3b5?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/73c8f9efa3b5</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[angular-signals]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 16:15:03 GMT</pubDate>
            <atom:updated>2026-08-19T16:15:03.717Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Why “Humanize My Writing” Tools Don’t Work]]></title>
            <link>https://ashwinsathian19.medium.com/why-humanize-my-writing-tools-dont-work-52d6087595d7?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/52d6087595d7</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 07:13:36 GMT</pubDate>
            <atom:updated>2026-08-18T07:13:36.734Z</atom:updated>
            <content:encoded><![CDATA[<p>In December 2024, Florida State University linguists Tom Juzek and Zina Ward set out to answer a question that had turned into a running joke among people who read a lot of AI output: why does ChatGPT say “delve” so much?</p><p>Instead of guessing, they built a study designed to eliminate the wrong explanations first, a philosophy-of-science-style method for ruling out competing hypotheses one at a time. First candidate: maybe these words are just common in whatever text the models were trained on. Ruled out. Second candidate: something about the model architecture, or the mechanics of how the model picks its next word. Also ruled out. What was left, after comparing a base version of Llama 2 against the same model fine-tuned with human feedback, was the fine-tuning stage itself. Somewhere in the process of humans rating model outputs as good or bad, “delve” started winning.</p><p>That’s not a fringe result. A separate team led by Dmitry Kobak at the University of Tübingen ran the numbers on over 15 million PubMed abstracts published between 2010 and 2024, borrowing a statistical method from epidemiology, “excess mortality,” repurposed as “excess vocabulary,” to separate ordinary word-frequency drift from something anomalous. “Delve” wasn’t the only word that spiked. “Meticulously” rose 137% year over year. “Intricate,” 117%. “Commendable,” 83%. By their estimate, at least 13.5% of 2024 biomedical abstracts show signs of LLM involvement, a bigger vocabulary shift than the one COVID caused. Kobak’s study measures the size of that shift. The fine-tuning explanation for *<em>why</em>* it happens is still just the FSU team’s own finding, unreplicated so far.</p><p>Here’s the part almost nobody mentions when they cite that finding: it’s already going stale. A follow-up study from the same FSU team found “delve,” “boast,” and “meticulous” showing up more often in ordinary spoken language too, in podcasts and YouTube talks. People who read a lot of AI text are picking up its vocabulary and using it themselves. The tell is bleeding into the population it was supposed to detect.</p><h3>The word-list trap</h3><p>This is the problem with almost every “humanize my writing” tool currently on GitHub, even the well-built ones: underneath whatever nuance they add, they’re still built around a list of words. I went looking, expecting a handful of thoughtful tools and a pile of junk. What I found instead was a spectrum of care applied to the same underlying mechanism.</p><p>The most-starred tool in the space has over 36,000 stars, a number worth eyeing with some skepticism given it’s a single markdown file. It does real work: protecting ordinary formal vocabulary from being flagged, refusing to invent facts during a rewrite, matching a user’s own writing sample instead of forcing one house style on everyone. None of that changes what it’s actually doing underneath, which is checking a passage against roughly three dozen fixed patterns, a heuristic that goes stale the moment models or detectors shift. A second tool opens by citing real false-positive research on AI detectors before giving a single rule, and states outright that its signals are “worth acting on; not worth ruining someone’s day over,” arguably the most epistemically honest framing in the entire space. Strip away that framing, though, and the bulk of what’s left is the same genre of banned-word list as everything else.</p><p>Then there’s the tool at the other end of the spectrum, the one that instructs its model to treat certain words as an instant, unqualified tell: “if even one of these words appears, the text immediately flags as machine-written.” Its banned list includes *<em>robust</em>*, *<em>scalable</em>*, *<em>integrated</em>*, *<em>proactive</em>*, words that show up constantly in ordinary technical writing because they’re often the correct word for the job. Strike “robust” from a paragraph about fault tolerance and the paragraph just gets vaguer. No single word carries that much diagnostic weight on its own.</p><p>Even the more careful tools slip into the same trap. One enforces a rule capping em dashes at “Maximum ONE per 500 words,” with no stated methodology behind the number anywhere in its documentation, and separately instructs its model to apply all its rules silently, never mentioning them to the person it’s writing for. That’s a strange thing to optimize for if the goal is writing that’s actually good. Being undetected is a different achievement.</p><p>Word lists share the same fragility no matter how carefully they’re built: cheap to build, fast to go stale, and aimed at the weakest part of the signal.</p><h3>What the stronger signal actually looks like</h3><p>Separately from all of this vocabulary-chasing, there’s a body of peer-reviewed computational linguistics research quietly measuring sentence shape instead of word choice.</p><p>A 2024 study out of the Universidade da Coruña compared six sets of LLM-generated news text (Mistral, Falcon, and LLaMA at four different sizes) against real human-written news articles, chosen specifically from after the models’ training cutoffs so nothing in the comparison could have been memorized. Human writing spread its sentence lengths across a wide range, some short, some long, unevenly. Every model, regardless of which one wrote the piece, clustered tightly into a narrow 10-to-30-token band. That gap between human and machine was larger than the differences between the six models themselves. Whatever “sounds like Mistral” and whatever “sounds like LLaMA” turned out to have more in common with each other, structurally, than either has with an actual human sentence.</p><p>A separate PNAS study found the same convergence in the shape of entire stories instead of sentences: LLM-generated narratives cluster around a much smaller set of recurring plot patterns than human-written ones do, even across different prompts. Same convergence, different scale, still nothing to do with vocabulary.</p><p>This is the inconvenient part for anyone building a “humanizer” out of a word list: structure is a harder problem to fake your way around, and it’s also the more durable signal, because it isn’t tied to which specific words happen to be fashionable in this quarter’s training data. A model can stop saying “delve” tomorrow. Rewriting the shape of its sentences is a different kind of problem.</p><h3>The em dash isn’t the story people think it is</h3><p>If there’s one tell that’s achieved genuine cultural traction outside of NLP circles, it’s the em dash. NPR ran a piece on “the unofficial movement to save the em dash” from guilt by association. A Rochester Institute of Technology student paper cited GPT-4.1 using the mark at roughly 3.28 times the rate of typical human essays.</p><p>What’s less settled, and this is where the sources genuinely disagree, is whether that overuse even means what people assume it means, let alone why it happens. One independent analysis argues it’s a training-data artifact: labs eventually ran out of fresh web text and started digitizing older, pre-1950s books, which use em dashes far more heavily than contemporary writing, and GPT-3.5, trained before this shift, didn’t show the same overuse that GPT-4o does. A competing explanation points the other direction: human raters, during the reinforcement-learning stage that shapes a model’s final behavior, reward the clarity and pacing an em dash provides, and that preference gets baked in regardless of what the training data looked like.</p><p>Benjamin Dreyer, Random House’s longtime copy chief and about as credentialed a human authority on English prose as exists, doesn’t think the overuse claim itself holds up. He went looking for the “charts and graphs and proofs” behind the em-dash panic and found none. Examining sample AI prose by hand, he called the whole thing “social media blather” and found nothing anomalous in the counts. What worries him more is the chilling effect: students spooked into avoiding a perfectly good punctuation mark for fear of being falsely flagged, paying a real cost for a signal that was never trustworthy on its own to begin with.</p><h3>What the source of all this actually said</h3><p>At least 6 of the 13 tools I looked at trace their DNA back to one place: Wikipedia’s “Signs of AI writing” essay, maintained by volunteer editors who patrol new submissions for undisclosed AI content. It’s genuinely excellent applied research. Built from thousands of real cases and revised as models change, it’s more rigorous than most of what’s built on top of it.</p><p>It also contains a warning that hardly anyone who cites it seems to have read past: its own verdict on the tells it catalogs is that they’re surface symptoms of something worse underneath, unreliable sourcing, shallow synthesis, no real editorial judgment. Scrub the vocabulary without touching any of that and you’ve, in the essay’s own words, “obscured the actual concerns.” A find-and-replace pass that swaps “delve” for something else and caps the em dashes gets past the pattern-matching. It never produces text anyone actually thought through.</p><p>That’s the harder problem, and it’s the one worth building for. We ended up doing exactly that: research on 27 cross-referenced tells, ranked by source strength and how often each one actually shows up, plus a teardown of what the tools above get wrong, that became a Claude Code skill built around structure and specificity first, with the vocabulary list demoted to a backup role instead of the primary mechanism. It’s not foolproof, and it’ll date the same way every tell-based approach eventually does. It’s on GitHub if you want to check the sourcing yourself: <a href="https://github.com/AshwinSathian/humanize-writing-skill">github.com/AshwinSathian/humanize-writing-skill</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52d6087595d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Runtime i18n for Angular, done right: @ngx-runtime-i18n]]></title>
            <link>https://levelup.gitconnected.com/runtime-i18n-for-angular-done-right-ngx-runtime-i18n-d8922f92a327?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8922f92a327</guid>
            <category><![CDATA[i18n]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[localization]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Mon, 27 Oct 2025 11:09:17 GMT</pubDate>
            <atom:updated>2025-10-31T01:36:58.586Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UUD4bB1H1dlT35vW-Yzyqw.png" /></figure><p>Internationalisation in Angular tends to force a hard choice:</p><ul><li><strong>Angular built-in i18n</strong> is compile-time only — great for static text and AOT perf, but it forces <strong>one build per locale</strong>, complicates deployments, and doesn’t help when strings must come from a CMS or need to change without a rebuild.</li><li><strong>Legacy runtime libs</strong> (e.g., ngx-translate) solved “switch language at runtime,” but many apps hit pain around <strong>SSR/hydration</strong>, <strong>change detection churn</strong>, bundle size, and the lack of a <strong>signals-native</strong> API.</li></ul><p>@ngx-runtime-i18n Is a tiny, modern alternative that embraces Angular’s current primitives (signals, standalone, SSR/TransferState) while keeping the API intentionally small and ergonomic.</p><h3>What’s in the box?</h3><p><strong>@ngx-runtime-i18n/core</strong> — framework-agnostic primitives:</p><ul><li>Tiny, dependency-free <strong>ICU-lite</strong> formatter (string interpolation + plural with one/other and exact =0, =2, …).</li><li>Shared types used by the Angular wrapper.</li></ul><p><strong>@ngx-runtime-i18n/angular</strong> — Angular integration:</p><ul><li><strong>Signals-first </strong><strong>I18nService</strong> with a minimal surface (lang(), ready(), t(), setLang()).</li><li><strong>I18nPipe</strong> That’s impure by design, but <strong>doesn’t write during render</strong> (avoids NG0600).</li><li><strong>I18nCompatService</strong> (RxJS) for apps that aren’t on signals yet.</li><li><strong>SSR-aware</strong>: TransferState snapshot on the server; hydration-safe on the client.</li><li><strong>Cancellation-aware</strong> language switching (rapid toggles won’t corrupt state).</li><li><strong>Lazy Angular locale data</strong> per language to power date/number pipes as you switch.</li></ul><h3>Quick start</h3><pre>npm i @ngx-runtime-i18n/angular @ngx-runtime-i18n/core</pre><p>Provide the library once at app bootstrap:</p><pre>// app.config.ts<br>import { ApplicationConfig } from &#39;@angular/core&#39;;<br>import { provideRouter } from &#39;@angular/router&#39;;<br>import { provideRuntimeI18n } from &#39;@ngx-runtime-i18n/angular&#39;;<br>import { appRoutes } from &#39;./app.routes&#39;;<br><br>export const appConfig: ApplicationConfig = {<br>  providers: [<br>    provideRouter(appRoutes),<br>    provideRuntimeI18n(<br>      {<br>        defaultLang: &#39;en&#39;,<br>        supported: [&#39;en&#39;, &#39;hi&#39;, &#39;de&#39;],<br>        fetchCatalog: (lang, signal) =&gt;<br>          fetch(`/i18n/${lang}.json`, { signal }).then((r) =&gt; {<br>            if (!r.ok) throw new Error(`Failed to load catalog: ${lang}`);<br>            return r.json();<br>          }),<br>      },<br>      {<br>        // Optional niceties<br>        localeLoaders: {<br>          en: () =&gt; import(&#39;@angular/common/locales/global/en&#39;),<br>          hi: () =&gt; import(&#39;@angular/common/locales/global/hi&#39;),<br>          de: () =&gt; import(&#39;@angular/common/locales/global/de&#39;),<br>        },<br>        options: {<br>          autoDetect: true,                 // first boot: SSR → persisted → navigator → default<br>          storageKey: &#39;@ngx-runtime-i18n:lang&#39;,<br>          preferNavigatorBase: true,        // map en-GB → en if only base exists<br>        },<br>      }<br>    ),<br>  ],<br>};</pre><p>Use it in templates:</p><pre>&lt;h1&gt;{{ &#39;home.title&#39; | i18n }}&lt;/h1&gt;<br>&lt;p&gt;{{ &#39;home.greeting&#39; | i18n:{ name: user.name, count: unreadCount } }}&lt;/p&gt;</pre><p>Or imperatively:</p><pre>import { inject } from &#39;@angular/core&#39;;<br>import { I18nService } from &#39;@ngx-runtime-i18n/angular&#39;;<br><br>const i18n = inject(I18nService);<br><br>if (i18n.ready()) {<br>  console.log(i18n.t(&#39;cart.items&#39;, { n: 2 }));  // “2 items”<br>}<br><br>await i18n.setLang(&#39;de&#39;);                        // cancels in-flight requests safely</pre><p>Not on signals? Use the RxJS-backed compatibility service:</p><pre>import { I18nCompatService } from &#39;@ngx-runtime-i18n/angular&#39;;<br><br>i18nCompat.ready$.subscribe((ready) =&gt; ...);<br>i18nCompat.lang$.subscribe((lang) =&gt; ...);<br>i18nCompat.t$(&#39;home.title&#39;).subscribe((text) =&gt; ...);<br>await i18nCompat.setLang(&#39;hi&#39;);</pre><h3>Why this library exists (and what it optimises for)</h3><ol><li><strong>Runtime first: </strong>Load catalogs from anywhere (public JSON, CMS, API), switch languages without rebuilding, and keep deployments simple.</li><li><strong>SSR &amp; hydration, handled: </strong>The initial catalogue and locale are snapshotted on the server via TransferState and read on the client without double-fetches or hydration warnings.</li><li><strong>Signals-native ergonomics: </strong>The I18nPipe is intentionally impure but read-only, and I18nService.lang is a signal you can depend on anywhere. No global zone churn, no manual change detection spelunking.</li><li><strong>Small surface area: </strong>A tiny core formatter and a focused Angular wrapper. No magical globals, no deep DI hierarchies, no heavy runtime.</li><li><strong>Pragmatic ICU: </strong>Most apps don’t need the full ICU matrix on day one. The core ships an ICU-lite that does the 95%: interpolation and plural basics. Full ICU is on the roadmap (see below).</li><li><strong>Cancellation &amp; race-safety: </strong>Rapid toggles (en → de → hi → en) don’t corrupt the active catalog. The library wires AbortSignal through your fetchCatalog to cancel stale requests.</li></ol><h3>Real-world usage patterns</h3><p><strong>Feature-level catalogs (split by route)</strong></p><pre>// feature.routes.ts<br>{<br>  path: &#39;&#39;,<br>  providers: [<br>    provideRuntimeI18n(<br>      { defaultLang: &#39;en&#39;, supported: [&#39;en&#39;, &#39;hi&#39;],<br>        fetchCatalog: (lang, signal) =&gt; fetch(`/i18n/feature.${lang}.json`, { signal }).then(r =&gt; r.json())<br>      }<br>    ),<br>  ],<br>  loadComponent: () =&gt; import(&#39;./feature.component&#39;),<br>}</pre><p>Feature areas can ship their own keys to keep catalogues small and clearly owned.</p><p><strong>Multi-tenant or brand overlays</strong></p><pre>// merge base + tenant overrides before returning<br>fetchCatalog: async (lang, signal) =&gt; {<br>  const [base, tenant] = await Promise.all([<br>    fetch(`/i18n/base.${lang}.json`, { signal }).then(r =&gt; r.json()),<br>    fetch(`/i18n/${tenantId}.${lang}.json`, { signal }).then(r =&gt; r.json()),<br>  ]);<br>  return deepMerge(base, tenant);<br>}</pre><p><strong>Server-prefetch with </strong><strong>TransferState</strong></p><p>During SSR, hit your CMS/API directly, then stash the result:</p><pre>import { makeStateKey, TransferState } from &#39;@angular/core&#39;;<br>const STATE_KEY = makeStateKey&lt;Record&lt;string, unknown&gt;&gt;(&#39;i18n:en&#39;);<br><br>provideRuntimeI18n(<br>  {<br>    defaultLang: &#39;en&#39;,<br>    supported: [&#39;en&#39;, &#39;de&#39;],<br>    fetchCatalog: async (lang, signal) =&gt; {<br>      if (isServer) {<br>        const cat = await cms.fetch(lang, { signal });<br>        transferState.set(STATE_KEY, cat);<br>        return cat;<br>      }<br>      return transferState.get(STATE_KEY, null) ?? fetch(`/i18n/${lang}.json`, { signal }).then(r =&gt; r.json());<br>    },<br>  }<br>);</pre><p>The library will read the snapshot on the client and avoid a duplicate request.</p><h3>Under the hood (implementation notes)</h3><ul><li><strong>No writes during render</strong>: the pipe only reads lang() to establish reactivity; the actual translation work is pure.</li><li><strong>Missing-key hygiene</strong>: in dev mode, warnings are de-duplicated per key.</li><li><strong>Config tokens</strong>: a small set of injection tokens wires config, catalogs store, locale loaders, and options cleanly (RUNTIME_I18N_CONFIG, RUNTIME_I18N_CATALOGS, RUNTIME_I18N_LOCALE_LOADERS, RUNTIME_I18N_OPTIONS).</li><li><strong>Locale data</strong>: opt-in per language with localeLoaders So date/number pipes switch correctly without bundling every locale.</li><li><strong>Compat layer</strong>: I18nCompatService Mirrors the signals API with RxJS for gradual migrations.</li></ul><h3>Roadmap</h3><p><strong>Short-to-mid term:</strong></p><ul><li><strong>Full ICU message syntax</strong></li><li><strong>Dev tooling</strong>: key extraction, dead-key detection, and catalogue linting.</li><li><strong>First-class CMS adapters</strong> (filesystem, HTTP, popular headless CMS).</li><li><strong>Schematics/Generators</strong>: generate per-feature catalog scaffolds and locale-data wiring.</li><li><strong>Language negotiation</strong> improvements (regional fallbacks, custom mappers).</li><li><strong>Runtime devtools</strong>: overlay to inspect keys, active catalog, and missing translations at a glance.</li></ul><p><strong>Longer-term explorations:</strong></p><ul><li><strong>Message compilation</strong> to speed hot paths for large catalogs.</li><li><strong>Polyglot mode</strong>: capability to compose multiple sources (base + module + A/B experiment layer) with predictable precedence.</li></ul><h3>Where the library stands today</h3><ul><li><strong>Core and Angular packages are production-ready</strong> for apps that need runtime i18n with SSR correctness and a signals-native API.</li><li><strong>ICU-lite</strong> covers the majority of practical cases (interpolation + plural basics). If you need the full ICU grammar across the board, keep an eye on upcoming minors.</li><li><strong>Demos</strong> include both CSR and SSR apps to showcase recommended setups (public JSON catalogs, locale loaders, auto-detect + persist).</li></ul><h3>Adoption checklist</h3><ol><li>Install @ngx-runtime-i18n/angular and @ngx-runtime-i18n/core.</li><li>Provide it once at bootstrap; wire a fetchCatalog and optional localeLoaders.</li><li>Create public/i18n/en.json (and friends).</li><li>Replace template calls with | i18n and imperative usages with i18n.t(…).</li><li>If needed, start on I18nCompatService (RxJS) and migrate to signals over time.</li></ol><h3>Closing thoughts</h3><p>If your app needs <strong>runtime</strong> language switching, <strong>SSR correctness</strong>, and <strong>modern Angular ergonomics</strong>, you shouldn’t have to glue together a bag of tricks. @ngx-runtime-i18n tries to be that slim, boringly-reliable layer that “just works,” while leaving room for your catalogs to come from anywhere and evolve independently of deploys.</p><p>Feedback, issues, and PRs are welcome.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8922f92a327" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/runtime-i18n-for-angular-done-right-ngx-runtime-i18n-d8922f92a327">Runtime i18n for Angular, done right: @ngx-runtime-i18n</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I rewired a tiny Next.js site so search actually likes it: The 2025 Next.js SEO Playbook]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">This weekend, I optimised a Next.js (App Router) project into something search engines understand and social platforms preview nicely</p><p class="medium-feed-link"><a href="https://levelup.gitconnected.com/i-rewired-a-tiny-next-js-site-so-search-actually-likes-it-the-2025-next-js-seo-playbook-f9c394d9d930?source=rss-6382b37e6343------2">Continue reading on Level Up Coding »</a></p></div>]]></description>
            <link>https://levelup.gitconnected.com/i-rewired-a-tiny-next-js-site-so-search-actually-likes-it-the-2025-next-js-seo-playbook-f9c394d9d930?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9c394d9d930</guid>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[seo]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Sun, 31 Aug 2025 10:24:09 GMT</pubDate>
            <atom:updated>2025-09-01T02:32:21.448Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Dynamic Theming using Angular Material]]></title>
            <link>https://levelup.gitconnected.com/dynamic-theming-using-angular-material-c0b7dc7a12d4?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0b7dc7a12d4</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[angular-material]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Mon, 26 Apr 2021 08:26:35 GMT</pubDate>
            <atom:updated>2021-04-28T14:21:07.880Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*stOukK_jMBWA84pcesjWMg.jpeg" /></figure><p>A while back, I was working on a project that used Angular for the UI and Angular Material for the UI components. And that got me thinking — what if I could allow the user to choose a light or dark theme for the application?</p><h3>First things first: Create the Application</h3><p><em>Skip this part if your app is already created</em></p><p>You know the drill. To create the app, run the ng new command in your Terminal. Before executing the application creation process, the Angular CLI asks you a few questions, the last of which is the stylesheet format to be used. Since we need to use mixins(more on that later), choose SCSS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*RGsOyB7-kA1NUKhIdFiLXg.png" /><figcaption>Pick SCSS as the stylesheet format</figcaption></figure><p>Once that’s done, the Angular CLI proceeds with creating the application.</p><h3>Add Angular Material to the project</h3><p>Since we’re using Angular Material as the UI component library, we need to add it to the project first. For this, browse into the project directory and run the following command</p><pre>ng add @angular/material</pre><p>Once again, the CLI gives you a list of prompts. Feel free to respond with any option you desire.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*VNJNvvQJP3liQ9z1rz4MdA.png" /><figcaption>ng add @angular/material</figcaption></figure><h3>Now, the real deal</h3><p>Let’s look at how we can implement dynamic theming in our application. For this, we’ll be using the concept of mixins to firstly custom theme based on the themes provided by Angular Material.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f67e647b43933ffe8787ffdf76d3806/href">https://medium.com/media/8f67e647b43933ffe8787ffdf76d3806/href</a></iframe><p>Okay, a lot of things happened there. Let’s look at it all in detail and understand what is going on.</p><p>Firstly, we import ~@angular/material/theming and include mat-core(). This is so that all the default Material design stylings get copied to the theme we define.</p><p>Nest, we define the colour palettes for our themes. Going by Angular Material’s scheme, we need a primary colour and an accent colour. For defining a primary and accent colour for the theme, we use the mat-palette method. As you can see, it’s recommended that multiple shades of the colour be defined for the accent colour. Once the colours are defined, we define the theme itself and since this is the light theme, we use the mat-light-theme method to define the theme. Finally, we add the theme to the application using include.</p><p>Once the default theme is set, we define the alternate theme, in our case the dark theme. The only major difference here is that we use include within a class, which I am calling dark-theme. We do this so that the dark theme is applied only when the dark class is applied to the application.</p><p>Behind the scenes, the mat-light-theme and mat-dark-theme methods control things such as the colour of UI elements — for instance when the mat-light-theme is used, the mat-card component will have a white colour, while it’ll get a dark grey shade when mat-dark-theme is used.</p><p>That should take care of most of the things, except the theming of what are known as overlay components, such as mat-dialog, mat-snackbar, etc. For this, we need to set the application theme at a module level, as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ec2dfcb26a2a7c1d056374fb4b8d309/href">https://medium.com/media/3ec2dfcb26a2a7c1d056374fb4b8d309/href</a></iframe><p>Note that we have hard-coded the theme name statically. We’ll make it dynamic in later steps.</p><h3>The theme service</h3><p>Now that the styles and themes are in place, we need to create a service to control the app theme. Why a service? Because it fits our bill — unlike components, only a single instance of a service is created, meaning that we have a central control on the theme. Let’s use the Angular CLI for creating the service. Browse into the project directory and run the following command:</p><pre>ng g s theme </pre><p>To the service, add the following bit of code</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/73db3d25ab6d95585634b59771cde6ba/href">https://medium.com/media/73db3d25ab6d95585634b59771cde6ba/href</a></iframe><p>As you can see, we have declared an enum with our theme names so that we don’t have to spell it out over and over again, at the risk of misspelling it. Next, we declare a variable where we store the current theme(currentTheme) and a <a href="https://rxjs-dev.firebaseapp.com/guide/subject">Subject</a> that will emit the current theme as and when it changes(currentThemeSubject). Next, we declare two methods — one for toggling the theme(toggleTheme) and one for returning the theme subject as an <a href="https://rxjs-dev.firebaseapp.com/guide/observable">Observable</a> that the application can listen to(getTheme).</p><p>As mentioned earlier, now we have to make the theme on the module dynamic. To achieve this, make the following updates to the code we added earlier.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c136788203c2c0f5182466a64f974eaf/href">https://medium.com/media/c136788203c2c0f5182466a64f974eaf/href</a></iframe><p>And now, the only thing left for us to do? Apply the dark theme conditionally to the application. For this, we go to the App component. We start by adding the necessary code to app.component.ts .</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2acda79af00b756a2c9ec286149dc15/href">https://medium.com/media/d2acda79af00b756a2c9ec286149dc15/href</a></iframe><p>And in the app.component.html file, we add a wrapping div around all the content.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d0dbcaf068eb80adc46c5fd27dd3f5a/href">https://medium.com/media/3d0dbcaf068eb80adc46c5fd27dd3f5a/href</a></iframe><p>That’s it. You should now have an Angular application that has a dynamic theme, with the theme colours custom-defined by you. All you need to do now is add some sort of control, like say, a toggle button that allows you to switch themes, which you can wire up to the toggleTheme method in the Theme service.</p><p>I hope you liked that story, and are a little smarter than you were when you started reading this story.</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0b7dc7a12d4" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/dynamic-theming-using-angular-material-c0b7dc7a12d4">Dynamic Theming using Angular Material</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Shorter import paths in Angular]]></title>
            <link>https://levelup.gitconnected.com/shorter-import-paths-in-angular-8141734090e4?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/8141734090e4</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Sat, 10 Apr 2021 20:15:28 GMT</pubDate>
            <atom:updated>2021-04-20T03:21:18.358Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sw4IeaqAWhbcYPU49fFk0A.png" /></figure><p>Imports in Angular applications can get messy, particularly in ones that have a very nested structure. While a nested project directory structure has many benefits that make it much better than a flat structure, relative and/or absolute import paths in such cases can be agonizingly long. For instance, consider the following project directory.</p><h3>The Problem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/285/1*u0dByPS1EeVfhWuS7FJ32Q.png" /></figure><p>Neat, wouldn’t you say? Now consider that you wish to import and inject the SharedService exported out of them shared.service.ts into the AdminDashboardComponent in admin-dashboard.component.ts. The import statement would look something like this:</p><pre>import { SharedService } from ‘../../../shared/services/shared.service’;</pre><p>In an even bigger and more complicated application, it could have been longer. Granted, our robust text editors, VSCode in my case, mostly takes care of the imports but even if that happens, the code’s readability drops considerably when such long relative paths are included.</p><p>And that brings up the question — is there a way to make the imports paths more elegant, and yes, shorter? (Cue the drumrolls…) Yes. There is — and not even a hack but one that’s provided for natively. Let’s find out how.</p><h3>The Solution</h3><p>tsconfig.json is a file present in the root of the project directory and critical to every Angular project. As you can figure from the name, and also from its contents, if you have checked it out, this file defines a lot of configurations necessary for the application. And this is where we’ll make the setup for enabling shorter import paths.</p><p>What we need to do is add a key called <a href="https://www.typescriptlang.org/tsconfig#paths">paths</a> into the compilerOptions array. Here, Typescript allows us to define path aliases for use across the project. Behind the scenes, what essentially happens is when the project is compiled, wherever the path aliases defined in the paths array appear in the code, the compiler will replace it with the actual path. The value for paths will be an object containing key-value pairs of actual paths and aliases. Let’s look at the steps using an example.</p><p>Consider the very problem we discussed up top(SharedService import). Here’s a way(yes, it’s a way, not THE way) to do it</p><ol><li>At the root of the shared folder, add a new file called index.ts(feel free to name it anything, so long as it’s a TS file).</li><li>In index.ts, add the following line<br>export { SharedService } from ‘./services/shared.service’;</li><li>Now, open tsconfig.json and in compilerOptions, add the following line<br>“paths”: { “@blog/shared”: [“src/app/shared”] }</li><li>After this is done, go to admin-dashboard.component.ts and the import can be updated as follows<br>import { SharedService } from ‘@blog/shared’;</li></ol><p>That’s it! Doesn’t that look much better? Obviously, you can name the path aliases(the keys in paths object) can be anything at all(even the @ in that is a personal choice and not syntax), as long as the values specify the correct absolute paths with respect to the project root directory.</p><p>Since we are leveraging a Typescript feature here, this can be done for any Typescript project that follows a modular structure, including but not limited to NestJS projects.</p><p>I hope that this story helped you.</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8141734090e4" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/shorter-import-paths-in-angular-8141734090e4">Shorter import paths in Angular</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unsubscribing in Angular, the right way]]></title>
            <link>https://levelup.gitconnected.com/unsubscribing-in-angular-the-right-way-6ed82be43ccc?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ed82be43ccc</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[subscription]]></category>
            <category><![CDATA[asynchronous]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Fri, 05 Feb 2021 09:45:30 GMT</pubDate>
            <atom:updated>2021-04-20T03:22:16.079Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kh36dX-r9FGmTYhVzC44HQ.png" /></figure><p>Once you get a hold of it, event-driven implementations using RxJS go a long way in making your Angular app dynamic. Even if you’re in your early days of using Angular, it’s highly recommended that you make use of Observables, Subjects, Subscriptions, etc. in your application to get the best out of the app. That said, if not done right, RxJS implementation can come back to you haunt you in the form of performance drops for your applications. And one of the top things even developers who have been into Angular for a while may get wrong is the concept of unsubscribing and how best to do it. That’s what we’ll be exploring in this post.</p><h3>Is unsubscribing necessary in the first place?</h3><p>Absolutely. Granted, your observables and subscriptions will work just fine even if you don’t with the whole unsubscribing business. To the untrained eye, particularly in a small-ish application, everything may look good. Let me try and explain with a real-life analogy what unsubscribing can entail.</p><p>Consider that you’re at a restaurant. Before the meal comes in, you decide to wash your hands. You go to the washroom, turn the tap on, and press the soap dispenser. For some reason, the soap dispenser stays in the pressed down position and soap keeps dripping out. You wash your hands, and decide to leave the tap open — what’s the harm, someone will eventually come and close the tap and also fix the soap dispenser. Minutes later, when you’re enjoying your meal, or even an hour later when you’ve finished your <em>filet mignon</em>, left a handsome tip and stepped out, the tap in the washroom is still letting water out and so is the unchecked soap dispenser. See where I am going with this?</p><p>Although you never saw it, a lot of water was lost, and so was a lot of soap. There’s even a fair chance that the drain may get clogged up leading to a messy situation. This is pretty much what’d happen if you leave your observables open and unsubscribed after use. Unchecked memory leaks will happen during application runtime and may lead to issues although on the outside, at least for the initial part at least, you may be blissfully ignorant of the trouble to come.</p><p>To see this in action, subscribe to an observable in a component and keep logging the data from the observable. You’ll see that the logging will carry on.</p><blockquote><em>The component will get destroyed but the subscription will live on</em></blockquote><p>More logs will keep getting added to the browser console. More so, if we navigated back to the original route. The component would get recreated together with a new subscription. That’s why it’s absolutely critical that after use, observables be unsubscribed from, to relieve the subscription the application has placed on it to track some update.</p><blockquote>Angular, being the robust framework it is, internally takes carte of unsubscribing from implicitly created observables such as HTTP calls, async pipes, etc. The Observables and Subscriptions which we create however, we have to unsubscribe from them explicitly.</blockquote><p>With that out of the way, let’s looks ta various ways to unsubscribe from an observable(yes, there’s more than one way).</p><h3>Method 1: The Manual Way using <em>unsubscribe()</em></h3><p>This is the most commonly used method, the one that we teach beginners getting started on Observable and Subscriptions.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/beb51f1030f42adc45fdb760f29e5072/href">https://medium.com/media/beb51f1030f42adc45fdb760f29e5072/href</a></iframe><p>Not much rocket science is happening here, as can be seen. All we do in this method is calling unsubscribe on the Subscription if it’s defined, as and when the component is destroyed. Simple, and gets the job done for the most part.</p><p>Now imagine that your component has many such subscriptions, it can quickly become quite a process to ensure everything gets unsubscribed when the component is destroyed, not to mention the fact that the <em>ngOnDestroy</em> function will be a lot more lines longer. This is where we need a better approach and that’s where the next method comes in.</p><h3>Method 2: Declarative or ‘automatic’ using takeUntil()</h3><p>According to the official docs,</p><blockquote><em>takeUntil(notifier: Observable&lt;any&gt;) — Emits the values emitted by the source Observable </em><strong><em>until</em></strong><em> a </em><em>notifier Observable emits a value.</em></blockquote><p>In simple words, we can use the takeUntil operator to make subscriptions smarter by passing a boolean-typeobservable to it. Once we follow this method, all we ned to do in the OnDestroy method is make the observable truthy and unsubscribe from it alone, which will, in turn, stop all the subscriptions handled in this manner. Check out the following example implementation.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a243d97fe4d15ea8d93f390606f24c5e/href">https://medium.com/media/a243d97fe4d15ea8d93f390606f24c5e/href</a></iframe><blockquote>Is this method the silver bullet for the whole unsubscribe issue? Not quite.</blockquote><p>As much as it’s effective, it has downsides and gotchas of its own.</p><ol><li>It’s verbose, what with the need to declare a Subject to use as a notifier for the <em>takeUntil</em> method</li><li>There are a fair few things that you can mess up, such as but not limited to forgetting to make either or both of the <em>next()</em> and <em>unsubscribe()</em>(or <em>complete()</em>) calls on our notifier subject, or forgetting to implement the OnDestroy method itself, to name a couple.</li><li>Special care has to be taken to ensure that in case you’re using some other operators like <em>map()</em>, <em>filter()</em>, etc. inside <em>pipe()</em>, <em>takeUntil</em> should be placed last so that all generated observables are handled.</li></ol><h3>Method 3: There’s always the prodigal <em>async</em> pipe</h3><p>Pipes are one of the great things about Angular. As much as custom pipes can be written, the pipes we get out of the box itself are plentiful and one such incredible pipe is the <em>async</em> pipe. This allows you to use observables directly in the template, as shown below</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d59d69624553c30eeaf347cedb7b7239/href">https://medium.com/media/d59d69624553c30eeaf347cedb7b7239/href</a></iframe><p>That this is the most compact solution yet, is a matter-of-fact beyond doubt. And look, no hassles of <em>takeUntil</em>, subscriptions, OnDestroy method, nothing. And yet, this has downsides, a big one in particular.</p><blockquote>Since data is resolved directly in the template, no manipulation can be done on it from the component, but will have to be used as is.</blockquote><p>In conclusion, this is like one of those math problems. There’s no unique method. It all boils down to situation and personal choice, which you develop over time of writing Angular code. That said, <em>takeUntil</em> and <em>async</em> pipe approaches stand shoulder to shoulder, and leaps and bounds ahead on simple unsubscribe(Method 1). Personally, I use the <em>takeUntil</em> method because I like to have the data available in the component just in case.</p><blockquote>After this story was initially published, a few good people cared to take time to respond and pitch in with some inputs and I greatly appreciate the gesture as it helps me improve too. So, here’s a shot out to <a href="https://medium.com/u/63f345744d27">Károly Tranta</a>, <a href="https://medium.com/u/64f874e142e">Mdroz</a>, <a href="https://medium.com/u/54c492106876">Leandro Hereñu</a> and <a href="https://medium.com/u/7ba07cd6dc56">David Adams</a>. Please do chewck out their responses! I also recommend that you check out two other solutions for unsubscribing well in Angular which I have left out of the article — the <a href="https://github.com/ngneat/until-destroy">until-destroy</a> and <a href="https://github.com/wardbell/subsink">SubSink</a>.</blockquote><p>That’s all folks. i hope that you end this read with some better perspective on handling Observable unsubscriptions. Happy Coding!</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ed82be43ccc" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/unsubscribing-in-angular-the-right-way-6ed82be43ccc">Unsubscribing in Angular, the right way</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying your Angular app on Firebase using Github Actions]]></title>
            <link>https://medium.com/analytics-vidhya/deploying-your-angular-app-on-firebase-using-github-actions-b2167af8e0e6?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2167af8e0e6</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[github-actions]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Sat, 30 Jan 2021 08:08:10 GMT</pubDate>
            <atom:updated>2021-04-20T03:22:49.317Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*D6GQetcniO9h-1bhFadUsg.jpeg" /></figure><p>For any Angular developer, amateur or expert, looking for cheap(or free)hosting solutions for their projects, Firebase Hosting is one of the best solutions you have access to — it’s free and the deployment process is really easy. In this post, we’ll look at how Angular apps can be deployed into Firebase hosting automatically when you push your code to Github, using Github Actions.</p><p>Introductions first. <strong>Angular</strong>(NOT AngularJS), a UI framework developed and maintained by the good people from Google and written in Typescript, developed by a few more good people from Microsoft(since you’re here, I’m assuming you already knew that). <strong>Firebase</strong> is an array of cloud solutions provided by Google, with a pretty decent free tier that offers services such as but not limited to static web hosting, real-time database, storage, etc. And finally, Github — the one-stop solution(mostly) for saving your version-controlled code, owned currently by Microsoft. And <strong>Github Actions</strong> is a service that allows you to perform automated functions as and when you interact with your repositories, like pushing commits. With that out of the way, let’s get cracking.</p><h3>Creating the Angular App</h3><p><em>[If your app is already in place, feel free to skip this section]</em></p><p>Assuming that you’ve NodeJS, npm, and Angular CLI setup in your system(check out <a href="https://medium.com/@ashwinsathyan19/setting-up-your-new-mac-for-mean-stack-development-152aaf927133?sk=b914a29ece2d8d9f66866418f092c2a2">this</a> post for some pointers), you can create your new application by running the following command ina Terminal/Command Prompt.</p><p>ng new my-angular-app</p><p>Now, go ahead and build your app.</p><h3>Initialize Firebase in the project</h3><p>Next, we need to initialize Firebase in the project. First, go to <a href="https://console.firebase.google.com/">Firebase Console</a> and sign in using your Google account. Once there, create a new project — the wizard help you with this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EqLo10lOZ1D2luTOy4XZ7Q.png" /><figcaption>Feel free to name you project as you like</figcaption></figure><p>After the project is created, you’ll be taken to the project dashboard. Here, in the left-side menu, click on the gear icon next to Project Overview and select <strong>Project Settings</strong> from the context menu. Once in the Project Settings page, in the General tab, scroll down to the Your Apps section which says Add Firebase to your app, and select the <strong>Web </strong>option</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*tdlgzJLYpkIRfIM-PKcoNQ.png" /><figcaption>Add Firebase to your Web app</figcaption></figure><p>Once you successfully register your web app, you’ll get the Firebase configurations. Copy this and add it to your Angular app’s <em>environment.ts</em> file, after making the necessary formatting changes to make a valid JSON object. Once you&#39;re done, your <em>environment.ts</em> file would like something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f423744331c698e2eda834339c9afe6/href">https://medium.com/media/1f423744331c698e2eda834339c9afe6/href</a></iframe><blockquote>Note: Don’t foget to copy the firebaseConfig object into <strong>environment.prod.ts</strong> file as well</blockquote><p>To initialise Firebase in your project, we can use the Firebase CLI. If you don’t have to already installed, you can do so by running the following command in a Terminal:</p><pre>npm in -g firebase-tools</pre><p>Once installation completes, run the following command</p><pre>firebase init</pre><p>Follow the prompts from the CLI to enable hosting. You may want to enable configuration as a SPA when prompted. Once this step is done, the project is now initialised for Firebase hosting.</p><h3>Enter Github</h3><p>We’re almost done with the work required at the project’s end of things. Now, we have to do some groundwork in Github. Firstly, create a New Repo and give it a name of your choice. Once in, switch tp the <strong>Settings</strong> tab and in it, the <strong>Secrets</strong> sub-section. Here, we need to save the token required for Github to authenticate Firebase during deployment.</p><p>But first, we need to generate such a token. For this, we can use Firebase CLI. Run the following command in Terminal to generate your token</p><pre>firebase login:ci</pre><p>Your browser window will now open up, asking you to login. Use the account you used to login to Firebase. Once login succeeds, close the browser window. If you check the terminal, you’ll see that a token has been generated for you. Copy this token. We’ll be using it shortly.</p><p>Back in Github, click on New repository secret. Name it FIREBASE_TOKEN and set the value to the token you copied, and save it. If done properly, your screen will now looks something like this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B4aoQI_cLDpO13zmymB2HQ.png" /></figure><p>Now, it’s time to define the Action that’ll automatically deploy your application on pushing to Github. Switch to the Actions tab and here, click on the link that says <strong>set up a workflow yourself</strong>. This opens up an editor windows with a file <em>main.yml</em> open. Replace the contents of the file with the following code. Ensure that the alignment and indentation is maintained since <em>.yml </em>file executions depend strictly on indentation.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5b652990cf7f19f4373a2a584ea486c/href">https://medium.com/media/e5b652990cf7f19f4373a2a584ea486c/href</a></iframe><h3>Okay, what was all that pig-latin?</h3><p>If you’ve ever written any amount of code at all, that might not all be pig-latin. But let’s examine it nevertheless. To start with, if you had noticed, we kept the code that was already in the file and just added some more from our side, specifically, the section starting with <em>deploy.</em></p><p>What we have essentially done here is</p><ol><li>Defined a new job called <em>deploy</em>. This, and all other items under jobs, namely <em>build</em>, in this case, will execute as and when the condition defined in the <em>on</em> section is met; i.e. code is pushed or a pull request is merged into the master branch of our repository.</li><li><em>deploy</em> is set to first checkout the code from master and use a node environment, with a node version of our choice — in this case, 14.15.</li><li>Next, we install all dependencies of the project using npm install since node_modules isn’t pushed into the repo.</li><li>Once the packages are installed, we run a script to build our app for production. I have, in my project’s <em>package.json</em> file defined a script called buildProd as follows<br><em>“buildProd”: “ng build — prod”</em></li><li>On the success of the build process, we deploy the application to firebase using <a href="https://github.com/w9jds/firebase-action">this</a> action from the Girhib Actions Marketplace. We specify deploy as the task to be done, and need to pass the token for authenticating it, which we fetch from the Secret we stored in our repo earlier, as <em>secret.FIREBASE_TOKEN</em>, similar to how environment variables are accessed in Node environments.</li></ol><p>And that’s it. This repo is now set to build and deploy the application into Firebase as and when you push code or merge a pull request. Test this out by pushing your code to to your Github repo. Wait for the Action to run. Now, if you browse to the hosting URL from Firebase Hosting dashboard, you’ll see your application up and running!</p><p>If you liked that post, do show your support with a few claps. For more such posts, follow me. Happy coding!</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2167af8e0e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/analytics-vidhya/deploying-your-angular-app-on-firebase-using-github-actions-b2167af8e0e6">Deploying your Angular app on Firebase using Github Actions</a> was originally published in <a href="https://medium.com/analytics-vidhya">Analytics Vidhya</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Tale of Two Copies]]></title>
            <link>https://levelup.gitconnected.com/a-tale-of-two-copies-bb4f8ab64c1a?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb4f8ab64c1a</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[es6]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Fri, 24 Jul 2020 12:19:11 GMT</pubDate>
            <atom:updated>2021-04-20T03:23:26.250Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*ZgAxmE7hqE2D1s8Ut63Rmw.png" /></figure><p>Let’s face it — Javascript is a funny language, to say the least. And the internet is filled with articles articulating this. But it’s simple, powerful and ubiquitous, and learning a trick or two wouldn’t go amiss. In this article, we’ll be discussing a tricky bit in Javascript — copying.</p><p>Consider two variables <strong>a</strong> and <strong>b</strong>. You have a value stored in <strong>a</strong>, which you wish to copy into <strong>b</strong>. This can be done as follows</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ddc6822623ca28cec9a9ce49906b77e7/href">https://medium.com/media/ddc6822623ca28cec9a9ce49906b77e7/href</a></iframe><p>Now you might be wondering what was the point of showing that, for that was obvious. Bear with me. This method holds true so long as <strong>a</strong> and <strong>b</strong> are of primitive data types — string, number, boolean, etc. The above bit of code will copy the value stored in <strong>a </strong>to <strong>b</strong> and then, changes in one won’t affect the other. Again, obvious.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/14a10ce820de76a07db7f53ae54dae20/href">https://medium.com/media/14a10ce820de76a07db7f53ae54dae20/href</a></iframe><p>Let’s take this one step ahead now. What if <strong>a</strong> was say, an array? “Yea, what about it?”, I hear you ask. Logic dictates that this should not make any difference. The array in <strong>a</strong> can be copied into <strong>b</strong> in exactly the same way and changes to<strong>a</strong> won’t affect <strong>b</strong> and vice versa.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/561f095e857f6f79d847908e3264141c/href">https://medium.com/media/561f095e857f6f79d847908e3264141c/href</a></iframe><p>Surprised? I’m sure that at least a couple of you reading this would certainly be. Feel free to try it out and see it for yourself.</p><h3>So, what happened there?</h3><p>This behaviour is a result of the way Javascript works. In JS, Arrays, Objects and Functions(let’s collectively call them Objects, because that’s how JS sees all 3 of them), are treated differently from String, Number, Boolean, Null and Undefined(the Primitives). While the Primitives are passed by value, Objects are passed by reference.</p><p>This essentially means that when we assign a Primitive variable to another Primitive variable, like in our simple copy case, the value stored in one variable is copied into the other and after this copying, they are independent of each other. On the other hand, in case of Objects, when you assign an Object variable to another Object variable, both variables are essentially referring to the same Object in memory — just as how Christiano Ronaldo and CR7 refer to the same individual.</p><p>It’s because of this pass by reference nature of objects that we saw the arrays from the above code snippet behave the way did. When we work on <strong>a</strong> or <strong>b</strong>, we are effectively working on the same array, referred by using different names.</p><p>It’s also worth noting that JS is not exclusive in this behaviour — Typescript, which is essentially a superset of JS, shows the same behaviour. So does Python.</p><h3>What’s the solution?</h3><p>Time and again, situations might arise when you need to copy an Object-type variable and not end up altering the source variable while working on the copy and vice versa.</p><h3>Enter Spread …</h3><p>Introduced in ECMAScript 6(ES6), the spread operator(<strong>…)</strong> solves this very problem. Using the spread syntax, you can extract the value of an Object, which can subsequently be copied into another variable.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c05900fca1bbcaab3041401feb9865df/href">https://medium.com/media/c05900fca1bbcaab3041401feb9865df/href</a></iframe><p>As can be seen from the above code snippet, once we use the spread syntax to copy Objects, changes in one variable don’t affect the value stored in the other and vice versa. What has essentially happened here is that by extracting and copying the value of <strong>a</strong> to <strong>b</strong>, we ensured that both <strong>a</strong> and <strong>b</strong> are not referring to the same Object in memory.</p><h3>Yay! We’re sorted — not so fast</h3><p>As much as spread operator is a lifesaver as far as copying Objects go, there is a catch and a big one at that. Consider the following piece of code</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4fadb5576c95d39fadee6580ed37cff3/href">https://medium.com/media/4fadb5576c95d39fadee6580ed37cff3/href</a></iframe><p>Looks like we still have problems after all.</p><p>As you can see, despite using the spread operator to copy the value of <strong>a</strong> to <strong>b</strong>, changes to <strong>johnMarks</strong> affected the <strong>marks</strong> field for both <strong>a</strong> and <strong>b</strong>. This happens because the copying done by means of the spread operator is what is known as a ‘shallow copy’.</p><p><strong>Shallow Copy</strong> is one where while copying an Object, we copy values of the main Object but pass the reference of Objects within it to the copy. Thus, in our case, both <strong>a</strong> and <strong>b</strong> store a reference to the same <strong>johnMarks</strong> Object. What we need in such cases, is a ‘deep copy’.</p><p>In a <strong>deep copy</strong>, values of the Object, as well as those of Objects within it are copied out, meaning that if we deep copy <strong>a</strong> to <strong>b</strong>, the <strong>marks</strong> field will hold the value of <strong>johnMarks</strong> and not a reference to it.</p><h3>How to perform a deep copy?</h3><p>While various ways exist to perform a deep copy in Javascript, including creating a custom function that could maybe recursively do a shallow copy to emulate a deep copy, I usually go with a simple yet effective method. All we need are two methods already available to us out of the box.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c3a0bc2005160beb020083f898764a37/href">https://medium.com/media/c3a0bc2005160beb020083f898764a37/href</a></iframe><p>And there you have it — a neat deep copy performed by combining the <strong>JSON.parse()</strong> and <strong>JSON.stringify()</strong> methods. What is happening here is that first a string is constructed out of the source Object, which is then used to create a new Object that gets stored in the second variable.</p><p>Note that while using this method for deep copying, ensure that the objects involved conform to <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON">JSON conventions</a>, to avoid unexpected errors. If they do not, you may have to look at other methods such as perhaps a custom function, as already mentioned.</p><p>That’s it then. In this article, we looked at the need for copying in Javascript, two different copying styles and a method each for implementing the copying styles. The methods illustrated and/or mentioned are by no means an exhaustive list, but simply methods I personally favour.</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb4f8ab64c1a" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/a-tale-of-two-copies-bb4f8ab64c1a">A Tale of Two Copies</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular Tutorial: Building a Postman clone — Part 2]]></title>
            <link>https://faun.pub/angular-tutorial-building-a-postman-clone-part-2-eb6fc96631e?source=rss-6382b37e6343------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb6fc96631e</guid>
            <category><![CDATA[indexeddb]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Ashwin Sathian]]></dc:creator>
            <pubDate>Sun, 05 Jan 2020 19:07:22 GMT</pubDate>
            <atom:updated>2021-04-20T03:24:22.664Z</atom:updated>
            <content:encoded><![CDATA[<h3>Angular Tutorial: Building a Postman clone — Part 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gPqL5V7Rur21LCzTgyfrQQ.png" /><figcaption>API Sandbox</figcaption></figure><p>In the first part of this tutorial, we achieved the following:</p><ul><li>Project Setup</li><li>Building the basic functionality of sending requests and receiving responses for GET and POST REST API endpoints</li><li>Attach custom request body to POST requests</li></ul><p>If you still haven&#39;t read Part 1, it’s strongly recommended that you do so before proceeding</p><p><a href="https://medium.com/@ashwinsathyan19/angular-tutorial-building-a-postman-clone-part-1-1727d815b0d3">Angular Tutorial: Building a Postman clone — Part 1</a></p><p>In this second and final part of the tutorial, we’ll build on our application and add two more functionalities:</p><ul><li>Attach custom Headers to the API requests</li><li>Saving and loading past requests so that they may be reused</li></ul><h3>Attach custom Headers to the API requests</h3><p>Many times, or in fact more often than not, it’s necessary to attach Headers to API requests for purposes such as Authentication, like ‘<em>x-api-key</em>’. The good news is that the look and functionality of custom headers are very similar to that of the custom request body for POST requests. To start with, let’s add the UI for this functionality and a good place to do so would be as a tab alongside the Body tab. So, we update the section as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c506df8782828d3c9618d1b02d1c9485/href">https://medium.com/media/c506df8782828d3c9618d1b02d1c9485/href</a></iframe><p>As you can see, we start with moving the <em>*ngIf</em> on the section to the tab corresponding to ‘<em>Body</em>’, since request headers may be required in GET or POST requests, unlike request body. Apart from that, the UI is considerably similar and actually simpler than that of the Body tab — here we do not need a data type field — it’s always a key-value pair of string values. We also have provisions to Add and Remove items. Here though, we add a compulsory, non-mutable header for Content-Type — this field can neither be edited nor removed.</p><p>With the UI out of the way, let’s now look at the logic part. To start with, we need to add headers to the wrapper functions we defined in the service. We need to add an extra parameter to both the functions and construct a header using the HttpHeader class supplied by Angular. The completed <em>main.service.ts</em> will now look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ef36016486dfe5243e9042eb893c8722/href">https://medium.com/media/ef36016486dfe5243e9042eb893c8722/href</a></iframe><p>Now that the service is out of the way, it’s time to add the component logic. The good news once again is that we can recycle the functions we made for the custom body, by adding a context parameter to the available functions and returning results or performing actions accordingly. For this, we update <em>api-params.component.ts</em> as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c3f1c60c060f133febe3f275ba4b73b/href">https://medium.com/media/7c3f1c60c060f133febe3f275ba4b73b/href</a></iframe><p>And just like that, we now have the custom request header functionality as well.</p><h3>Saving and Loading Past Requests</h3><p>Our application has now met more than enough requirements to work as a basic API interrogation tool. A good-to-have feature though will be the ability to reuse past requests. This involves two parts — saving the requests we make and being able to load them so that the same request can be made again. This feature has a fundamental requirement for a storage system. SInce for this version of the application, we are keeping it as a pure browser application, the logical choice to choose one of the multiple storage solutions provided by the browser. The most obvious choice would be to use localStorage. However, localStorage is string-based storage. What we ideally need in this case is a JSON object-store. NAd because of this, the better and apter choice will be to use the IndexedDB.</p><p><a href="https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API">IndexedDB API - Web APIs | MDN</a></p><p>To start with, we’ll need a component to display the past requests and load them up from. We create it using the CLI.</p><pre>ng g c past-requests</pre><p>Let’s now layout both the components on the base component, the App component. Once done, it’d look something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4fe3add7ced71bab2f3ba49334887186/href">https://medium.com/media/4fe3add7ced71bab2f3ba49334887186/href</a></iframe><p>What we have to understand at this point is that although most of the modern browsers do, there still are earlier versions of browsers that do not support the IndexedDB API. And since there is no point in having the <em>past-requests</em> component if the browser doesn’t support IndexedDB. Thus, as can be, seen, the layout of the page, as well as the rendering of the <em>past-requests</em> component, is controlled by the <em>hasIndexedDB</em> variable, which we’ll be set to true or false based on the availability fo the API in the browser. This is one aspect of Progressive Web Apps, where we adjust the rendered app according to the provisions of the browser it’s running in.</p><p>The first step at hand is to check whether the browser supports the IndexedDB API and a good place to run the check and set the hasIndexedDB variable would the OnInit method of the App Component.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37c67abeb7084372243c41f57e899ab2/href">https://medium.com/media/37c67abeb7084372243c41f57e899ab2/href</a></iframe><p>As shown, we call the <em>openIndexedDB</em> function from <em>ngOnInit</em>. In the <em>openIndexedDB</em> function, we first check if the browser scope; i.e. <em>window</em> object contains I<em>ndexedDB</em>. If this check succeeds, we attempt to open an instance of the <em>IndexedDB</em>. If this succeeds, the <em>onsuccess</em> handler is triggered and this is the place where we initiate the <em>indexedDB</em> instance and sets the <em>hasIndexedDB</em> variable to true.</p><p>Assuming that the IndexedDB is successfully opened, we need to open an object-store. We can use the <em>createObjectStore</em> method on the <em>indexedDB</em> instance for opening the store, as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/29fcdd39251f83ef0f2f25eb9a422651/href">https://medium.com/media/29fcdd39251f83ef0f2f25eb9a422651/href</a></iframe><p>The method creates a new object-store of the name ‘<em>pastRequests</em>’ or opens the same if it already exists from previous instances of running the application. We have passed two attributes as options to the method. <em>keyPath</em> defines the unique index by which we identify each entry in the store we create/open, while <em>autoIncrement: true</em> automatically adds a new <em>_id</em> to each entry in the store, without us having to manually set it.</p><p>The next step is to save the requests that are made. For this, we move back to the <em>api-params</em> component.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee1fb82c1997a3d72cd18c46092d2fc7/href">https://medium.com/media/ee1fb82c1997a3d72cd18c46092d2fc7/href</a></iframe><p>We have created a function that constructs a <em>requestObject</em> based on the type of request. This object contains elements of the request that we wish to save. Once the object is ready, we initiate a new transaction where we open the created object-store, ‘<em>pastRequests</em>’ in <em>readwrite</em> mode, since we have to write new data. Finally, we add the created <em>requestObject</em> to the <em>pastRequests</em> store. The only things that remain to be done are call the saveRequest function in the <em>sendRequest</em> method.</p><p>Next part is fetching the saved requests to display in our <em>past-requests</em> component. For this, we go back to the <em>app</em> component.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/05e06e81f5857dd33672391f97e01b21/href">https://medium.com/media/05e06e81f5857dd33672391f97e01b21/href</a></iframe><p>Here, we use the <em>getAll</em> method to fetch all the stored requests. The rest of the flow is similar to add a new item to the object-store. We then call this function in the <em>onsucess</em> handler of opening the IndexedDB.</p><p>We now need to add UI and logic in the <em>past-requests</em> component to supply the fetched requests. The template for this would look something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c7c729ae6a35901db05a54194ee62338/href">https://medium.com/media/c7c729ae6a35901db05a54194ee62338/href</a></iframe><p>On the logic part of the component, all we need to do is define an Input to receive th <em>pastRequests</em> array from the <em>app</em> component.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/53e8a6483170efea608a88f95570422d/href">https://medium.com/media/53e8a6483170efea608a88f95570422d/href</a></iframe><p>At this point, we’ll be able to see all the requests we make in this component.</p><p>The last part we need to do is add functionality to load a past request. To do this, we define the click event on any of the listed requests, which emits an event to the <em>app</em> component.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4c39b6a4d4614b77f62b2a20ce608da4/href">https://medium.com/media/4c39b6a4d4614b77f62b2a20ce608da4/href</a></iframe><p>We now need to define a function in the <em>api-params</em> component to load the request. We’ll also be needing a function to deconstruct the headers and body objects into arrays so that they may be displayed right.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fdde277ee07434d7fa04162db7169093/href">https://medium.com/media/fdde277ee07434d7fa04162db7169093/href</a></iframe><p>Since the function is in place, all we need to do is invoke it when a past request is clicked. We can do this in the handler function for the event emitted by the <em>past-requests</em> component. Since <em>api-params</em> component is a child to the app component, we can use the <em>@ViewChild</em> decorator to access it and run the function. The completed App Component would now look as follows:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/64f45d1776d18554273253170749df9b/href">https://medium.com/media/64f45d1776d18554273253170749df9b/href</a></iframe><p>We have now completed our application with all the planned functionalities. You can see teh complete project code in the following Github repository.</p><p><a href="https://github.com/AshSat19/apiSandbox">AshSat19/apiSandbox</a></p><p>You can view the application live in the following link</p><p><a href="https://sandbox.ashwinsathian.com/">API Sandbox</a></p><p>Thank you for reading.</p><blockquote>Interested in having a 1:1 chat with me over this story, or Angular, Typescript and Javascript in general? Head over to <a href="https://www.hiretheauthor.com/ashwinSathian">Hire The Author</a> and let’s connect!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/0*Piks8Tu6xUYpF4DU" /></figure><p><strong>Follow us on </strong><a href="https://twitter.com/joinfaun"><strong>Twitter</strong></a><strong> </strong>🐦<strong> and </strong><a href="https://www.facebook.com/faun.dev/"><strong>Facebook</strong></a><strong> </strong>👥<strong> and </strong><a href="https://instagram.com/fauncommunity/"><strong>Instagram</strong></a><strong> </strong>📷 <strong>and join our </strong><a href="https://www.facebook.com/groups/364904580892967/"><strong>Facebook</strong></a><strong> and </strong><a href="https://www.linkedin.com/company/faundev"><strong>Linkedin</strong></a><strong> Groups </strong>💬<strong>.</strong></p><p><strong>To join our community Slack team chat </strong>🗣️ <strong>read our weekly Faun topics </strong>🗞️,<strong> and connect with the community </strong>📣<strong> click here⬇</strong></p><figure><a href="https://www.faun.dev/join/?utm_source=medium.com%2Ffaun&amp;utm_medium=medium&amp;utm_campaign=faunmediumbanner"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6P3WpLjGv5v1ucm5dgkucg.png" /></a></figure><h4>If this post was helpful, please click the clap 👏 button below a few times to show your support for the author! ⬇</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb6fc96631e" width="1" height="1" alt=""><hr><p><a href="https://faun.pub/angular-tutorial-building-a-postman-clone-part-2-eb6fc96631e">Angular Tutorial: Building a Postman clone — Part 2</a> was originally published in <a href="https://faun.pub/">FAUN.dev() 🐾</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>