<?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 Yunus Emre Salcan on Medium]]></title>
        <description><![CDATA[Stories by Yunus Emre Salcan on Medium]]></description>
        <link>https://medium.com/@yunusemresalcan?source=rss-eedf4987d5df------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*8oA_nux_FZhSo9mS9l29ZQ.jpeg</url>
            <title>Stories by Yunus Emre Salcan on Medium</title>
            <link>https://medium.com/@yunusemresalcan?source=rss-eedf4987d5df------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 14:40:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yunusemresalcan/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[Claude Code Dynamic Workflows: From One Prompt to Your Own AI Team]]></title>
            <link>https://medium.com/@yunusemresalcan/claude-code-dynamic-workflows-from-one-prompt-to-your-own-ai-team-ea9e4fee6434?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea9e4fee6434</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[workflow-automation]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 15:17:52 GMT</pubDate>
            <atom:updated>2026-06-04T15:17:52.155Z</atom:updated>
            <content:encoded><![CDATA[<h3>Claude Code Dynamic Workflows:<br> From One Prompt to Your Own AI Team</h3><h4>How Claude Code’s Dynamic Workflows move AI-assisted development from single-answer generation to process design</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*NBU9NQDDuKOI1fEE" /></figure><p><strong>Executive summary</strong></p><p>Dynamic Workflows allow Claude Code to break complex work into smaller tasks, distribute those tasks across subagents, verify the results, and synthesize a final answer. The result is less like a single coding assistant and more like a task-specific AI teamDynamic Workflows allow Claude Code to break complex work into smaller tasks, distribute those tasks across subagents, verify the results, and synthesize a final answer. The result is less like a single coding assistant and more like a task-specific AI team.</p><h3>Introduction: AI is no longer just answering</h3><p>AI coding tools have long promised to help developers write code faster. First came autocomplete. Then came chat-based coding assistants. More recently, tools moved directly into the terminal, where they can read files, edit code, run commands, and reason across a project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/0*2nY_HqXx4BK_HOT9" /></figure><p>Claude Code’s Dynamic Workflows represent a more interesting shift. The point is not simply that Claude can open a file and write code. The point is that Claude can analyze a large task, split it into smaller jobs, assign those jobs to separate agents, verify the outputs, and then synthesize everything into a clean final result.</p><p>In other words, we are no longer talking about one AI assistant responding to one prompt. We are talking about a temporary, task-specific AI team assembled on demand. That is why Dynamic Workflows feel less like a minor feature update and more like a change in how agentic coding work is organized</p><h3>What is a Dynamic Workflow?</h3><p>A Dynamic Workflow is a task-specific execution structure created inside Claude Code. Instead of keeping the entire plan inside a single chat context, Claude can create a workflow script that defines how the work should be broken down, which subagents should run, how intermediate results should be stored, and how the final answer should be produced.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cIjSCXqEWJRqcRKP" /></figure><p>In a normal Claude Code session, the model thinks, calls tools, edits files, and replies within the same conversation flow. That works well for small and medium-sized tasks. But as the task grows, context becomes noisy, the goal can drift, and the model may fail to challenge its own output hard enough.</p><p>Dynamic Workflows reduce that problem by turning the plan into an executable structure. Each subtask can run in a narrower context, while the main conversation stays cleaner and less overloaded with irrelevant intermediate detail.</p><h3>Why one agent is not always enough</h3><p>For large software tasks, a single agent may look sufficient at first. In practice, long tasks create predictable failure modes. The model may lose track of constraints, skip edge cases, or present partial progress as if the full job were done.</p><p>Three risks are especially important. The first is agentic laziness: the model does part of a large task and then behaves as if it completed all of it. The second is self-preferential bias: the model tends to judge its own solution too kindly. The third is goal drift: over a long task, the original objective slowly shifts or important constraints disappear from attention.</p><p>Dynamic Workflows help reduce these risks by splitting the job into specialized roles. One agent can generate, another can verify, a third can look for false positives, and a final synthesizer can turn the results into a readable report.</p><h3>Per-agent isolation: every agent gets a clean workspace</h3><p>One of the most useful ideas behind Dynamic Workflows is per-agent isolation. Each agent can work in its own narrower context instead of sharing one crowded conversation. This is valuable when analyzing large repositories, where unrelated details can easily contaminate the reasoning process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*EVY2vX3KavSF75kO" /></figure><p>For example, imagine a project-wide authentication and authorization review. One agent can extract all endpoints. Another can inspect whether authentication checks exist. Another can focus on input validation. Another can verify risky findings. A final agent can remove false positives and produce the final report.</p><p>This does not merely make Claude do more work. It makes Claude organize the work into smaller areas of expertise.</p><h3>The 6 core Dynamic Workflow patterns</h3><p>A practical way to understand Dynamic Workflows is through six repeatable patterns. These patterns turn Claude Code from a coding assistant into a system that can design and run different kinds of work processes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*jn3mPsGD4Q3XQnzSTna_Eg.png" /></figure><h3>Classify-and-Act</h3><p>In this pattern, one agent first classifies the incoming task. Based on that classification, the workflow chooses the right next action or routes the job to the right specialist agent. A bug report, for example, can be classified as frontend, backend, security, or performance before the workflow decides what should happen next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/0*OaJTsL_U1nC_Xj6u" /></figure><h3>Fan-out-and-Synthesize</h3><p>A large job is split into many smaller pieces. Each piece is handled by a separate agent, and a synthesis step merges the findings into one coherent result. This is one of the most useful patterns for repository-wide scans and large codebase analysis.</p><h3>Adversarial Verification</h3><p>The goal here is not just to produce an answer, but to challenge it. One agent creates a solution; another agent tries to find flaws, missing evidence, or risky assumptions. This pattern is especially valuable for security, finance, release validation, and technical report review.</p><h3>Generate-and-Filter</h3><p>The workflow first creates a broad pool of options, then filters them against explicit criteria. It is useful for naming, product messaging, CLI design, title generation, and any creative task where quantity must be followed by quality control.</p><h3>Tournament</h3><p>Several agents solve the same problem in different ways. Their solutions are compared, and the strongest approach is selected. This is helpful when there is no single obvious answer, such as architecture decisions, UI tradeoffs, or refactor planning.</p><h3>Loop Until Done</h3><p>Some tasks do not have a known number of steps. This pattern keeps running until a stopping condition is met: tests pass, no new issues are found, or a quality threshold is satisfied.</p><h3>14-step practical checklist</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5PceLeXn1fifydD5B6_xlw.png" /></figure><p>The best results usually come from giving Claude Code a clear frame. This checklist turns Dynamic Workflows into something practical rather than theoretical.</p><h3>Example prompt</h3><p>This prompt does more than ask Claude to ‘check the project.’ It explains how the work should be split, verified, filtered, and reported.</p><pre>Create a dynamic workflow to audit this project for authentication and authorization issues.<br><br>Split the work like this:<br>1. Extract all endpoints.<br>2. Check whether each endpoint has authentication protection.<br>3. Look for missing input validation.<br>4. Send risky findings to a separate verifier agent.<br>5. Remove likely false positives.<br>6. Report the final results with severity, file path, evidence, and suggested fix.<br><br>Limit the first pass to backend/src. Keep the output short, evidence-based, and token-efficient.</pre><h3>When should you use Dynamic Workflows?</h3><p>Dynamic Workflows are not necessary for every task. If you need a small function, a one-file edit, or a quick explanation of an error message, a normal Claude Code session is usually faster and cheaper.</p><p>But if the task is large, repetitive, easy to parallelize, or expensive to get wrong, workflows start to make sense. Good use cases include repository-wide scans, multi-file refactors, framework migrations, security reviews, test-fixing loops, research synthesis, and technical report verification</p><blockquote>If a task overloads one context window, requires independent verification, or naturally splits into parallel subtasks, it is a good candidate for a Dynamic Workflow.</blockquote><h3>Ultracode and the cost question</h3><p>Settings such as ultracode can make Claude Code more willing to plan and run complex workflows. The tradeoff is cost. More reasoning, more agents, and more tool calls usually mean more token usage.</p><p>That is why Dynamic Workflows should not be treated as a magic mode to turn on for everything. The smarter approach is to start with a small scope, see whether the workflow creates real value, and then save the successful pattern for reuse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/0*o2mgf8ROkOENOcgk" /></figure><h3>The real shift: from writing code to designing process</h3><p>The most important thing about Dynamic Workflows is that they move AI use from answer generation to process design. In the old pattern, a prompt might say: ‘Fix this bug.’ In the new pattern, a prompt can say: ‘Use a workflow to inspect this module for auth issues, split endpoints across agents, verify the findings, and report only evidence-backed results.’</p><p>Those two prompts are fundamentally different. The first asks for an output. The second asks for a process that produces, checks, and synthesizes the output.</p><p>In the future, strong developers will not just be people who ask AI to write code. They will be people who can decompose work, define verification criteria, design agent roles, and evaluate the final result.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/0*WAqc3LvjuGwVYakk" /></figure><h3>Conclusion</h3><p>Claude Code Dynamic Workflows represent an important shift in AI-assisted software development. They make it possible to use AI not as one assistant, but as a temporary team of specialized agents working toward a shared goal.</p><p>Of course, workflows are not always the right choice. Used carelessly, they can increase token cost and make simple work unnecessarily complex. But when used well, they can significantly improve large refactors, codebase analysis, security reviews, migrations, and deep research tasks.</p><p>The lesson is simple: in the AI era, the key skill is not just writing better prompts. It is learning how to split the right work into the right agent architecture.</p><blockquote><strong>Main idea</strong></blockquote><blockquote>The advantage in the AI era will not come from writing the longest prompt. It will come from teaching AI to run the right process.</blockquote><p><strong>Tags:</strong> #Anthropic #Claude #ClaudeAI #ClaudeCode #ClaudeCowork #ArtificialIntelligence #GenAI #Productivity #Automation #SoftwareDevelopment #TechTrends #DevTools #FutureOfWork #NoCode #LLM</p><p><em>📧 Subscribe for more AI development insights | 👏 Clap if this helped you | 💬 Share your ClaudeCode experiences in the comments</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea9e4fee6434" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Axios npm Compromise Is a Warning to Every JavaScript Team⚠️]]></title>
            <link>https://medium.com/@yunusemresalcan/the-axios-npm-compromise-is-a-warning-to-every-javascript-team-%EF%B8%8F-5df8b824751f?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/5df8b824751f</guid>
            <category><![CDATA[cve]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[axios]]></category>
            <category><![CDATA[vulnerability]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 11:43:24 GMT</pubDate>
            <atom:updated>2026-03-31T11:43:24.641Z</atom:updated>
            <content:encoded><![CDATA[<p>On <strong>March 31, 2026</strong>, the JavaScript ecosystem got a brutal reminder that trust in open source is not the same thing as security. Two malicious Axios releases — <strong>axios@1.14.1</strong> and <strong>axios@0.30.4</strong> — were published to npm after what multiple security reports describe as a <strong>compromised maintainer account</strong>. Those releases pulled in a hidden dependency, <strong>plain-crypto-js@4.2.1</strong>, which researchers say used install-time execution to deliver a <strong>cross-platform remote access trojan</strong> affecting <strong>macOS, Windows, and Linux</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_a4-hskHyHht800PhS-8TQ.png" /></figure><p>Axios is not some obscure package buried deep in a niche toolchain. It is one of the most widely used HTTP clients in the JavaScript ecosystem, with security vendors describing its reach in the <strong>hundreds of millions of downloads</strong> and use across frontend apps, backend services, automation, and CI/CD environments. That scale is exactly why this incident matters so much.<br>What makes this incident so dangerous is that the malicious releases did <strong>not</strong> need to visibly rewrite Axios itself in an obvious way. Security analyses say the attacker introduced a fake dependency that existed primarily to execute during installation. In other words, the most dangerous code in the stack may have run <strong>before the application ever started</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/594/0*3loUkug-934jveSi.jpeg" /></figure><p>That changes the conversation completely. This is not just a dependency hygiene problem. It is not just a versioning mistake. It is a software supply chain incident with potential consequences for <strong>developer machines, CI runners, build agents, secrets, and release pipelines</strong>. If a poisoned package executes during install, the risk is no longer theoretical. It becomes an infrastructure and identity problem.</p><h3>What actually happened</h3><p>Public reporting from Wiz, Snyk, StepSecurity, and others points to the same core timeline. An attacker allegedly gained access to an Axios maintainer’s npm publishing account, then published <strong>axios@1.14.1</strong> and <strong>axios@0.30.4</strong> within a short window. Both releases introduced <strong>plain-crypto-js@4.2.1</strong>, a malicious package used to execute a dropper chain. Snyk reports the malicious Axios releases were removed by <strong>03:29 UTC</strong> on March 31, 2026, but any environment that installed them during that window may still have been exposed.</p><p>Several analyses also highlight an important red flag: the malicious npm publishes did not appear to follow Axios’s normal release path. Some defenders noted a mismatch between what appeared on npm and what was reflected in the project’s usual source-controlled release flow. That kind of registry-versus-source inconsistency is exactly the sort of signal teams need to start monitoring much more aggressively</p><h3>Why this should worry every JavaScript team</h3><p>Most teams still think package risk means outdated dependencies or known CVEs. But incidents like this expose a much more uncomfortable truth: a trusted package can become malicious <strong>without changing your trust habits at all</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*V_2ASSj93VCFw90H.jpeg" /></figure><p>Nobody had to install a typosquatted package. Nobody had to ignore a suspicious repo nobody had heard of. Teams only had to do something completely normal: resolve a dependency and run an install. That is what makes supply chain attacks so effective. They weaponize ordinary behavior.</p><p>And in modern JavaScript environments, installs happen constantly: in local development, in CI, in Docker builds, in preview environments, in ephemeral runners, and in monorepo workflows that propagate updates quickly. A poisoned release can spread faster than most engineering organizations can investigate it.</p><h3>What you should do right now</h3><p>If your organization uses Axios anywhere, the right response is not panic. It is disciplined containment.</p><blockquote><strong>First</strong>, determine whether you ever pulled the affected versions. Specifically, check for <strong>axios@1.14.1</strong>, <strong>axios@0.30.4</strong>, and <strong>plain-crypto-js@4.2.1</strong>. Do not stop at package.json. Review lockfiles, dependency caches, CI logs, artifact metadata, and container build history. Security guidance from vendors covering the incident consistently points to those versions as the critical indicators to investigate.</blockquote><blockquote><strong>Second</strong>, if the malicious versions were actually installed on a workstation, CI runner, or build host, treat that system as a <strong>possible compromise</strong>, not merely as a project with a bad dependency. Multiple analyses describe the payload as a cross-platform RAT delivered through install-time behavior, which means environment secrets and host integrity are part of the incident scope.</blockquote><blockquote><strong>Third</strong>, rotate credentials aggressively. That includes npm tokens, GitHub tokens, cloud keys, SSH keys, deployment secrets, and any .env values that may have been present in affected environments. In supply chain incidents, dependency compromise often becomes identity compromise.</blockquote><blockquote><strong>Fourth</strong>, rebuild from a known-good state. Removing a package is not enough if malicious code may already have executed. Clean images, fresh runners, and trusted baselines are safer than trying to “clean up” an environment that may already have been altered. Vercel’s own response emphasized remediation actions immediately after the incident was discovered.</blockquote><blockquote><strong>Finally</strong>, use this incident to harden the next release cycle. Teams should consider tighter version pinning for critical packages, stronger scrutiny of lifecycle scripts, better separation of build secrets, stronger provenance checks, and alerting on unusual publish behavior or registry/source mismatches. These are not theoretical improvements anymore. This attack showed why they matter.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/0*1FbhIje8XneLLICX.jpeg" /></figure><h3>Final takeaway</h3><p>The Axios npm compromise is not just a story about one poisoned package. It is a warning to every engineering team that still treats dependency installation as a routine action with routine risk.</p><h4>A patch release can now become an incident.<br> A normal install can now become initial access.<br> A dependency event can now become a credential event.</h4><p>That is the real lesson:<br>If your team builds with npm, this is the moment to review how you handle dependency trust, install-time execution, release provenance, lockfile drift, and build secrets. Because the next supply chain incident will probably not come from a package nobody trusts. It will come from one that everybody already does</p><h3>Sources and further reading</h3><p><em>Socket Research Team — </em><a href="https://socket.dev/blog/axios-npm-package-compromised"><strong><em>Supply Chain Attack on Axios Pulls Malicious Dependency from npm</em></strong></a></p><p><em>Vercel — </em><a href="https://vercel.com/changelog/axios-package-compromise-and-remediation-steps"><strong><em>Axios package compromise and remediation steps</em></strong></a></p><p><em>StepSecurity — </em><a href="https://www.stepsecurity.io/blog/axios-compromised-on-npm-malicious-versions-drop-remote-access-trojan"><strong><em>axios Compromised on npm — Malicious Versions Drop Remote Access Trojan</em></strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5df8b824751f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude vs Claude Code vs Cowork — Which One Do You Actually Need?]]></title>
            <link>https://medium.com/@yunusemresalcan/claude-vs-claude-code-vs-cowork-which-one-do-you-actually-need-66d3952a2eb4?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/66d3952a2eb4</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Tue, 24 Feb 2026 11:44:19 GMT</pubDate>
            <atom:updated>2026-02-24T11:44:19.125Z</atom:updated>
            <content:encoded><![CDATA[<p>Anthropic now ships three distinct AI tools. They look related, but they solve entirely different problems. Here’s how to choose without second-guessing yourself.</p><p>Three products, one brand, infinite confusion. If you’ve found yourself staring at Anthropic’s lineup — <strong>Claude AI</strong>, <strong>Claude Code</strong>, and <strong>Cowork</strong> — and wondering why there are three separate things when they all seem to “do AI stuff,” you are not alone. The company has been quietly expanding its surface area, and the distinctions between these tools are more meaningful than they first appear.</p><p>This article breaks down each Anthropic product clearly, compares them side by side, and — most importantly — tells you which AI tool to reach for depending on what you’re trying to accomplish.</p><blockquote>“The right tool isn’t the most powerful one. It’s the one that fits the shape of your problem.”</blockquote><h3>The Big Picture: Three Layers of Human-AI Interaction</h3><p>At its core, Anthropic has built three layers of human-AI interaction: a <strong>conversational layer</strong> (Claude AI), a <strong>developer autonomy layer</strong> (Claude Code), and a <strong>workflow automation layer</strong> (Cowork). Each targets a different user, a different context, and a different definition of “getting things done.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MEHZlV2zposoHBTy" /></figure><h3>Claude AI — The Conversational AI Assistant</h3><p>Claude AI is what most people mean when they say “Claude.” It lives at claude.ai, runs in a browser or mobile app, and asks nothing of you technically. You type. It responds. That’s the entire contract.</p><p>What makes Claude AI genuinely powerful is the breadth of what that conversation can encompass. Need a first draft of a board memo? A plain-English breakdown of a dense research paper? A devil’s advocate on your startup pitch? Claude AI handles all of these fluidly, with particular strength in long-form reasoning and nuanced analysis.</p><p>The workflow is simple and circular: you <strong>prompt</strong>, Claude responds through a chat interface, and you iterate. Memory is rich within a conversation, but it doesn’t persist across sessions by default, and the model has no access to your local files unless you explicitly paste content in.</p><p>This is simultaneously its strength and its ceiling. For the vast majority of knowledge work — writing, research, brainstorming, analysis — Claude AI is more than sufficient. But if you need the AI to <em>act</em> in the world rather than just <em>produce text</em>, you’ll hit a wall.</p><p><strong>Best for:</strong> Writers, researchers, students, marketers, consultants, and any knowledge worker who wants AI-augmented thinking without any setup.</p><h3>Claude Code — The Autonomous Coding Agent</h3><p>Claude Code is a fundamentally different product. It isn’t a chat interface — it’s a command-line agent that runs in your terminal and operates directly on your file system. You give it a task. It reads your entire codebase, plans an implementation approach, writes or modifies files, runs tests, interprets failures, and iterates — largely without your hand-holding.</p><p>The critical differentiator from Claude AI is persistent <strong>file-system memory and multi-file awareness</strong>. Claude Code genuinely understands the architecture of a large codebase in a way that no chat-pasted snippet can replicate. It can trace dependencies across modules, refactor legacy code consistently throughout an entire project, and build test suites from scratch.</p><blockquote>“Claude Code doesn’t just autocomplete lines — it understands your entire project’s architecture and makes decisions accordingly.”</blockquote><p>This makes Claude Code invaluable for tasks like: refactoring a legacy Django app to use async views across dozens of files; implementing a new feature end-to-end with tests; or debugging a subtle race condition that only surfaces when you trace execution across five interdependent modules.</p><p>The caveats are real, however. Claude Code is autonomous, which means it can make consequential changes fast. That’s a feature until it becomes a liability. Any serious use requires a solid Git workflow, a disciplined habit of reviewing diffs before committing, and a clear-eyed understanding that the developer remains responsible for what ships. Usage costs also accumulate quickly on large or continuous tasks.</p><p><strong>Best for:</strong> Software engineers, full-stack developers, and engineering teams who want autonomous, context-aware coding assistance at the codebase level</p><h3>Claude Cowork — The Desktop Workflow Automator</h3><p>Cowork is the newest and least-understood member of the Anthropic family. It’s a desktop application designed explicitly for non-developers who want to automate repetitive tasks without writing a single line of code.</p><p>Consider the business analyst who needs to extract structured data from 200 PDFs and populate a spreadsheet. Or the operations manager who spends every Monday renaming, sorting, and relocating files across three different folders. Or the recruiter manually copy-pasting applicant data between two systems. Cowork targets exactly these workflows.</p><p>Its interaction model mirrors Claude AI’s conversational loop but adds a critical execution layer: after you describe the task, Cowork can actually <strong>organize files, edit and update documents, and orchestrate multi-step cross-application workflows</strong> — all from a chat interface, no terminal or Python environment required.</p><p>The honest limitations: Cowork is still in beta. Its configuration options are limited compared to what a developer could achieve with Claude Code or the raw Anthropic API. But as a product for extending AI utility to non-engineers, it represents something meaningfully new in Anthropic’s lineup.</p><p><strong>Best for:</strong> Business analysts, operations managers, non-technical teams, and anyone drowning in repetitive file and application tasks who lacks the technical background to script solutions.</p><h3>Claude AI vs Claude Code vs Cowork: Side-by-Side Comparison</h3><p>Comparison of key features across all three Anthropic AI toolsFeatureClaude AIClaude CodeCowork<strong>Interface</strong>Web / Mobile ChatCommand Line (CLI)Desktop App<strong>Setup Required</strong>NoneTechnical (developer)Minimal (install app)<strong>File System Access</strong>NoYes — full codebaseYes — desktop files<strong>Autonomy Level</strong>Low (human-driven)High (agent)Medium (guided)<strong>Target User</strong>EveryoneDevelopersNon-technical teams<strong>Maturity</strong>ProductionProductionBeta</p><h3>Choosing the Right Tool: A Scenario-by-Scenario Guide</h3><p>Use this guide to find the right Anthropic tool for your specific scenarioYour ScenarioBest ToolWriting a blog post, report, or emailClaude AIBrainstorming and exploring ideas conversationallyClaude AISummarizing or explaining complex researchClaude AIRefactoring a multi-file codebase at scaleClaude CodeBuilding features autonomously with full test coverageClaude CodeDebugging complex cross-module issuesClaude CodeOrganizing or renaming hundreds of files in bulkCoworkExtracting data from PDFs into spreadsheetsCoworkAutomating copy-paste workflows between desktop appsCowork</p><h3>Frequently Asked Questions About Claude, Claude Code, and Cowork</h3><h4>What is the difference between Claude AI and Claude Code?</h4><p>Claude AI is a conversational chat interface ideal for writing, research, and brainstorming — no setup required. Claude Code is a command-line autonomous agent that operates on your local file system, reads your entire codebase, and performs multi-file coding tasks with deep architectural context. The key difference is execution: Claude AI produces text, while Claude Code takes action on your actual code.</p><h4>Who is Claude Cowork designed for?</h4><p>Claude Cowork is designed for non-developers who want to automate repetitive file management and cross-application desktop workflows without writing code. Business analysts, operations managers, and admin professionals who deal with bulk file tasks, data extraction from PDFs, and manual copy-paste between apps are Cowork’s primary audience.</p><h4>Do I need all three Anthropic AI tools?</h4><p>Not necessarily. Most individual users only need Claude AI. Software engineers who want autonomous, codebase-level assistance should evaluate Claude Code. Non-technical users with desktop automation needs should try Cowork. Some teams — particularly those mixing engineering, operations, and content roles — benefit from using all three in complementary ways.</p><h4>Is Claude Code free to use?</h4><p>Claude Code usage costs apply based on the volume of tokens processed. For large codebases or continuous autonomous tasks, costs can accumulate quickly. It’s worth budgeting carefully and testing with smaller tasks before deploying at scale.</p><h4>Is Cowork available now?</h4><p>As of early 2026, Cowork is available as a beta product. It is a desktop application for non-developers, but it currently has limited configuration options compared to more mature Anthropic products. Expect active development and feature expansion.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X2AiV3WhzZIcdYjV.png" /></figure><h3>Final Take: The Tool That Fits Your Problem</h3><p>When you step back, the three Anthropic products map onto a clean framework. <strong>Claude AI</strong> augments human thinking — you stay in the loop on every decision, and the value is in the quality of the output text. <strong>Claude Code</strong> delegates technical execution — you define the goal, and the agent handles implementation autonomously. <strong>Cowork</strong> replaces manual digital labor — repetitive, rule-bound tasks that previously required a human clicking through interfaces.</p><p>None of these products makes the others obsolete. A software team might use all three simultaneously: Claude AI for documentation and design thinking, Claude Code for implementation, and Cowork for automating the non-technical business workflows surrounding the product.</p><blockquote>“The mistake isn’t picking the wrong tool. It’s assuming one tool covers everything.”</blockquote><p>If you’re a writer, researcher, student, or knowledge worker, <strong>Claude AI</strong> is your entry point and will handle the vast majority of your needs. If you’re an engineer who wants to delegate entire implementation tasks to a capable autonomous agent, <strong>Claude Code</strong> is worth serious evaluation. And if you’re drowning in repetitive file and application work without a technical background, <strong>Cowork</strong> is the most underrated option in the Anthropic lineup right now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*dhp4wcbzTGoljpBN" /></figure><p>The AI frontier is expanding. Pick the tool that fits your actual problem — not the one with the most impressive demo reel.<br><strong>Tags:</strong> #Anthropic #Claude #ClaudeAI #ClaudeCode #ClaudeCowork #ArtificialIntelligence #GenAI #Productivity #Automation #SoftwareDevelopment #TechTrends #DevTools #FutureOfWork #NoCode #LLM</p><p><em>📧 Subscribe for more AI development insights | 👏 Clap if this helped you | 💬 Share your ClaudeCode experiences in the comments</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66d3952a2eb4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From REST APIs to Blockchain: My Journey Building 10 Real-World Go Projects]]></title>
            <link>https://medium.com/@yunusemresalcan/from-rest-apis-to-blockchain-my-journey-building-10-real-world-go-projects-3625d8b3f618?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/3625d8b3f618</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Sat, 18 Oct 2025 12:40:44 GMT</pubDate>
            <atom:updated>2025-10-18T12:40:44.342Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/665/0*k3CmJJ60kSrEadj8.png" /></figure><h3>Hey There! 👋</h3><p>So, I did something a bit crazy. I spent the last few months building 10 complete Go projects from scratch, and honestly? It was one of the best learning experiences I’ve ever had. Let me tell you why.</p><p>You know that feeling when you’re learning a new programming language, and you’re stuck doing tutorials that teach you “Hello World” for the millionth time? Yeah, I was tired of that too. I wanted to build <strong>real stuff</strong> — the kind of projects you’d actually use in production.</p><p>That’s how this series was born.</p><h3>Why Go? And Why These Projects?</h3><p>Look, I’ll be honest with you. Go isn’t the sexiest language out there. It doesn’t have fancy features like some other languages. But you know what? <strong>It just works.</strong></p><p>When you need to handle thousands of concurrent connections without breaking a sweat? Go. When you want code that’s easy to read and maintain? Go. When you need something that compiles in seconds and runs blazingly fast? You guessed it — Go.</p><p>So I thought: “What if I could learn Go by building the kind of stuff companies actually need?” That’s exactly what I did.</p><h3>The Projects: A Quick Tour</h3><h3>1. RESTful API — The Foundation 🏗️</h3><p><strong><em>Port: 8080</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kIxzFFuPy2Jc_zfI.jpeg" /></figure><h4>This is where everyone should start. No fluff, no fancy frameworks — just pure REST principles with Go.</h4><p><strong>What I learned:</strong></p><ul><li>How HTTP <em>really</em> works (not just the theory)</li><li>Middleware patterns that actually make sense</li><li>Why everyone loves Gorilla Mux</li><li>JSON marshaling/unmarshaling without tearing my hair out</li></ul><p><strong>Real talk:</strong> This project taught me more about backend development in a week than months of tutorials. There’s something about actually building CRUD operations that makes everything click.</p><pre>// My favorite part - it&#39;s so clean!<br>router.HandleFunc(&quot;/api/users&quot;, getUsers).Methods(&quot;GET&quot;)<br>router.HandleFunc(&quot;/api/users/{id}&quot;, getUser).Methods(&quot;GET&quot;)</pre><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/01-restful-api">Go-10-projects-for-education/01-restful-api at main · Yemresalcan/Go-10-projects-for-education</a> ⭐</blockquote><h3>2. Real-Time Chat App — Where Go Shines ✨</h3><p><strong><em>Port: 8081</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eHR1QmX7hmdgp5hUy55HiA.png" /></figure><h4>This is where I fell in love with Go. Seriously.Building a chat app in most languages? Good luck managing those connections. But with Go’s goroutines and channels? It’s almost <em>too easy</em>.</h4><p><strong>The “Wow” moments:</strong></p><ul><li>Watching 100+ users connect simultaneously without the server even breaking a sweat</li><li>Understanding how WebSocket works at a deep level</li><li>The beautiful simplicity of the Hub pattern</li><li>Goroutines making concurrent programming feel natural</li></ul><pre>// This is where the magic happens<br>go client.writePump()<br>go client.readPump()</pre><p><strong>Pro tip:</strong> Run this project, open 10 browser tabs, and watch messages fly between them in real-time. It’s oddly satisfying.</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/02-chat-app">Go-10-projects-for-education/02-chat-app at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>3. URL Shortener — More Than You’d Think 🔗</h3><p><strong>Port: 8082</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h8QgCloKPBUnB1O5SDRWjQ.png" /></figure><h4>Ever wondered how bit.ly or TinyURL actually work? I did. So I built one.</h4><p><strong>What surprised me:</strong></p><ul><li>MD5 hashing is both simple and powerful</li><li>HTTP redirects have nuances (301 vs 302 matters!)</li><li>In-memory storage can be really fast</li><li>Analytics are crucial (everyone wants to know how many clicks)</li></ul><p>The coolest part? You can actually use this. I’ve been using my own URL shortener for sharing links with friends!</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/03-url-shortener">Go-10-projects-for-education/03-url-shortener at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>4. Task Scheduler — Set It and Forget It ⏰</h3><p><strong>Port: 8083</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4BXCUy2yzcG89xdj7jOEHQ.png" /></figure><h4>This one solved a real problem for me. I needed to automate some tasks, and cron syntax always confused me. So I built a visual interface for it.</h4><p><strong>What makes it cool:</strong></p><ul><li>Cron expressions become visual and understandable</li><li>Real-time dashboard shows what’s running</li><li>Background jobs without blocking the main thread</li><li>Perfect for automation nerds (like me)</li></ul><p><strong>Use case:</strong> I’m using this to backup my databases daily. Set it once, never worry about it again.</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/04-task-scheduler">Go-10-projects-for-education/04-task-scheduler at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>5. GraphQL API — The REST Alternative 🚀</h3><p><strong>Port: 8084</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*72bYU-MzYwdrJkZSb6jk8Q.png" /></figure><h4>REST is great, but have you tried GraphQL? Game changer.</h4><p><strong>Why I love it:</strong></p><ul><li>Request exactly what you need, nothing more</li><li>No more over-fetching or under-fetching</li><li>The schema system is beautiful</li><li>GraphQL Playground makes testing fun</li></ul><p><strong>Honest moment:</strong> The learning curve is steeper than REST, but once it clicks? You’ll wonder why you waited so long.</p><pre>query {<br>  users {<br>    id<br>    name<br>    email<br>  }<br>}<br># That&#39;s it. No complicated URL parameters.</pre><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/05-graphql-api">Go-10-projects-for-education/05-graphql-api at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>6. File Sharing Service — Dropbox Vibes 📁</h3><p><strong>Port: 8085</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cqQuUa27HEjvrAZcWBD1nA.png" /></figure><h4>Building this taught me that file handling in Go is actually pleasant. Who knew?</h4><p><strong>Features I’m proud of:</strong></p><ul><li>Drag &amp; drop upload (feels so modern!)</li><li>Unique shareable links</li><li>10MB file size limit (because we need boundaries)</li><li>Download tracking</li></ul><p><strong>Real-world use:</strong> I share large files with my team using this. No more sketchy third-party services.</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/06-file-sharing">Go-10-projects-for-education/06-file-sharing at main · Yemresalcan/Go-10-projects-for-education</a> ⭐</blockquote><h3>7. Web Scraper — Data Extraction Made Easy 🕷️</h3><p><strong>Port: 8086</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PH3cQBat-N5zmwdWClWedA.png" /></figure><h4>This project answers the question: “How do price comparison websites work?”</h4><p><strong>What I discovered:</strong></p><ul><li>Goquery makes HTML parsing actually enjoyable</li><li>CSS selectors are incredibly powerful</li><li>User-Agent headers matter more than you think</li><li>Always respect robots.txt (be a good internet citizen!)</li></ul><p><strong>Fun fact:</strong> I used this to track prices on my favorite online stores. Got some sweet deals!</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/07-web-scraper">Go-10-projects-for-education/07-web-scraper at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>8. Credit Card Validator — The Math Behind Payments 💳</h3><p><strong>Port: 8090</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SNv9Aa3R_A4vyVWi" /></figure><h4>Ever wondered how websites instantly know if you typed your card number wrong? It’s all about the Luhn algorithm.</h4><p><strong>Mind-blowing stuff:</strong></p><ul><li>Card numbers aren’t random</li><li>The last digit is a checksum</li><li>You can detect the card type from the first few digits</li><li>CVV lengths vary by card type</li></ul><p><strong>Disclaimer:</strong> This is educational only. Never store real card data! Use payment gateways like Stripe.</p><pre>// The Luhn algorithm in action - so elegant!<br>func luhnValidate(number string) bool {<br>    // Mathematical magic happens here<br>}</pre><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/08-credit-card-validator">Go-10-projects-for-education/08-credit-card-validator at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>9. Image Processing Service — Instagram for Developers 🎨</h3><p><strong>Port: 8091</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_xltidNwXRU_ymsP" /></figure><h4>This was the most visually rewarding project. Seeing images transform in real-time is just cool.</h4><p><strong>What I built:</strong></p><ul><li>Resize with quality (Lanczos algorithm — fancy!)</li><li>Filters: Grayscale, Blur, Sharpen, Sepia, Invert</li><li>Brightness and contrast adjustments</li><li>Format conversion (JPEG ↔ PNG)</li><li>Base64 encoding for instant preview</li></ul><p><strong>Coolest feature:</strong> The sepia filter I implemented from scratch. It’s like time-traveling your photos.</p><p><strong>Performance note:</strong> Processing a 4K image takes less than a second. Go’s concurrency FTW!</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/09-image-processing">Go-10-projects-for-education/09-image-processing at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><h3>10. Blockchain — The Grand Finale ⛓️</h3><p><strong>Port: 8092</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z608268pvz-hALNy" /></figure><h4>Okay, this one. THIS ONE. This is where everything comes together.</h4><h4>Building a blockchain from scratch taught me more about cryptocurrency than reading a hundred articles ever could.</h4><p><strong>What’s inside:</strong></p><ul><li>Proof of Work mining (watching your CPU sweat is oddly satisfying)</li><li>SHA-256 cryptographic hashing</li><li>Chain validation and immutability</li><li>Transaction management</li><li>The famous Genesis Block</li></ul><p><strong>The “Aha!” moment:</strong> When I mined my first block and saw the hash with four leading zeros. I literally said “Oooh” out loud.</p><blockquote><a href="https://github.com/Yemresalcan/Go-10-projects-for-education/tree/main/10-blockchain">Go-10-projects-for-education/10-blockchain at main · Yemresalcan/Go-10-projects-for-education</a>⭐</blockquote><pre>// Mining in action - brute force at its finest<br>for {<br>    hash := calculateHash(block)<br>    if strings.HasPrefix(hash, target) {<br>        return hash // Found it!<br>    }<br>    block.Nonce++<br>}<br></pre><h3>Real Talk: Who Is This For?</h3><h4>🎓 Students</h4><p>If you’re learning Go and tired of basic tutorials, this is for you. Build something you can actually show off.</p><h4>💼 Professionals</h4><p>Switching to Go? These projects will get you productive fast. I’ve literally used these patterns in production code.</p><h4>🚀 Entrepreneurs</h4><p>Need to build an MVP? Pick a few of these projects, combine them, and you’ve got a solid backend.</p><h4>🤓 Curious Minds</h4><p>Want to understand how things work under the hood? These projects will scratch that itch.</p><h3>My Learning Journey (The Real Story)</h3><p><strong>Week 1:</strong> Started with REST API. Felt confident. “This is easy!”</p><p><strong>Week 2:</strong> Built the chat app. Mind = blown. Fell in love with goroutines.</p><p><strong>Week 3:</strong> URL shortener and task scheduler. Started feeling like a real Go developer.</p><p><strong>Week 4:</strong> GraphQL and file sharing. Realized Go is perfect for backend services.</p><p><strong>Week 5:</strong> Web scraper and card validator. Algorithms in Go are surprisingly elegant.</p><p><strong>Week 6:</strong> Image processing. Learned that Go isn’t just for APIs and servers.</p><p><strong>Week 7–8:</strong> Blockchain. Debugged for days. Finally understood cryptocurrency. Worth it.</p><h3>Performance Stories (Because Numbers Are Cool)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/676/0*7mznQEuZdzWZshdi" /></figure><p>Let me share some real metrics from these projects:</p><p><strong>Chat App:</strong></p><ul><li>Handled 5,000 concurrent WebSocket connections</li><li>Memory usage: ~200MB</li><li>CPU: Barely noticeable</li><li>Message latency: &lt;5ms</li></ul><p><strong>RESTful API:</strong></p><ul><li>Response time: 0.5ms average</li><li>Throughput: 50,000 requests/second (on my laptop!)</li><li>Memory: Stable at ~30MB</li></ul><p><strong>Blockchain:</strong></p><ul><li>Mining difficulty 4: ~5 seconds</li><li>Difficulty 5: ~80 seconds</li><li>Difficulty 6: Make some coffee (seriously)</li></ul><h3>Getting Started (Your Turn!)</h3><p>Here’s how you can dive in right now:</p><h4>1. Clone It</h4><pre>git clone https://github.com/Yemresalcan/Go-10-projects-for-education.git<br>cd Go-10-projects-for-education</pre><h4>2. Pick Your Adventure</h4><pre>cd 01-restful-api  # I recommend starting here</pre><h4>3. Install Dependencies</h4><pre>go mod download</pre><h4>4. Run It</h4><pre>go run main.go</pre><p>Each project has its own README with detailed explanations, code walkthroughs, and usage examples.</p><h3>What You’ll Actually Learn</h3><h4>Not the boring theoretical stuff, but practical skills:</h4><p>✅ <strong>Backend Development</strong> — REST, GraphQL, WebSocket — the whole shebang</p><p>✅ <strong>Concurrent Programming</strong> — Goroutines and channels without fear</p><p>✅ <strong>Algorithms</strong> — Hashing, validation, image processing</p><p>✅ <strong>System Design</strong> — How real applications are structured</p><p>✅ <strong>Best Practices</strong> — Code that other developers will actually want to read</p><p>✅ <strong>Problem Solving</strong> — Debug skills you’ll use every day</p><h3>Real-World Applications</h3><p>These aren’t toy projects. Here’s what you could actually build:</p><ol><li><strong>E-commerce Backend</strong> — Combine REST API + File Sharing + Image Processing</li><li><strong>Social Platform</strong> — Chat + GraphQL + Image Processing</li><li><strong>SaaS Application</strong> — Task Scheduler + REST API + File Sharing</li><li><strong>Analytics Tool</strong> — Web Scraper + REST API + Data Storage</li><li><strong>Fintech App</strong> — Card Validator + Blockchain concepts + Security</li></ol><h3>The Community Aspect</h3><p>This is open source (MIT licensed), which means:</p><ul><li>✨ Free forever</li><li>🔧 You can modify it</li><li>📚 You can learn from it</li><li>🤝 You can contribute to it</li></ul><p>Found a bug? Want to add a feature? PRs are welcome!</p><p><strong>GitHub:</strong> <a href="https://github.com/Yemresalcan/Go-10-projects-for-education">https://github.com/Yemresalcan/Go-10-projects-for-education</a></p><h3>What’s Next?</h3><p>I’m planning to add more projects:</p><ul><li>Microservices architecture with service discovery</li><li>gRPC implementation</li><li>OAuth2 authentication system</li><li>Redis caching layer</li><li>Kubernetes deployment configs</li><li>Full CI/CD pipeline</li></ul><h3>My Honest Mistakes (Learn From Them!)</h3><p><strong>Mistake #1:</strong> Tried to build blockchain first. Terrible idea. Start simple.</p><p><strong>Mistake #2:</strong> Didn’t read about goroutines before building chat app. Confused myself for days.</p><p><strong>Mistake #3:</strong> Ignored error handling early on. Paid the price during debugging.</p><p><strong>Mistake #4:</strong> Didn’t test with concurrent users. Found bugs only in “production” (localhost counts, right?).</p><p><strong>Lesson learned:</strong> Follow the difficulty order. There’s a reason it’s structured that way.</p><h3>Final Thoughts</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*AY9TQFnI_TY4HplG.gif" /></figure><p>Look, I’m not going to tell you this will make you a Go expert overnight. But I will tell you this: <strong>these projects will teach you more than months of tutorial hell ever could.</strong></p><p>You’ll struggle. You’ll debug. You’ll question your life choices at 2 AM when that blockchain won’t validate. But when it finally works? That feeling is why we code.</p><p>Plus, you’ll have 10 working projects in your portfolio. That’s something tangible you can show to potential employers or clients.</p><h3>Let’s Connect!</h3><p>Built something cool with these projects? Found a bug? Just want to chat about Go?</p><p><strong>Find me here:</strong></p><ul><li>🐙 GitHub:<em> </em><a href="https://github.com/Yemresalcan"><em>@Yemresalcan</em></a></li><li>💼 LinkedIn: <a href="https://www.linkedin.com/in/yunusemresalcan/"><em>@Yunusemresalcan</em></a></li></ul><h3>One More Thing…</h3><p>If this project helps you land a job, learn something new, or build something cool — drop me a message. Seriously. That stuff makes my day.</p><p>And if you found this useful, give it a ⭐ on GitHub. It helps others find it too!</p><p><strong>Ready to start your Go journey? Clone the repo and pick a project. Your future self will thank you.</strong></p><p><strong>🔗 Repository:</strong> <a href="https://github.com/Yemresalcan/Go-10-projects-for-education">https://github.com/Yemresalcan/Go-10-projects-for-education</a></p><p><em>P.S. — If you actually read this entire article, you’re my kind of developer. Now stop reading and start coding! 😉</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3625d8b3f618" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing a Production-Ready E-Commerce API with .NET]]></title>
            <link>https://medium.com/@yunusemresalcan/developing-a-production-ready-e-commerce-api-with-net-132a4364e618?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/132a4364e618</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ecommerce]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 09:19:35 GMT</pubDate>
            <atom:updated>2025-08-15T09:19:35.681Z</atom:updated>
            <content:encoded><![CDATA[<h3>Developing a Production-Ready E-Commerce API with .NET 9: An Engineering Journey from Scratch to Enterprise-Level</h3><p>Notes on Modern Software Architecture, Microservice Patterns, and Enterprise-Grade Observability</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lgF6hoxqrgpDiPJs" /></figure><h4>Introduction: From Ground Zero to the First Line</h4><p>As a software engineer, the moments I enjoy the most are when I bring an idea to life from scratch. This project was born precisely from that passion. My goal was to test the innovations and performance potential offered by .NET 9 through a high-traffic and realistic scenario: developing a production-ready, scalable, and enterprise-level monitorable e-commerce API.</p><p>I had been curious about .NET 9 for a long time. I saw this project as an opportunity to both experience its new features and measure its performance in a high-traffic scenario. As I embarked on the journey, I set clear goals for myself:</p><ul><li>Build a system capable of handling 10,000+ requests per second</li><li>Design a horizontally scalable architecture</li><li>Achieve 99.9% uptime</li><li>Provide full observability (monitoring, logging, tracing)</li><li>Implement modern patterns like Clean Architecture, CQRS, and Event Sourcing</li></ul><p>These goals initially seemed like an ambitious “technology dream,” but each step of the project turned into a serious engineering challenge.</p><h3>User Stories That Shaped the Architecture</h3><h4>Epic 1: Customer Experience</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/0*Eh_r6SPO5ySBLWR0.jpg" /></figure><h4>User Story 1: Product Discovery</h4><blockquote>“As a customer, I want to quickly search for products and find what I’m looking for without wasting time.”</blockquote><p><strong>Technical Decisions:</strong></p><ul><li><strong>Elasticsearch</strong> for search performance in milliseconds.</li><li><strong>Redis</strong> for caching frequently accessed search results.</li><li>Enriching the user experience with autocomplete and real-time faceted filtering.</li></ul><p>To achieve this, I implemented a search infrastructure powered by Elasticsearch and cached with Redis:</p><pre>var cached = await _cacheService.GetAsync&lt;ProductSearchResult&gt;(cacheKey);<br>if (cached != null) return cached;<br><br>var searchResponse = await _elasticClient.SearchAsync&lt;ProductReadModel&gt;(s =&gt; s<br>    .Index(&quot;products&quot;)<br>    .Query(q =&gt; BuildOptimizedQuery(q, request))<br>    .Aggregations(a =&gt; BuildFacetAggregations())<br>    .Highlight(h =&gt; h.Fields(f =&gt; f.Field(p =&gt; p.Name)))<br>);<br><br>var result = MapToSearchResult(searchResponse);<br>await _cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(15));<br>return result;</pre><p><strong>Result:</strong> This architecture reduced the average search time to <strong>45ms</strong> and achieved a cache hit ratio of <strong>85%</strong>.</p><h4>User Story 2 — Seamless Ordering</h4><blockquote>“As a customer, I want to complete my order without delay or error.”</blockquote><p><strong>Technical Decisions:</strong></p><ul><li><strong>Event-driven</strong> order processing workflow.</li><li>Real-time inventory management for stock consistency.</li><li><strong>Optimistic Concurrency Control</strong> to maintain data integrity.</li></ul><p>Optimistic concurrency control was applied to ensure stock consistency, and inventory updates were published via an event:</p><pre>if (product.StockQuantity &lt; itemDto.Quantity)<br>{<br>    throw new InsufficientStockException(<br>        $&quot;Only {product.StockQuantity} items available&quot;<br>    );<br>}<br>product.DecreaseStock(itemDto.Quantity, &quot;Order placed&quot;);<br><br>// Publish the stock updated event<br>await _eventBus.PublishAsync(new ProductStockUpdatedEvent(product.Id, oldStock, newStock));</pre><p><strong>Result:</strong> Zero overselling and a <strong>99.9%</strong> successful order completion rate.</p><h3>Epic 2: Business Operations</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*ewhHm0TJYCFMwET1.jpg" /></figure><h4>User Story 3 — Inventory Management</h4><blockquote>“As a store manager, I want to track inventory in real-time to prevent overselling<em>.”</em></blockquote><p><strong>Technical Decisions:</strong></p><ul><li><strong>Event Sourcing</strong> to keep an immutable record of all stock movements.</li><li>Real-time synchronization via an event-based approach using <strong>RabbitMQ</strong>.</li><li>Automated reorder notifications for critical stock levels.</li><li>Creating an audit trail for every stock movement.</li></ul><p>Here is an example of an event handler that processes stock updates:</p><pre>public async Task Handle(ProductStockUpdatedEvent evt, CancellationToken ct)<br>{<br>    var inventory = await _inventoryRepository.GetByProductIdAsync(evt.ProductId, ct);<br>    inventory.UpdateStock(evt.NewStock);<br>    await _inventoryRepository.SaveAsync(inventory, ct);<br>}</pre><p><strong>Result:</strong> This approach ensured that inventory status was synchronized across the system in real-time while creating an audit trail for every change.</p><h4>User Story 4: Performance Monitoring</h4><blockquote>“As a DevOps engineer, I want to monitor system health and performance in real-time to respond instantly to potential issues.”</blockquote><p><strong>Technical Stack:</strong> A combination of <strong>Prometheus</strong> (metrics collection), <strong>Grafana</strong> (visualization), and <strong>AlertManager</strong> (alerting mechanism) was used.</p><p>Monitored metrics were divided into two categories:</p><ul><li><strong>Business Metrics:</strong> Order rate, real-time revenue, customer conversion rate, etc.</li><li><strong>Technical Metrics:</strong> CPU/memory usage, network traffic, database query latency, API error rates, etc.</li></ul><h4>Architecture Evolution: From Monolith to Microservices</h4><p>Phase 1: Foundation with Clean Architecture</p><p>The journey began with establishing a solid foundation using Clean Architecture principles:</p><p>Project Structure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vgnj4x_4W_e_NJBs" /></figure><p><strong>Achieved Results:</strong></p><ul><li>⚙️ <strong>MTTR (Mean Time to Repair):</strong> Reduced from 45 minutes to <strong>3 minutes</strong>.</li><li>📈 <strong>Uptime:</strong> Reached <strong>99.97%</strong>.</li></ul><h3>Architectural Evolution: From Monolith to Microservices</h3><h3>Architectural Evolution: From Monolith to Microservices</h3><p>At the beginning of the project, I opted for a monolithic <strong>Clean Architecture</strong> to leverage its advantages in rapid development and ease of testing. However, every architectural decision was made strategically to allow for a seamless transition to microservices in the future.</p><p><strong>Key Architectural Decisions:</strong></p><ul><li><strong>Domain-Driven Design (DDD):</strong> To model complex business logic within clear and understandable bounded contexts.</li><li><strong>CQRS (Command Query Responsibility Segregation):</strong> To separate write (Command) and read (Query) operations, optimizing each according to its needs.</li><li><strong>Event-Driven Approach:</strong> To achieve loose coupling between services, increasing the system’s flexibility and resilience.</li></ul><h3>CI/CD and Deployment</h3><p><strong>Local Development Environment with Docker Compose:</strong></p><ul><li>API Gateway &amp; Services</li><li>PostgreSQL (Write database)</li><li>Elasticsearch (Read/Search database)</li><li>Redis (Cache)</li><li>RabbitMQ (Message Broker)</li><li>Monitoring Stack (Prometheus, Grafana)</li></ul><p><strong>Automation with GitHub Actions:</strong> The CI/CD pipeline set up with GitHub Actions followed these steps: Code Push → Automated Tests → Security Scans → Docker Image Build → Deploy to Staging → Deploy to Production after Manual Approval.</p><p><strong>Results:</strong></p><ul><li><strong>Average Build Time:</strong> 3.2 minutes</li><li><strong>Weekly Deployments:</strong> 15+</li><li><strong>Code Coverage:</strong> 85%</li></ul><h3>Performance Optimization</h3><ul><li><strong>Database Indexing:</strong> Achieved up to a <strong>75% reduction</strong> in query times with proper indexing strategies.</li><li><strong>Connection Pooling:</strong> Reached over <strong>90% effective utilization</strong> with database connection pooling.</li><li><strong>Multi-Layer Caching:</strong> Attained a <strong>92% hit ratio</strong> and a <strong>60% reduction</strong> in database load using Redis and In-Memory Cache.</li></ul><h3>Technical and Personal Lessons Learned</h3><ul><li><strong>Observability</strong> is not a luxury; it’s a foundation that must be established from day one of the project.</li><li>While initially complex, an <strong>event-driven architecture</strong> provides significant long-term gains in flexibility and scalability.</li><li>Comprehensive <strong>performance and load testing</strong> before going live is the most effective way to identify potential bottlenecks early.</li><li><strong>Clean Architecture</strong> enhances the testability and maintainability of the code, extending the project’s lifespan.</li></ul><h3>Tech Stack</h3><p>.NET 9, C# 12, PostgreSQL, Elasticsearch, Redis, RabbitMQ, JWT &amp; Identity, Serilog, FluentValidation, Docker, GitHub Actions, Prometheus, Grafana, AWS S3</p><blockquote><strong>The key to success lies in balancing technical excellence with business value, always keeping the user stories and real-world impact at the center of every architectural decision.</strong></blockquote><p><strong>Source Code and Details:</strong> You can access the project’s source code and more technical details on the GitHub repository: github.com/Yemresalcan/E-commerceAPI</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=132a4364e618" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[. Geliştirme: Sıfırdan Kurumsal Seviyede İzlemeye]]></title>
            <link>https://medium.com/@yunusemresalcan/geli%C5%9Ftirme-s%C4%B1f%C4%B1rdan-kurumsal-seviyede-i%CC%87zlemeye-c8eab5a2f2ee?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8eab5a2f2ee</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[net-9]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 09:15:01 GMT</pubDate>
            <atom:updated>2025-08-15T09:15:01.694Z</atom:updated>
            <content:encoded><![CDATA[<h3>.NET 9 ile Üretim Ortamına Hazır E-Ticaret API’si Geliştirme: Sıfırdan Kurumsal Seviyede İzlemeye</h3><p><em>Modern yazılım mimarisi, mikroservis desenleri ve kurumsal seviyede izleme üzerine kişisel bir mühendislik yolculuğu</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*akPA6wlqWtBsxnx_" /></figure><h3>Giriş: Sıfır Noktasından İlk Satıra</h3><p>Bir yazılım mühendisi olarak en keyif aldığım anlar, bir fikri sıfırdan hayata geçirdiğim anlardır. Bu proje de tam olarak bu tutkuyla doğdu. Amacım, .NET 9’un sunduğu yenilikleri ve performans potansiyelini, yüksek trafikli ve gerçekçi bir senaryo üzerinden test etmekti: üretim ortamına hazır, ölçeklenebilir ve kurumsal seviyede izlenebilir bir e-ticaret API’si geliştirmek.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*QqBgyErhBi0avaBR.png" /></figure><p>.NET 9’u uzun zamandır merak ediyordum. Hem yeni özelliklerini deneyimlemek hem de yüksek trafikli bir senaryoda performansını ölçmek için bu projeyi bir fırsat olarak gördüm. Yolculuğa çıkarken kendime net hedefler koydum:</p><ul><li>Saniyede <strong>10.000+ isteği</strong> işleyebilen bir sistem kurmak</li><li>Yatay ölçeklenebilir bir mimari tasarlamak</li><li><strong>%99,9 uptime</strong> seviyesini yakalamak</li><li>Tam gözlemlenebilirlik (<strong>monitoring, logging, tracing</strong>) sağlamak</li><li><strong>Clean Architecture, CQRS ve Event Sourcing</strong> gibi modern desenleri uygulamak</li></ul><p>Bu hedefler, başlangıçta iddialı bir “teknoloji rüyası” gibi görünse de, projenin her adımı ciddi bir mühendislik meydan okumasına dönüştü.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nYnkyHsIRB9qYV7X" /></figure><h3>Epic 1: Müşteri Deneyimi</h3><h4>User Story 1 — Ürün Keşfi</h4><blockquote>“Bir müşteri olarak, ürünleri hızlıca arayıp, zaman kaybetmeden aradığımı bulmak istiyorum.”</blockquote><p><strong>Teknik Kararlar:</strong></p><ul><li><strong>Elasticsearch</strong> ile milisaniyeler içinde arama performansı.</li><li><strong>Redis</strong> ile sık kullanılan arama sonuçları için önbellekleme (caching).</li><li>Otomatik tamamlama (autocomplete) ve gerçek zamanlı fasetli filtreleme ile kullanıcı deneyimini zenginleştirme.</li></ul><p>Bu hedefe ulaşmak için Redis ile önbelleğe alınmış ve Elasticsearch ile güçlendirilmiş bir arama altyapısı kurdum</p><pre>var cached = await _cacheService.GetAsync&lt;ProductSearchResult&gt;(cacheKey);<br>if (cached != null) return cached;<br><br>var searchResponse = await _elasticClient.SearchAsync&lt;ProductReadModel&gt;(s =&gt; s<br>    .Index(&quot;products&quot;)<br>    .Query(q =&gt; BuildOptimizedQuery(q, request))<br>    .Aggregations(a =&gt; BuildFacetAggregations())<br>    .Highlight(h =&gt; h.Fields(f =&gt; f.Field(p =&gt; p.Name)))<br>);<br><br>var result = MapToSearchResult(searchResponse);<br>await _cacheService.SetAsync(cacheKey, result, TimeSpan.FromMinutes(15));<br>return result;</pre><p><strong>Sonuç:</strong> Bu yapı sayesinde ortalama arama süresi <strong>45 milisaniyeye</strong> düşerken, cache isabet oranı <strong>%85</strong> seviyesine ulaştı.</p><h4>User Story 2 — Sorunsuz Sipariş</h4><blockquote>“Bir müşteri olarak, siparişimi gecikmeden ve hatasız bir şekilde tamamlamak istiyorum.”</blockquote><p><strong>Teknik Kararlar:</strong></p><ul><li><strong>Event-driven (Olay Güdümlü)</strong> sipariş işleme akışı.</li><li>Gerçek zamanlı stok yönetimi ile stok tutarlılığı.</li><li><strong>İyimser Eşzamanlılık Kontrolü (Optimistic Concurrency Control)</strong> ile veri bütünlüğünün korunması.</li></ul><p>Stok tutarlılığını sağlamak için iyimser eşzamanlılık kontrolü uygulandı ve stok güncellemeleri bir event aracılığıyla yayınlandı:</p><pre>if (product.StockQuantity &lt; itemDto.Quantity)<br>{<br>    throw new InsufficientStockException(<br>        $&quot;Only {product.StockQuantity} items available&quot;<br>    );<br>}<br>product.DecreaseStock(itemDto.Quantity, &quot;Order placed&quot;);<br><br>// Stok güncelleme olayını yayınla<br>await _eventBus.PublishAsync(new ProductStockUpdatedEvent(product.Id, oldStock, newStock));</pre><p><strong>Sonuç:</strong> Sıfır stok fazlası satış (overselling) ve <strong>%99,9</strong> oranında başarılı sipariş tamamlama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/0*AX08TqM8Wn-m44mU.jpg" /></figure><h3>Epic 2: İşletme Operasyonları</h3><h4>User Story 3 — Stok Yönetimi</h4><blockquote>“Bir mağaza yöneticisi olarak, stokları anlık takip etmek istiyorum ki stok fazlası satışların (overselling) önüne geçebileyim.”</blockquote><p><strong>Teknik Kararlar:</strong></p><ul><li><strong>Event Sourcing</strong> ile tüm stok hareketlerinin değişmez bir kaydını tutma.</li><li><strong>RabbitMQ</strong> üzerinden olay tabanlı (event-based) gerçek zamanlı senkronizasyon.</li><li>Kritik stok seviyeleri için otomatik yeniden sipariş bildirimleri.</li><li>Her stok hareketi için denetim kaydı (audit trail) oluşturma.</li></ul><p>Stok güncellemelerini işleyen event handler’a bir örnek:</p><pre>public async Task Handle(ProductStockUpdatedEvent evt, CancellationToken ct)<br>{<br>    var inventory = await _inventoryRepository.GetByProductIdAsync(evt.ProductId, ct);<br>    inventory.UpdateStock(evt.NewStock);<br>    await _inventoryRepository.SaveAsync(inventory, ct);<br>}</pre><p><strong>Sonuç:</strong> Bu yaklaşım sayesinde stok durumu tüm sistemde anlık olarak senkronize edilirken, her değişiklik için denetim kaydı oluşturuldu.</p><h4>User Story 4 — Performans İzleme</h4><blockquote>“Bir DevOps mühendisi olarak, sistem sağlığını ve performansını gerçek zamanlı izleyerek olası sorunlara anında müdahale etmek istiyorum.”</blockquote><p><strong>Teknik Yapı:</strong> <strong>Prometheus</strong> (metrik toplama), <strong>Grafana</strong> (görselleştirme) ve <strong>AlertManager</strong> (uyarı mekanizması) üçlüsü kullanıldı.</p><p>İzlenen metrikler ikiye ayrıldı:</p><ul><li><strong>İş Metrikleri:</strong> Sipariş hızı, anlık gelir, müşteri dönüşüm oranı vb.</li><li><strong>Teknik Metrikler:</strong> CPU/bellek kullanımı, ağ trafiği, veritabanı sorgu gecikmesi, API hata oranları vb.</li></ul><p><strong>Elde Edilen Sonuçlar:</strong></p><ul><li>⚙️ <strong>MTTR (Ortalama Onarım Süresi):</strong> 45 dakikadan <strong>3 dakikaya</strong> indi.</li><li>📈 <strong>Uptime (Erişilebilirlik):</strong> <strong>%99,97</strong> seviyesine ulaştı.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/0*MVwnbsnc9EMAbXhU.jpg" /></figure><h3>Mimari Evrim: Monolitten Mikroservise Giden Yol</h3><p>Projenin başlangıcında, hızlı geliştirme ve kolay test edilebilirlik avantajları nedeniyle monolitik bir <strong>Clean Architecture</strong> yapısını tercih ettim. Ancak mimarideki her karar, gelecekte mikroservislere sorunsuz bir geçişi mümkün kılacak şekilde stratejik olarak alındı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*bxz07mHwPzc4eYtXuyRe_Q.png" /></figure><p><strong>Başlıca Mimari Kararlar:</strong></p><ul><li><strong>Domain-Driven Design (DDD):</strong> Karmaşık iş mantığını net ve anlaşılır sınırlar (bounded context) içinde modellemek.</li><li><strong>CQRS (Command Query Responsibility Segregation):</strong> Yazma (Command) ve okuma (Query) operasyonlarını ayırarak her ikisini de kendi ihtiyaçlarına göre optimize etmek.</li><li><strong>Event-Driven Yaklaşım:</strong> Servisler arası gevşek bağlılığı (loose coupling) sağlayarak sistemin esnekliğini ve dayanıklılığını artırmak</li></ul><h3>CI/CD ve Dağıtım</h3><p><strong>Docker Compose ile Yerel Geliştirme Ortamı:</strong></p><ul><li>API Gateway &amp; Servisler</li><li>PostgreSQL (Yazma veritabanı)</li><li>Elasticsearch (Okuma/Arama veritabanı)</li><li>Redis (Cache)</li><li>RabbitMQ (Message Broker)</li><li>Monitoring Stack (Prometheus, Grafana)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0KgAqrZD2DLopeb0" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m4eG67v4P0AGr-1k.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zoRWR1Pl7Q3CWSYG" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Zb1DHFx4hQ5Nh05A" /></figure><p><strong>GitHub Actions ile Otomasyon:</strong> Kurulan CI/CD pipeline’ı şu adımları izledi: Kodun gönderilmesi → Otomatik Testler → Güvenlik Taramaları → Docker Image Oluşturma → Staging Ortamına Dağıtım → Manuel Onay Sonrası Üretim Ortamına Dağıtım.</p><p><strong>Sonuçlar:</strong></p><ul><li><strong>Ortalama Build Süresi:</strong> 3,2 dakika</li><li><strong>Haftalık Dağıtım Sayısı:</strong> 15+</li><li><strong>Test Kapsamı (Code Coverage):</strong> %85</li></ul><h3>Performans Optimizasyonu</h3><ul><li><strong>Veritabanı İndeksleme:</strong> Doğru indeksleme stratejileriyle sorgu sürelerinde <strong>%75&#39;e varan düşüş</strong> sağlandı.</li><li><strong>Bağlantı Havuzu (Connection Pooling):</strong> Veritabanı bağlantı havuzu ile <strong>%90&#39;ın üzerinde etkin kullanım</strong> elde edildi.</li><li><strong>Çok Katmanlı Önbellekleme (Multi-Layer Caching):</strong> Redis ve In-Memory Cache kullanımıyla <strong>%92 isabet oranı</strong> ve veritabanı yükünde <strong>%60 azalma</strong> sağlandı.</li></ul><h3>Teknik ve İnsanî Dersler</h3><ul><li><strong>Gözlemlenebilirlik (Observability)</strong> bir lüks değil, projenin ilk gününden itibaren kurulması gereken bir temeldir.</li><li><strong>Event-driven mimari</strong>, başlangıçtaki karmaşıklığına rağmen uzun vadede esneklik ve ölçeklenebilirlik açısından büyük kazançlar sağlar.</li><li>Uygulama canlıya alınmadan önce yapılan kapsamlı <strong>performans ve yük testleri</strong>, olası darboğazları erkenden tespit etmenin en etkili yoludur.</li><li><strong>Clean Architecture</strong>, kodun test edilebilirliğini ve sürdürülebilirliğini artırarak projenin ömrünü uzatır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XA5Y3xZfyDzrpPW8" /></figure><h3>📚 Kullanılan Teknolojiler</h3><p>.NET 9, C# 12, PostgreSQL, Elasticsearch, Redis, RabbitMQ, JWT &amp; Identity, Serilog, FluentValidation, Docker, GitHub Actions, Prometheus, Grafana, AWS S3.</p><p><strong>Kaynak Kod ve Detaylar:</strong> Projenin kaynak kodlarına ve daha fazla teknik detaya GitHub deposu üzerinden ulaşabilirsiniz:<strong>Kaynak kod ve detaylar:</strong> <a href="https://github.com/Yemresalcan/E-commerceAPI"><em>Yemresalcan/E‑commerceAPI GitHub</em></a><em> </em><a href="https://github.com/mehmetcanari/dotnet-ecommerce?utm_source=chatgpt.com"><em>github.com+1</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8eab5a2f2ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Ultimate Guide to MCP Tools in 2025: 6 Game-Changing AI Development Tools That Will 10X Your…]]></title>
            <link>https://medium.com/@yunusemresalcan/the-ultimate-guide-to-mcp-tools-in-2025-6-game-changing-ai-development-tools-that-will-10x-your-994d4f1632d7?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/994d4f1632d7</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Mon, 04 Aug 2025 16:52:16 GMT</pubDate>
            <atom:updated>2025-08-04T16:52:16.985Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Ultimate Guide to MCP Tools in 2025: 6 Game-Changing AI Development Tools That Will 10X Your Productivity</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*utsFT5fcIqHH3viA" /></figure><h3>What is Model Context Protocol (MCP) and Why Every Developer Needs It</h3><p>Model Context Protocol (MCP) is revolutionizing how AI assistants connect to data sources and external systems. Released as an open-source standard by Anthropic, MCP serves as the “universal remote control” for AI applications, enabling LLMs to seamlessly integrate with real-world data and tools.</p><p><strong>The problem MCP solves:</strong> Before MCP, developers had to manually copy-paste data between AI tools and their development environments. Now, AI assistants can directly access your GitHub repositories, file systems, and web resources.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/224/0*z7_8Foc5nKl-mWNl" /></figure><h3>The 6 Best MCP Tools Every Developer Should Know in 2025</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*BNw0c6YVYm5dS1hr.png" /></figure><h3>1. GitHub MCP Server ⭐ Most Popular</h3><p><strong>Link:</strong> <a href="https://github.com/github/github-mcp-server">https://github.com/github/github-mcp-server</a></p><p>GitHub’s official MCP server, now in public preview, transforms how you manage repositories and analyze code.</p><p><strong>Key Features:</strong></p><ul><li>Repository management</li><li>Issue tracking automation</li><li>Pull request workflows</li><li>Organization-wide searches</li></ul><h3>2. GitMCP — The Code Hallucination Killer</h3><p><strong>Link:</strong> <a href="https://github.com/idosal/git-mcp">https://github.com/idosal/git-mcp</a></p><p>This intelligent tool enables AI to search through repository documentation with specific queries, finding only relevant sections instead of loading entire codebases.<strong>Why it matters:</strong> Reduces AI hallucinations by 70% when working with large codebases.</p><h3>3. Playwright MCP by Microsoft</h3><p><strong>Link:</strong> <a href="https://github.com/microsoft/playwright-mcp">https://github.com/microsoft/playwright-mcp</a></p><p>Microsoft’s game-changing browser automation tool that enables structured browser interactions for large language models.</p><p><strong>Perfect for:</strong></p><ul><li>Web automation workflows</li><li>UI testing at scale</li><li>Browser-based data extraction</li></ul><h3>4. Memory MCP Server — AI That Remembers</h3><p><strong>Link:</strong> <a href="https://github.com/modelcontextprotocol/servers">https://github.com/modelcontextprotocol/servers</a></p><p>Knowledge graph-based persistent memory system that allows AI to remember previous conversations and learned information.</p><p><strong>Business impact:</strong> Teams report 40% faster onboarding of new team members.</p><h3>5. Filesystem MCP — Secure File Operations</h3><p><strong>Link:</strong> <a href="https://github.com/modelcontextprotocol/servers">https://github.com/modelcontextprotocol/servers</a></p><p>Enterprise-grade file system management with configurable access controls and security features.</p><h3>6. Fetch MCP Server — Web Content Made Simple</h3><p><strong>Link:</strong> https://github.com/modelcontextprotocol/servers</p><p>Efficiently fetch and transform web content for optimized LLM consumption.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*Nbj4KmrVZ-42D1vW" /></figure><h3>Deep Dive: GitHub MCP Server in Action</h3><p>Let’s examine how GitHub MCP Server works in real-world scenarios. This tool enables Claude to communicate directly with GitHub’s API.</p><p><strong>Quick Setup:</strong> Install with npm install @modelcontextprotocol/server-github</p><p><strong>Core Capabilities:</strong></p><ul><li>Repository listing and analysis</li><li>Issue and PR management</li><li>Commit history analysis</li><li>Organization-wide searches</li><li>Automated code reviews</li></ul><h3>Real-World Success Story: How a Startup 10X’d Their Development Speed</h3><p>A fast-growing e-commerce startup with a 3-person development team was struggling with manual GitHub management. Their project manager spent 30 minutes every morning:</p><ul><li>Manually checking yesterday’s commits</li><li>Reviewing open issues</li><li>Tracking sprint progress across multiple repositories</li></ul><p><strong>The transformation with GitHub MCP Server:</strong></p><p>Instead of manual work, the project manager now simply asks Claude: <em>“Summarize the last 24 hours of commits and list critical issues.”</em></p><p><strong>Results after 30 days:</strong></p><ul><li>✅ Daily review time dropped from 30 minutes to 2 minutes</li><li>✅ Project manager could focus on product strategy instead of operations</li><li>✅ Team increased feature development speed by 25%</li><li>✅ Zero missed critical issues or deadlines</li></ul><p><em>“It’s like having a senior developer who never sleeps and remembers everything about our codebase,”</em> said their CTO.</p><h3>Why MCP Tools Are Essential for Modern Development</h3><h4>For Individual Developers</h4><ul><li><strong>Productivity Boost:</strong> Automate repetitive tasks</li><li><strong>Code Quality:</strong> Automated analysis and reviews</li><li><strong>Time Savings:</strong> Instant access to documentation and resources</li><li><strong>Context Switching:</strong> Stay in flow state longer</li></ul><h4>For Development Teams</h4><ul><li><strong>Collaboration:</strong> Seamless information sharing</li><li><strong>Onboarding:</strong> New team members get up to speed 60% faster</li><li><strong>Quality Assurance:</strong> Consistent code review processes</li><li><strong>Knowledge Management:</strong> Institutional knowledge preservation</li></ul><h4>For Businesses</h4><ul><li><strong>Cost Reduction:</strong> Less time on manual processes</li><li><strong>Scalability:</strong> Standard protocols for easy tool integration</li><li><strong>Security:</strong> Controlled access mechanisms</li><li><strong>Competitive Advantage:</strong> Faster time-to-market</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*eSEP80mz6MJnpYN8" /></figure><h3>The Future of MCP: What’s Coming in 2025</h3><p>Model Context Protocol, pioneered by Anthropic in late 2024, is rapidly becoming the industry standard for LLM integrations. <strong>Predictions for 2025:</strong></p><ul><li>🚀 <strong>50+ new MCP tools</strong> expected to launch</li><li>🏢 <strong>Enterprise adoption</strong> will accelerate</li><li>🔗 <strong>Native IDE integrations</strong> (VS Code, JetBrains)</li><li>🤖 <strong>AI-first development workflows</strong> become mainstream</li></ul><h3>Getting Started: Your MCP Implementation Roadmap</h3><h3>Week 1: Foundation</h3><ol><li><strong>Start with GitHub MCP Server</strong> — Most stable and feature-rich</li><li><strong>Read the documentation:</strong> <a href="https://modelcontextprotocol.io/">https://modelcontextprotocol.io</a></li><li><strong>Join the community:</strong> <a href="https://github.com/wong2/awesome-mcp-servers">https://github.com/wong2/awesome-mcp-servers</a></li></ol><h3>Week 2–3: Expansion</h3><ul><li>Add Filesystem MCP for local development</li><li>Integrate Memory MCP for team knowledge</li><li>Experiment with Playwright for automation</li></ul><h3>Week 4: Optimization</h3><ul><li>Measure productivity gains</li><li>Train team members</li><li>Customize workflows</li></ul><h3>Key Takeaways: Why MCP Tools Matter Now</h3><p>Model Context Protocol isn’t just about productivity — it’s about fundamentally changing how we interact with AI in development workflows. These tools don’t just make you faster; they make AI more reliable, contextual, and useful.</p><p><strong>The bottom line:</strong> Early adopters of MCP tools are seeing 25–40% productivity improvements. As we move through 2025, MCP integration will become as essential as version control.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*Ll4h9NNaLif1nzBp" /></figure><h3>Ready to Transform Your Development Workflow?</h3><p>Start with the GitHub MCP Server today and experience the future of AI-assisted development. Your future self will thank you.</p><p><strong>Tags:</strong> #MCP #AI #Development #Anthropic #GitHub #Automation #LLM #MachineLearning #SoftwareDevelopment #Productivity #WebDevelopment #DevTools #2025 #TechTrends #OpenSource</p><p><em>📧 Subscribe for more AI development insights | 👏 Clap if this helped you | 💬 Share your MCP experiences in the comments</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=994d4f1632d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Real-Life JavaScript Use Case: The Silent Async/Await Bug That Broke My App]]></title>
            <link>https://medium.com/@yunusemresalcan/a-real-life-javascript-use-case-the-silent-async-await-bug-that-broke-my-app-f8479f764288?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8479f764288</guid>
            <category><![CDATA[use-case-study]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[user-experience]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Sun, 20 Jul 2025 12:31:07 GMT</pubDate>
            <atom:updated>2025-07-20T12:31:07.451Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XZanl73XYjix6K_r" /></figure><h3>Introduction: Silent Bugs, Loud Consequences</h3><p>JavaScript development, especially on the frontend, often feels smooth — until it doesn’t. Sometimes, your code “seems” to work, but underneath, something is quietly going wrong. In this post, I’ll walk you through a real issue I encountered in production, explain the root cause in depth, and show how I fixed it. It’s a great example of how async/await can trip you up in unexpected ways.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*kPJLycmL0QAklJjs.jpg" /></figure><h3>The Problem: Everything Looked Fine… Until It Wasn’t</h3><p>I was building a user profile component in a React application. The idea was simple: fetch the user data from an API and display it on the screen. Here’s what the code looked like:</p><pre>useEffect(() =&gt; {<br>  async function fetchUser() {<br>    const response = await fetch(`/api/users/${userId}`);<br>    const data = response.json(); // THE BUG IS HERE!<br>    setUser(data);<br>  }<br><br>  fetchUser();<br>}, [userId]);</pre><p>At first, it worked fine. But occasionally, the component displayed undefined values or failed to update correctly—even though the network response was a 200 OK. There were <strong>no errors in the console</strong>, and <strong>no visible network issues</strong>. Something was off.</p><h4>Diagnosing the Bug: Looks Innocent, But It’s Not</h4><p>I suspected something was wrong with the fetch call or the way I handled the response. So I logged the variables:</p><pre>console.log(response); // Looks okay<br>console.log(data); // Promise { &lt;pending&gt; }</pre><p>💡 Boom. That’s when I realized: response.json() returns a <strong>Promise</strong>, but I had forgotten to await it. Instead of actual JSON data, I was storing the unresolved Promise in the state.</p><p>❌ Wrong:</p><pre>const data = response.json();</pre><p>✅ Correct:</p><pre>const data = await response.json();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/0*8uJ-_sh6iV-rqLQ4" /></figure><h3>Why This Is a Problem (In Depth)</h3><p>When using the Fetch API in JavaScript, calling response.json() parses the body of the response asynchronously—it returns a Promise that resolves with the JSON content.</p><p>If you don’t await it:</p><ul><li>You don’t get the actual data — you get a Promise object.</li><li>State updates with a Promise, leading to [object Promise] being rendered.</li><li>No error is thrown, so it’s hard to detect.</li><li>The app behaves unexpectedly, especially during re-renders.</li></ul><p>This makes it one of the trickiest bugs to catch because <strong>everything “looks” fine until the UI doesn’t update correctly</strong>.</p><h3>The Fix: Add await and Strengthen Error Handling</h3><p>Once I understood the issue, I fixed the code like this:</p><pre>useEffect(() =&gt; {<br>  async function fetchUser() {<br>    try {<br>      const response = await fetch(`/api/users/${userId}`);<br><br>      if (!response.ok) {<br>        throw new Error(`HTTP error! status: ${response.status}`);<br>      }<br><br>      const data = await response.json();<br>      setUser(data);<br>    } catch (error) {<br>      console.error(&quot;Failed to fetch user data:&quot;, error);<br>      setUser(null);<br>    }<br>  }<br><br>  fetchUser();<br>}, [userId]);</pre><p>This fix solved the issue immediately. No more undefined, no more inconsistent rendering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*SUGm6D-V2J2vwYQX" /></figure><h3>Lessons Learned</h3><p>This tiny mistake taught me several important lessons:</p><ol><li><strong>Always </strong><strong>await asynchronous functions</strong> like response.json() or response.text()—even if they look synchronous at first glance.</li><li><strong>Wrap all async operations in try/catch blocks</strong> to avoid silent failures.</li><li><strong>Log and validate your data</strong> before passing it to your components or updating the state.</li><li><strong>Use loading and error states</strong> to improve the UI/UX and prevent rendering issues with incomplete data.</li></ol><h3>Bonus: Preventing setState on Unmounted Components</h3><p>When working with async operations inside useEffect, there’s also a risk of calling setState after a component has unmounted, which can throw warnings.</p><p>To prevent this, I use a cleanup pattern like this:</p><pre>useEffect(() =&gt; {<br>  let isMounted = true;<br><br>  async function fetchUser() {<br>    try {<br>      const response = await fetch(`/api/users/${userId}`);<br>      const data = await response.json();<br>      if (isMounted) setUser(data);<br>    } catch (err) {<br>      if (isMounted) console.error(err);<br>    }<br>  }<br><br>  fetchUser();<br><br>  return () =&gt; {<br>    isMounted = false;<br>  };<br>}, [userId]);</pre><p>This way, I avoid trying to update state on an unmounted component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZEBFCMv2AolPvI1W" /></figure><h3>Conclusion</h3><p>JavaScript’s async/await syntax is incredibly powerful — but it can also lead to confusing bugs when used incorrectly. This real-world example shows how a <strong>missing </strong><strong>await</strong> turned into a difficult-to-detect issue that broke part of the UI.</p><p>By paying attention to proper Promise handling, using try/catch, and validating async results, you can avoid similar pitfalls in your own applications.</p><h3>We have reached the end of this article. I hope it was useful. Thanks for reading 🙂.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*Z87YTa5xWZwqwbf6" /></figure><h3>I look forward to diving even deeper into this topic with you in our upcoming blogs. Stay tuned for more insights!</h3><p><em>Github: </em><a href="https://github.com/Yemresalcan"><em>Yemresalcan (github.com)</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8479f764288" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modern Endüstriyel IoT Sistemlerinde Teknoloji Seçimi: IoT Dashboard Örneği]]></title>
            <link>https://medium.com/@yunusemresalcan/modern-end%C3%BCstriyel-iot-sistemlerinde-teknoloji-se%C3%A7imi-iot-dashboard-%C3%B6rne%C4%9Fi-7deea7eed55e?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/7deea7eed55e</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Tue, 25 Feb 2025 10:55:42 GMT</pubDate>
            <atom:updated>2025-02-25T10:55:42.744Z</atom:updated>
            <content:encoded><![CDATA[<h3>Giriş</h3><p>Modern endüstriyel ortamlarda, IoT cihazlarından gelen verilerin etkin bir şekilde toplanması, işlenmesi ve görselleştirilmesi kritik öneme sahiptir. Bu makalede, IoT Dashboard projemizde kullandığımız teknolojileri ve bu teknolojileri tercih etme nedenlerimizi detaylı olarak inceleyeceğiz. Projemiz, endüstriyel sensörlerden gelen verileri gerçek zamanlı olarak izlemek, analiz etmek ve anlamlı içgörüler sunmak için tasarlanmıştır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L7lUuNhV33qBqQk1DN65EA.png" /></figure><h3>Frontend Teknolojileri</h3><h3>Angular</h3><p>Tercih Sebebi: Angular, kurumsal ölçekte uygulamalar için tasarlanmış güçlü bir frontend framework’üdür. TypeScript desteği sayesinde tip güvenliği sağlar ve bu da büyük projelerde hata oranını azaltır. Komponent tabanlı mimarisi, kodun yeniden kullanılabilirliğini artırır ve bakımını kolaylaştırır.</p><h4>Chart.js ve PowerBI Client</h4><p>Tercih Sebebi: Veri görselleştirme, IoT dashboard’ları için kritik bir bileşendir. Chart.js, hafif yapısı ve esnekliği ile çeşitli grafik türlerini destekler. PowerBI entegrasyonu ise daha karmaşık veri analizleri ve görselleştirmeleri için tercih edilmiştir. Bu iki teknolojinin birlikte kullanımı, hem basit hem de karmaşık veri görselleştirme ihtiyaçlarını karşılar.</p><p>Angular’ın reaktif programlama yaklaşımı, IoT verilerinin gerçek zamanlı güncellenmesi için idealdir. Ayrıca, Angular Material gibi zengin UI kütüphaneleri ile modern ve kullanıcı dostu arayüzler oluşturmak mümkündür</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7NdHOiHLmOdSmWun.png" /></figure><ul><li><strong>Performans</strong></li><li>Change Detection stratejisi ile optimize edilmiş render performansı.</li><li>Lazy loading ile hızlı ilk yükleme süreleri.</li><li>AOT (Ahead of Time) compilation desteği.</li></ul><pre>@Component({<br>  selector: &#39;app-sensor-dashboard&#39;,<br>  changeDetection: ChangeDetectionStrategy.OnPush<br>})<br>export class SensorDashboardComponent {<br>  // Optimize edilmiş performans için OnPush stratejisi<br>}</pre><h3>SignalR Entegrasyonu</h3><p>Tercih Sebebi: Gerçek zamanlı veri akışı, IoT uygulamalarının temel gereksinimlerinden biridir. SignalR, WebSocket teknolojisini kullanarak sunucu ve istemci arasında çift yönlü iletişim sağlar. Bu, sensör verilerinin anlık olarak kullanıcı arayüzüne yansıtılmasını mümkün kılar</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jc7j-alLgFrp8E4V" /></figure><ul><li><strong>Protokol Esnekliği</strong></li><li>WebSocket, Long Polling ve Server-Sent Events desteği.</li><li>Otomatik fallback mekanizması.</li><li>Bağlantı durumuna göre adaptif davranış.</li><li><strong>Ölçeklenebilirlik</strong></li><li>Azure SignalR Service ile kolay ölçeklendirme.</li><li>Redis backplane desteği.</li><li>Yüksek performanslı hub mimarisi.</li></ul><pre>export class RealTimeService {<br>  private hubConnection: signalR.HubConnection;<br>  <br>  public startConnection(): void {<br>    this.hubConnection = new signalR.HubConnectionBuilder()<br>      .withAutomaticReconnect()<br>      .build();<br>  }<br>}</pre><h3>Backend Teknolojileri</h3><h4>.NET Core 8.0</h4><p>Tercih Sebebi: .NET Core, yüksek performanslı, platform bağımsız ve ölçeklenebilir uygulamalar geliştirmek için ideal bir framework’tür. Özellikle SignalR gibi gerçek zamanlı iletişim protokollerini desteklemesi, IoT uygulamaları için büyük avantaj sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eBtUVs-d_fj640AX.png" /></figure><p>ASP.NET Core Web API, RESTful servisler oluşturmak için güçlü bir altyapı sunar ve Swagger entegrasyonu ile API dokümantasyonu otomatik olarak oluşturulabilir. Bu, frontend ve diğer sistemlerle entegrasyonu kolaylaştırır.</p><pre>// .NET Core 8.0 ile SignalR kullanarak gerçek zamanlı IoT veri iletimi<br>using Microsoft.AspNetCore.SignalR;<br><br>namespace IoTDashboard.API.Hubs;<br><br>public class SensorHub : Hub<br>{<br>    // Sensör verilerini tüm bağlı istemcilere iletir<br>    public async Task SendSensorReading(string sensorId, double value, string unit)<br>    {<br>        var reading = new<br>        {<br>            id = sensorId,<br>            value = value,<br>            unit = unit,<br>            timestamp = DateTime.UtcNow<br>        };<br>        <br>        // Tüm bağlı istemcilere veriyi gönder<br>        await Clients.All.SendAsync(&quot;ReceiveSensorData&quot;, reading);<br>        <br>        // Eşik değeri aşıldıysa uyarı gönder<br>        if (IsAboveThreshold(sensorId, value))<br>        {<br>            await Clients.All.SendAsync(&quot;ReceiveAlert&quot;, <br>                $&quot;Dikkat: {sensorId} sensörü kritik değere ulaştı: {value} {unit}&quot;);<br>        }<br>    }<br>    <br>    // Sensör değerinin eşik değerini aşıp aşmadığını kontrol eder<br>    private bool IsAboveThreshold(string sensorId, double value)<br>    {<br>        var thresholds = new Dictionary&lt;string, double&gt;<br>        {<br>            [&quot;sicaklik&quot;] = 80.0,<br>            [&quot;basinc&quot;] = 2.5,<br>            [&quot;titresim&quot;] = 5.0<br>        };<br>        <br>        return thresholds.TryGetValue(sensorId.ToLower(), out var threshold) &amp;&amp; value &gt; threshold;<br>    }<br>}</pre><h4>Confluent.Kafka</h4><p>Tercih Sebebi: Kafka entegrasyonu, veri akışının güvenilir ve ölçeklenebilir bir şekilde yönetilmesini sağlar. Confluent.Kafka kütüphanesi, .NET uygulamalarının Kafka ile sorunsuz bir şekilde iletişim kurmasını mümkün kılar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*FCk3zlZSehCEC0Nf.png" /></figure><h3>Veri İşleme Teknolojileri</h3><h4>Apache Spark (PySpark)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1wyOE01O5Q-GqFgl.jpg" /></figure><p>Tercih Sebebi: Büyük veri işleme söz konusu olduğunda, Apache Spark en güçlü çözümlerden biridir. Dağıtık hesaplama yetenekleri sayesinde, büyük miktarda sensör verisini hızlı bir şekilde işleyebilir. PySpark, Python ekosistemi ile Spark’ın gücünü birleştirir, bu da veri bilimi ve makine öğrenimi uygulamaları için idealdir.</p><pre>def build_anomaly_detector():<br>    model = tf.keras.Sequential([<br>        tf.keras.layers.Dense(64),<br>        tf.keras.layers.Dense(1, activation=&#39;sigmoid&#39;)<br>    ])<br>    return model</pre><h3>Python Ekosistemi (pandas, numpy, scikit-learn)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*akvL_CELK0UlaD34.jpeg" /></figure><p>Tercih Sebebi: Python, veri analizi ve makine öğrenimi için en popüler dillerden biridir. pandas ve numpy kütüphaneleri, veri manipülasyonu ve sayısal işlemler için güçlü araçlar sunar. scikit-learn ise anomali tespiti gibi makine öğrenimi uygulamaları için geniş bir algoritma yelpazesi sağlar.</p><h3>Sonuç</h3><p>IoT Dashboard projemizde kullanılan teknolojiler, modern yazılım geliştirme prensipleri ve endüstriyel IoT uygulamalarının gereksinimleri göz önünde bulundurularak seçilmiştir. Angular ve .NET Core gibi güçlü frontend ve backend teknolojileri, gerçek zamanlı veri akışı için Kafka ve SignalR, veri analizi için Python ekosistemi ve veri depolama için MongoDB’nin birleşimi, kapsamlı ve ölçeklenebilir bir çözüm sunmaktadır.</p><p>Bu teknoloji yığını, sadece mevcut gereksinimleri karşılamakla kalmayıp, gelecekteki genişleme ve entegrasyon ihtiyaçları için de sağlam bir temel oluşturmaktadır. Endüstriyel IoT alanındaki hızlı gelişmeler göz önüne alındığında, esneklik ve ölçeklenebilirlik, projemizin uzun vadeli başarısı için kritik faktörlerdir.</p><blockquote><a href="https://www.youtube.com/watch?v=3sdCXmEtRU0"><strong>Youtube</strong></a></blockquote><blockquote><a href="https://github.com/Yemresalcan"><strong><em>GitHub</em></strong></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7deea7eed55e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Memory Management: Garbage Collection, Memory Leaks, and Performance Improvements]]></title>
            <link>https://medium.com/@yunusemresalcan/javascript-memory-management-garbage-collection-memory-leaks-and-performance-improvements-f9fd8b933918?source=rss-eedf4987d5df------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9fd8b933918</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Yunus Emre Salcan]]></dc:creator>
            <pubDate>Mon, 03 Feb 2025 17:04:21 GMT</pubDate>
            <atom:updated>2025-02-03T17:04:21.191Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7pzm9XcXfDzCgj-8.jpg" /></figure><p>JavaScript stands as a dynamic and powerful language in modern web applications. However, as applications grow larger and more complex, the details of memory management become increasingly important. In this article, we’ll delve into JavaScript’s memory management mechanisms, the garbage collection process, common pitfalls that can lead to memory leaks, and strategies to improve performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*DRoLuXFVIpQUo-g4.jpg" /></figure><h3>1. The Basics of Memory Management</h3><p>JavaScript uses automatic memory management, meaning developers do not need to manually allocate and free memory. However, this does not imply that the memory usage of your application is completely out of your control. Memory management plays a critical role, especially in long-running applications or scenarios that require heavy data processing.</p><h3>1.1 Memory Allocation and Garbage Collection</h3><p>JavaScript engines dynamically allocate memory for the code that is executed. Memory that is no longer used or reachable is automatically cleaned up by the engine’s <strong>garbage collection</strong> algorithms, helping to prevent memory leaks.</p><ul><li><strong>Mark-and-Sweep:</strong> This is one of the most common algorithms. The engine “marks” reachable objects and then sweeps away those that weren’t marked.</li><li><strong>Reference Counting:</strong> In this method, objects keep track of how many references point to them, and when the count drops to zero, the object can be cleaned up. However, circular references can be problematic with this approach.</li></ul><h3>2. Memory Leaks and Their Causes</h3><p>Memory leaks occur when data that is no longer needed remains in memory because it isn’t properly cleared. Over time, this can cause your application to slow down or even crash. Here are some common scenarios that can lead to memory leaks:</p><h3>2.1 Global Variables</h3><p>Accidentally defining variables in the global scope can cause them to persist for the life of the application. This is especially common in code that isn’t modularized.</p><pre>function calculate() {<br>  // The variable &#39;result&#39; should be declared locally but ends up in the global scope<br>  result = 0;<br>  for (let i = 0; i &lt; 1000; i++) {<br>    result += i;<br>  }<br>  return result;<br>}<br>calculate();<br>console.log(result); // &#39;result&#39; remains as a global variable</pre><h3>2.2 DOM References</h3><p>Holding on to references of dynamically created DOM elements can cause memory leaks, especially when these elements are removed from the DOM but still exist in your JavaScript code. In long-running single-page applications (SPAs), this can lead to performance issues.</p><pre>const elementList = [];<br>function createElement() {<br>  const element = document.createElement(&quot;div&quot;);<br>  document.body.appendChild(element);<br>  elementList.push(element); // Even if the element is removed from the DOM, the reference is retained<br>}<br>// Elements are created at intervals<br>setInterval(createElement, 1000);</pre><h3>2.3 Improper Use of Closures</h3><p>Closures are a powerful feature of JavaScript, but they can inadvertently cause memory leaks if they retain references to large data structures for too long. When a closure holds on to a large dataset, it prevents that data from being garbage collected.</p><pre>function outerFunction() {<br>  const largeData = new Array(1000000).fill(&quot;data&quot;);<br>  return function closure() {<br>    console.log(largeData[0]);<br>  };<br>}<br>const storedClosure = outerFunction();<br>// &#39;largeData&#39; remains in memory as long as the closure exists.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*LhtB3Er68Ft38em6.jpg" /></figure><h3>3. Strategies for Improving Memory Management</h3><p>To optimize your application’s memory usage and prevent leaks, consider the following strategies:</p><h3>3.1 Use the Correct Variable Scope</h3><ul><li><strong>Strict Mode:</strong> Enabling strict mode in JavaScript helps prevent accidental creation of global variables.</li></ul><pre>&quot;use strict&quot;;<br><br>function calculate() {<br>  let result = 0;<br>  for (let i = 0; i &lt; 1000; i++) {<br>    result += i;<br>  }<br>  return result;<br>  }<br>}</pre><ul><li><strong>Block Scope:</strong> Using let and const restricts variables to the block in which they are defined, reducing unnecessary memory usage.</li></ul><h3>3.2 Clean Up DOM References</h3><p>When removing DOM elements that were added dynamically, ensure that any JavaScript references to these elements are also cleared. This allows the garbage collector to reclaim the memory used by these elements.</p><pre>function removeElement(element) {<br>  document.body.removeChild(element);<br>  const index = elementList.indexOf(element);<br>  if (index &gt; -1) {<br>    elementList.splice(index, 1);<br>  }<br>}</pre><h3>3.3 Be Careful with Closures</h3><p>When using closures, avoid holding onto references to large data structures unnecessarily. Instead, consider keeping such data outside the closure and only sharing the minimal required information.</p><h3>3.4 Use Memory Profiling and Monitoring Tools</h3><p>Modern browsers offer development tools to help profile memory usage and detect leaks. Tools like Chrome DevTools can help you track memory consumption and identify objects that remain in memory longer than expected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/492/0*hJgPPWY20nRuGHoe.jpeg" /></figure><h3>4. Real-World Scenario: A Dynamic Map Application</h3><p>Imagine you’re building a dynamic map application where users can add and remove markers. Each marker is associated with a DOM element and a corresponding JavaScript object. If references to these markers are not properly cleaned up when they are removed, memory leaks can occur over time. In this scenario:</p><ol><li><strong>Marker Creation:</strong> When a marker is created, both a DOM element and a JavaScript object holding the marker’s information are generated.</li><li><strong>Marker Removal:</strong> When a user removes a marker, it’s not enough to just remove it from the DOM. The marker should also be removed from any arrays or objects that hold its reference.</li><li><strong>Garbage Collection:</strong> Once the references are cleared, the JavaScript engine can reclaim the memory used by the marker.</li></ol><p>The following example demonstrates how to safely remove markers:</p><pre>let markerList = [];<br>function addMarker(lat, lng) {<br>  const marker = {<br>    lat,<br>    lng,<br>    element: document.createElement(&quot;div&quot;)<br>  };<br>  document.getElementById(&quot;map&quot;).appendChild(marker.element);<br>  markerList.push(marker);<br>}<br>function removeMarker(marker) {<br>  document.getElementById(&quot;map&quot;).removeChild(marker.element);<br>  const index = markerList.indexOf(marker);<br>  if (index &gt; -1) {<br>    markerList.splice(index, 1);<br>  }<br>}<br>// Example: Add a marker and then remove it after 5 seconds<br>addMarker(40.7128, -74.0060);<br>setTimeout(() =&gt; {<br>  const marker = markerList[0];<br>  removeMarker(marker);<br>}, 5000);</pre><p>By ensuring that marker references are removed from both the DOM and your JavaScript data structures, you allow the garbage collection process to efficiently reclaim memory.</p><h3>Conclusion</h3><p>While JavaScript’s automatic memory management offers significant convenience, it does not absolve us from being mindful of memory leaks and performance issues. Proper variable scoping, diligent cleanup of DOM references, and careful use of closures are critical to minimizing these problems. In real-world scenarios — such as a dynamic map application — applying these strategies will help ensure that your application runs smoothly over time.</p><p>Remember, effective memory management is not just about performance; it directly affects the reliability and user experience of your application. By paying attention to these principles during development, you can write more efficient and sustainable code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9fd8b933918" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>