<?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[Softtech - Medium]]></title>
        <description><![CDATA[Softtech is a leading Turkish technology company with highly skilled and expert teams dedicated to driving innovation through advanced AI solutions. - Medium]]></description>
        <link>https://medium.com/softtechas?source=rss----78ea619c4d2c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Softtech - Medium</title>
            <link>https://medium.com/softtechas?source=rss----78ea619c4d2c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 09:01:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/softtechas" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Biggest AI Failures Were Not Failures of AI]]></title>
            <link>https://medium.com/softtechas/the-biggest-ai-failures-were-not-failures-of-ai-12858f24ae8f?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/12858f24ae8f</guid>
            <category><![CDATA[ai-governance]]></category>
            <dc:creator><![CDATA[Sirin Beydilli]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 12:40:50 GMT</pubDate>
            <atom:updated>2026-11-13T12:48:35.201Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>A review of the decade’s most costly incidents suggests that governance, not technology, remains the greatest risk in artificial intelligence.</em></strong></p><p>As someone deeply engaged in AI governance, I have long been fascinated by the question of which artificial intelligence failures have inflicted the greatest business damage in recent years. Beyond the headlines and technical postmortems lies a broader story about accountability, oversight, and the real-world consequences of deploying AI at scale.</p><p>To minimize the bias that can emerge from relying on a single model’s perspective, I posed the same question to several leading AI systems and compared their responses. The synthesis that follows is not the output of any one model, but rather the product of deliberate human review, evaluation, and consolidation. (A small but important reminder that human oversight still matters. 😊)</p><p><strong>Prompt:</strong></p><p><strong><em>“What are the 10 most significant AI failures that have cost companies dearly over the past decade?”</em></strong></p><p>The table below summarizes the cases that emerged most consistently across the responses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2tUAdwkQtTghRW_KaAuChg.png" /><figcaption>Table compiled from responses of several AI systems and reviewed by the author. Dates and figures are indicative; please refer to the sources listed below for verified details. Created with Gamma.</figcaption></figure><p>For those whose curiosity extends beyond the examples above, <a href="https://airisk.mit.edu/navigator">MIT AI Risk Navigator</a> is well worth exploring. The MIT AI Risk Initiative (AIRI) provides authoritative data and frameworks to help decision makers across the AI ecosystem identify, prioritize, and manage risks from AI with its comprehensive living database of over 1700 categorized AI risks.</p><p><strong>AI Governance Is Becoming a Procurement Requirement</strong></p><p>In 2024, <strong>Air Canada</strong> lost a tribunal case because its chatbot provided incorrect information to a customer.</p><p><strong>Amazon</strong> abandoned an AI recruiting tool after concerns that it systematically disadvantaged female candidates.</p><p><strong>Samsung</strong> employees reportedly shared sensitive source code and internal information with ChatGPT, triggering company-wide restrictions on generative AI usage.</p><p>3 different organizations.</p><p>3 different industries.</p><p>1 common root cause: <strong>not AI failure but a Governance failure.</strong></p><p>Most AI incidents don’t happen because the algorithm suddenly goes wrong.</p><p>They happen because <strong>organizations fail to define ownership, establish controls, and manage risk before deploying AI.</strong></p><p><strong>Air Canada: When a Chatbot Becomes a Legal Liability (6)</strong></p><p>A customer relied on information provided by Air Canada’s chatbot regarding bereavement fares.</p><p>The information was incorrect.</p><p>The customer challenged the airline, and the tribunal ruled that Air Canada was accountable for the chatbot’s statements.</p><p>The most important takeaway wasn’t the legal dispute itself.</p><p>It was the principle:</p><p><strong>An organization remains accountable, even when the mistake comes from AI.</strong></p><p><strong>What could have helped?</strong></p><ul><li>AI output monitoring</li><li>Human oversight</li><li>AI incident management</li><li>Defined accountability for customer-facing AI systems</li></ul><p><strong>All core governance concepts found in ISO/IEC 42001.</strong></p><p><strong>Amazon: When Bias Becomes a Business Risk (9)</strong></p><p>Amazon’s experimental AI recruiting system learned from historical hiring data and reportedly favored resumes resembling past hiring patterns.</p><p>The company ultimately abandoned the project.</p><p>The financial impact was not a court-imposed penalty.</p><p>The cost was reputational damage, wasted investment, and a public example frequently cited whenever AI bias is discussed.</p><p><strong>What could have helped?</strong></p><ul><li>AI impact assessments</li><li>Fairness and bias evaluations</li><li>Dataset governance</li><li>Continuous monitoring</li></ul><p><strong>Without governance, organizations often discover AI risks after deployment rather than before.</strong></p><p><strong>Samsung: When Employees Become the Risk Surface (5)</strong></p><p>In 2023, Samsung reportedly discovered that employees had entered confidential source code and internal information into ChatGPT.</p><p>The incident led to restrictions on generative AI use inside the organization.</p><p>The issue wasn’t that ChatGPT malfunctioned.</p><p>The issue was that employees had no clearly established boundaries regarding what data could and could not be shared.</p><p><strong>What could have helped?</strong></p><ul><li>AI usage policy</li><li>Approved AI tools inventory</li><li>Data classification controls</li><li>Employee awareness and training</li></ul><p><strong>A Pattern Emerges</strong></p><p>Every major AI incident eventually leads to the same questions:</p><ul><li><strong>Who owns the AI system?</strong></li><li><strong>What data is being used?</strong></li><li><strong>Who approved it?</strong></li><li><strong>How is it monitored?</strong></li><li><strong>Who is accountable for outcomes?</strong></li></ul><p>These are not technical questions.</p><p><strong>They are governance questions.</strong></p><p>And governance questions <strong>ultimately become business questions</strong>.</p><p><strong>Why Procurement Teams Are Starting to Ask</strong></p><p>For years, supplier assessments focused on:</p><p>“Are you ISO 27001 certified?”</p><p>The next question is already emerging:</p><p><strong>“How do you govern AI?”</strong></p><p>As harm caused by irresponsible AI use becomes more visible and regulations continue to mature, organizations are becoming increasingly responsible not only for their own AI usage but also for the AI practices of their suppliers.</p><p>Banks, insurers, and heavily regulated sectors are unlikely to accept answers such as:</p><p>“We use AI, but we’re still figuring out the controls.”</p><p>They will increasingly expect evidence of:</p><ul><li>AI policies</li><li>Defined responsibilities</li><li>AI risk assessments</li><li>Human oversight mechanisms</li><li>Ongoing monitoring</li><li>Incident management processes</li></ul><p>In other words, the <strong>foundations of an AI Management System</strong>.</p><p><strong>Final Thought</strong></p><p>The next wave of AI failures is unlikely to be driven by a lack of technical capability. The underlying models will continue to improve. Governance, however, remains far less scalable than technology.</p><p>Organizations that succeed in the age of AI will not simply be those that build or purchase the most advanced systems. They will be those that can demonstrate <strong>disciplined oversight, clear accountability, and effective risk management</strong> across the AI lifecycle.</p><p><strong>In the years ahead, “Do you use AI?” may become one of the least interesting questions organizations are asked. The more important question will be: “How do you govern it?”</strong></p><p>For an increasing number of stakeholders, that answer will matter as much as the technology itself. And increasingly, frameworks such as <strong>ISO/IEC 42001</strong> will serve as the benchmark against which that answer is measured.</p><p><strong>Resources</strong></p><p>1. <a href="https://www.pertamapartners.com/insights/ai-project-failure-case-studies">https://www.pertamapartners.com/insights/ai-project-failure-case-studies</a></p><p>2. <a href="https://www.nbcnewyork.com/news/national-international/apple-250-million-settlement-false-advertising-ai-features-iphone/6498913/">Apple agrees to $250 million settlement over false advertising — NBC New York</a></p><p>3. <a href="https://www.designrush.com/trends/business-consulting/most-expensive-ai-mistakes">https://www.designrush.com/trends/business-consulting/most-expensive-ai-mistakes</a></p><p>4. <a href="https://www.theguardian.com/technology/article/2024/may/17/uk-engineering-arup-deepfake-scam-hong-kong-ai-video">https://www.theguardian.com/technology/article/2024/may/17/uk-engineering-arup-deepfake-scam-hong-kong-ai-video</a></p><p>5. <a href="https://airisk.mit.edu/ai-incidents/768-chatgpt-implicated-in-samsung-data-leak-of-source-code">https://airisk.mit.edu/ai-incidents/768-chatgpt-implicated-in-samsung-data-leak-of-source-code</a></p><p>6. <a href="https://www.canlii.org/en/commentary/doc/2025CanLIIDocs1963#!fragment/zoupio-_Tocpdf_bk_0_2/BQCwhgziBcwMYgK4DsDWszIQewE4BUBTADwBdoAvbRABwEtsBaAfX2zhoBMAzZgI1TMADMwBMASgA0ybKUIQAiokK4AntADkGyREJhcCJSvVadegyADKeUgCF1AJQCiAGScA1AIIA5AMJPJUjA+aFJ2cXEgA">II. Facts — A Most Unhelpful Chatbot: Inaccurate, Misleading Response | Case Comment: Lying Chatbot Makes Airline Liable: Negligent Misrepresentation in Moffatt v Air Canada | CanLII</a></p><p>7. <a href="https://www.autonews.com/volkswagen/ane-vw-cariad-job-cuts-0310/">VW’s Cariad to lay off 1,600 software staff — Automotive News</a></p><p>8. <a href="https://www.grandlinux.com/en/blogs/openai-sora-shutdown.html">OpenAI Shuts Down Sora — When AI Video Is Too Expensive to Sustain | Saeree ERP</a></p><p>9. <a href="https://incidentdatabase.ai/cite/37">Incident 37: Amazon’s Experimental Hiring Tool Allegedly Displayed Gender Bias in Candidate Rankings</a></p><p>10. <a href="https://airisk.mit.edu/ai-incidents/475-mcdonald-s-reportedly-ends-ibm-partnership-after-ai">https://airisk.mit.edu/ai-incidents/475-mcdonald-s-reportedly-ends-ibm-partnership-after-ai</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12858f24ae8f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/the-biggest-ai-failures-were-not-failures-of-ai-12858f24ae8f">The Biggest AI Failures Were Not Failures of AI</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Otomasyonun Sessiz Kahramanı: Redis’in Kuyruk, Kilit ve Koordinasyon Rolü]]></title>
            <link>https://medium.com/softtechas/otomasyonun-sessiz-kahraman%C4%B1-redisin-kuyruk-kilit-ve-koordinasyon-rol%C3%BC-c46b2a929828?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/c46b2a929828</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[redis]]></category>
            <dc:creator><![CDATA[Bahadır Duman]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 07:43:40 GMT</pubDate>
            <atom:updated>2026-11-04T07:43:39.177Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Redis bir otomasyon sisteminde gerçekte ne işe yarıyor ve neden sadece veri tutmaktan ibaret değil?</em></p><p>Redis denince çoğu kişinin aklına cache gelir. Otomasyon sistemlerinde ise Redis daha çok bir <strong>koordinasyon aracı</strong> olarak değer katar: işleri dağıtır, aynı kaydın iki kez işlenmesini engeller, hedef uygulamayı aşırı yüklemekten korur ve worker’ların hayatta olup olmadığını gösterir.</p><p>Bu yazıda Redis’in otomasyonda hangi işleri iyi yaptığını, nasıl kullanılabileceğini ve nerede dikkatli olmak gerektiğini anlatacağım.</p><h4>Otomasyon neden bir koordinasyon problemidir?</h4><p>Otomasyonunuzu tek bir worker üzerinden çalıştırmaktan birden fazla worker’ın görev aldığı dağıtık bir yapıya taşıdığınızda, çözmeniz gereken sorunlar da değişir:</p><ul><li>Hangi iş hangi worker’a atanacak?</li><li>İki worker aynı kaydı almaya çalışırsa ne olacak?</li><li>Bir worker, işi tamamlamadan çökerse o iş nasıl kurtarılacak?</li><li>Hedef uygulama aynı anda kaç oturumu kaldırabilir?</li><li>Sistemde çalışan worker’ların hâlâ aktif olduğu nasıl anlaşılacak?</li></ul><p>Bu soruların ortak noktası, tüm worker’ların erişebildiği, hızlı ve işlemleri atomik biçimde gerçekleştirebilen ortak bir duruma ihtiyaç duymalarıdır. Redis tam olarak bu noktada öne çıkar.</p><h4>Redis neden uygun bir tercih?</h4><p>Redis’i otomasyon sistemlerinde kullanışlı kılan birkaç temel özelliği var:</p><ul><li><strong>Hız:</strong> Verileri bellekte tutarak düşük gecikmeyle işlem yapılmasını sağlar.</li><li><strong>Zengin veri yapıları:</strong> Liste (list), özet tablo (hash), küme (set), sıralı küme (sorted set) ve akış (stream) gibi farklı veri yapılarını destekler.</li><li><strong>Atomik işlemler:</strong> INCR, SET ... NX gibi komutlar tek bir işlem olarak gerçekleştirilir. Böylece eşzamanlı erişimlerde yarış durumlarının (race condition) önüne geçilebilir.</li><li><strong>TTL desteği:</strong> Belirlenen süre sonunda kendiliğinden silinen anahtarlar oluşturulabilir. Bu özellik özellikle kilitler, yaşam sinyalleri ve geçici durum bilgileri için kullanışlıdır.</li><li><strong>Geniş ekosistem:</strong> Yaygın istemci kütüphaneleri ve kolay işletilebilir yapısı sayesinde mevcut sistemlere entegre edilmesi oldukça pratiktir.</li></ul><h4>1. İş kuyruğu</h4><p>Redis’in otomasyon sistemlerindeki en yaygın kullanım alanlarından biri iş kuyruğu oluşturmaktır. İş paketlerini kuyruğa eklersiniz, worker’lar da bu işleri sırayla alarak işler.</p><p>Bu amaçla kullanılabilecek iki temel veri yapısı bulunur:</p><ul><li><strong>List:</strong> En basit kuyruk yaklaşımıdır. Başlangıç seviyesindeki ihtiyaçlar için yeterli olabilir. Ancak worker bir işi kuyruktan aldıktan sonra çökerse iş kaybolabilir. Bunu önlemek için ayrıca bir işleniyor listesi ve başarısız işleri kurtarma mekanizması geliştirmek gerekir.</li><li><strong>Stream:</strong> Daha gelişmiş bir seçenektir. Consumer group desteği sayesinde mesajlar worker’lara dağıtılır. İş tamamlandığında XACK komutuyla onaylanır. Onaylanmayan mesajlar bekleyen mesajlar (pending messages) arasında tutulur. Böylece çöken bir worker’ın tamamlayamadığı işler başka bir worker tarafından devralınabilir.</li></ul><h4>2. Aynı işin birden fazla kez işlenmesini önlemek</h4><p>Redis Stream gibi kuyruk yapılarında bir mesajın birden fazla kez işlenmesi mümkündür. Örneğin bir worker, kendisine atanan işi tamamladıktan hemen sonra fakat mesajı onaylamadan önce çökerse aynı mesaj başka bir worker tarafından yeniden işlenebilir.</p><p>Bu nedenle otomasyon sistemlerini tasarlarken aynı işlemin birden fazla kez gerçekleştirilme ihtimalini göz önünde bulundurmak gerekir.</p><p>Redis, bu durumu kontrol altına almak için basit bir mekanizma sunar. Her işleme benzersiz bir kimlik (transaction ID) atayabilir ve bu kimliği Redis üzerinde saklayabilirsiniz. Böylece bir işlem yeniden kuyruğa düştüğünde, daha önce işlenip işlenmediğini kontrol edebilirsiniz.</p><p>Bunun için SET anahtar değer NX EX süre komutundan yararlanabilirsiniz. Bu komut, yalnızca belirtilen anahtar Redis üzerinde henüz bulunmuyorsa yeni bir kayıt oluşturur. Anahtar zaten mevcutsa yeni kayıt oluşturmaz. Böylece birden fazla worker aynı işlem için kayıt oluşturmaya çalışsa bile yalnızca biri başarılı olur.</p><p>Ancak bu yaklaşımın önemli bir sınırı var: İşlem kaydını ne zaman oluşturduğunuz, sistemin hata durumunda nasıl davranacağını doğrudan etkiler.</p><ul><li><strong>İşlem başlamadan önce kayıt oluşturursanız:</strong> Worker işlemi tamamlayamadan çökerse Redis üzerinde işlem kaydı kalabilir. Bu durumda sistem, işlem daha önce gerçekleştirilmiş gibi davranarak yeniden denemeyi engelleyebilir.</li><li><strong>İşlem tamamlandıktan sonra kayıt oluşturursanız:</strong> Worker, işlemi tamamladıktan sonra fakat Redis’e kayıt yazamadan çökerse aynı işlem yeniden gerçekleştirilebilir.</li></ul><p>Dolayısıyla yalnızca Redis üzerinde işlem kaydı tutmak, yinelenen işlemleri tamamen engellemek için yeterli değildir.</p><p>Özellikle para transferi, ödeme veya geri alınması zor işlemlerde bu sorunun hedef sistem tarafında da çözülmesi gerekir. Bunun için idempotency key adı verilen, aynı isteğin birden fazla kez gönderilmesi durumunda işlemin tekrar gerçekleştirilmesini önleyen benzersiz bir anahtar kullanılabilir.</p><p>Örneğin bir ödeme isteği aynı anahtarla iki kez gönderildiğinde hedef sistem ikinci isteği yeni bir ödeme olarak değerlendirmek yerine ilk işlemin sonucunu döndürebilir.</p><p><strong>Özetle Redis, yinelenen işlemleri tespit etmek ve kontrol altında tutmak için önemli bir araçtır. Ancak işlemin gerçekten yalnızca bir kez gerçekleştirilmesini sağlamak için hedef sistemin de idempotency desteği sunması gerekir.</strong></p><h4>3. Dağıtık kilit</h4><p>Bazı işlemlerin aynı kaynak üzerinde eşzamanlı olarak yürütülmesi istenmez. Örneğin aynı müşteri kaydının, hesabın veya dosyanın iki farklı çalışan tarafından aynı anda işlenmesi veri tutarsızlıklarına neden olabilir.</p><p>Bu yaklaşımda üç ayrıntıya dikkat etmek gerekiyor:</p><ul><li><strong>TTL kullanımı:</strong> Çalışan çökerse kilidin sonsuza kadar açık kalmasını önler. Belirlenen süre sonunda kilit kendiliğinden kaldırılır.</li><li><strong>Benzersiz anahtar değeri (token):</strong> Kilidi yalnızca onu oluşturan çalışanın kaldırabilmesini sağlar. Aksi durumda süresi dolmuş bir kilidi, başka bir çalışanın aldığı yeni kilidi de silerek kaldırabilirsiniz.</li><li><strong>Kilitlerin sınırları:</strong> Dağıtık kilitler mutlak güvence sağlamaz. Özellikle çoğaltma (replication) ve yük devri (failover) senaryolarında iki çalışanın kısa süreliğine aynı kaynağı kullanabilmesi mümkündür. Bu nedenle kritik işlemlerde yalnızca kilit mekanizmasına güvenilmemeli, hedef sistemde de ek kontroller bulunmalıdır.</li></ul><h4>4. Eşzamanlılık sınırı ve hız kontrolü</h4><p>Hedef uygulamaların aynı anda kabul edebileceği oturum sayısı çoğu zaman sınırlıdır.</p><p>Çalışan sayısını artırmak her zaman daha yüksek işlem hızı anlamına gelmez. Aksine, hedef uygulamanın yavaşlamasına, bağlantıları reddetmesine veya oturum hataları vermesine neden olabilir.</p><p>Redis üzerinden merkezi bir eşzamanlılık sınırı belirleyerek bu durumun önüne geçebilirsiniz.</p><p>İlk akla gelen yöntem INCR ve DECR komutlarıyla aktif oturum sayısını takip etmektir. Ancak bu yaklaşımın bir zayıf noktası vardır: Çalışan, oturumu kapatmadan veya sayacı azaltmadan çökerse sayaçta kalan değer zamanla gerçeği yansıtmaz.</p><p>Daha güvenilir bir yaklaşım, kira (lease) mantığıyla çalışmaktır.</p><p>Her çalışan, kullandığı oturum için kısa süreli bir TTL değerine sahip anahtar oluşturur ve aktif olduğu sürece bu anahtarın süresini yeniler. Böylece aktif oturum sayısı, geçerli anahtarlar üzerinden takip edilebilir. Çalışan çökerse anahtarı da belirlenen süre sonunda kendiliğinden silinir.</p><p>Bu yöntem, merkezi eşzamanlılık kontrolünü daha güvenilir hâle getirir.</p><h4>5. Yaşam sinyali ve çalışma durumunun takibi</h4><p>Redis’in bir diğer kullanım alanı da çalışanların sağlık durumunu izlemektir.</p><p>Her çalışan belirli aralıklarla Redis üzerinde kısa süreli bir yaşam sinyali (heartbeat) anahtarı oluşturabilir veya mevcut anahtarın süresini yenileyebilir.</p><p>Bu anahtarın süresi dolarsa ilgili çalışanın artık yanıt vermediği düşünülebilir. Sistemde bu durumu takip eden bir izleyici (watchdog) bulunabilir. İzleyici, çalışanın durumuna göre ilgili işi yeniden kuyruğa alabilir veya bir uyarı oluşturabilir.</p><p>Burada yalnızca çalışanların aktif olup olmadığını takip etmekle yetinmek zorunda değilsiniz.</p><p>İşlerin genel durumunu da Redis hash yapısı üzerinden saklayabilirsiniz:</p><ul><li>Çalışıyor</li><li>Tamamlandı</li><li>Hata aldı</li></ul><p>Bu sayede bir izleme paneli, sistemdeki işlerin ve çalışanların güncel durumunu hızlıca görüntüleyebilir.</p><p>Ancak Redis üzerindeki bu bilgiler operasyonel takip amacıyla kullanılmalı; kalıcı işlem geçmişi ve denetim kayıtları ayrı bir veritabanında tutulmalıdır.</p><h3>6. Önbellekleme</h3><p>Redis’in en bilinen kullanım alanı olan önbelleklemenin otomasyon sistemlerinde de önemli bir yeri var.</p><p>Örneğin:</p><ul><li>LLM yanıtlarının saklanması,</li><li>Sık kullanılan referans verilerinin tutulması,</li><li>Tekrar eden sorguların sonuçlarının önbelleğe alınması.</li></ul><p>Bu konuyu ayrı bir yazıda ele aldım. Ancak burada önemli bir noktaya değinmek istiyorum: Önbellekleme ve kuyruk işlemlerini aynı Redis örneğinde yürütmek her zaman doğru bir tercih değildir. Bunun nedenini bir sonraki bölümde açıklayacağım.</p><h4>Yaygın tuzaklar</h4><p>Redis güçlü bir araç olsa da yanlış konumlandırıldığında sistemin güvenilirliğini olumsuz etkileyebilir.</p><p>Dikkat edilmesi gereken başlıca noktalar şunlar:</p><ul><li><strong>Redis’i tek doğruluk kaynağı olarak kullanmayın.</strong> Kalıcılık seçenekleri (snapshot ve AOF) ve asenkron veri çoğaltma nedeniyle yük devri sırasında son yazılan veriler kaybolabilir. Denetim kayıtları, işlem sonuçları ve raporlar kalıcı bir veritabanında tutulmalıdır. Redis ise koordinasyon ve geçici durum yönetimi için kullanılmalıdır.</li><li><strong>Kuyruk ve önbellek kaynaklarını ayırın.</strong> Önbelleklemede bellek dolduğunda eski anahtarların bellekten çıkarılması (eviction) beklenen bir davranıştır. Ancak aynı davranış kuyrukta kullanıldığında henüz işlenmemiş mesajların kaybolmasına neden olabilir. Bu nedenle kuyruk için ayrılan Redis örneğinde bellek yönetimi ve anahtar çıkarma politikası dikkatle yapılandırılmalıdır. Gerektiğinde bellek dolduğunda yazma işlemlerini reddeden bir politika tercih edilmelidir.</li><li><strong>Büyük veri nesnelerini kuyruğa koymayın.</strong> Dosyalar ve büyük veri nesneleri nesne depolama sistemlerinde tutulmalı; kuyrukta yalnızca bu içeriklere ait referanslar ve gerekli üst veriler (metadata) taşınmalıdır.</li><li><strong>Yinelenen işlem ihtimalini göz ardı etmeyin.</strong> At-least-once yaklaşımında aynı iş birden fazla kez çalıştırılabilir. Bu nedenle işlemler, tekrar çalıştırıldıklarında veri tutarsızlığı oluşturmayacak şekilde tasarlanmalıdır.</li><li><strong>Güvenliği ihmal etmeyin.</strong> Ağ izolasyonu, kimlik doğrulama ve şifreli bağlantı kullanılmalıdır. Ayrıca kuyruk mesajlarında kişisel ve hassas verilerin mümkün olduğunca az tutulması gerekir.</li><li><strong>Sistemi düzenli olarak izleyin.</strong> Kuyruk uzunluğu, bekleyen mesaj sayısı, bellek kullanımı ve bağlantı sayısı takip edilmesi gereken temel göstergelerdir. Anahtar adlarında tutarlı bir adlandırma düzeni (namespace) kullanmak ve geçici anahtarlara TTL tanımlamak da operasyonel açıdan önemlidir.</li></ul><h3>Redis’in yetersiz kaldığı durumlar</h3><p>Her iş yükü için Redis doğru tercih olmayabilir.</p><p>Mesajların geçmişe dönük yeniden oynatılması (replay), uzun süre saklanması, çok yüksek hacimli olay akışlarının yönetilmesi veya daha güçlü mesaj dayanıklılığı gerektiren senaryolarda Kafka ya da RabbitMQ gibi çözümler daha uygun olabilir.</p><p>Bununla birlikte, birçok otomasyon iş yükünde Redis hem yeterli kapasiteyi sunar hem de işletim açısından daha basit bir yapı sağlar.</p><p>Burada önemli olan, teknolojiyi popülerliğine göre değil, ihtiyaca göre seçmektir. Her sorunu Redis ile çözmeye çalışmak da her iş için Kafka kullanmak da doğru bir yaklaşım değildir.</p><h3>Sonuç</h3><p>Redis, otomasyon sistemlerinin arka planında sessizce çalışan ancak sistemin sağlıklı işlemesinde önemli rol oynayan bileşenlerden biridir.</p><p>İşleri dağıtır, eşzamanlı işlemleri kontrol altında tutar, hedef uygulamaların aşırı yüklenmesini önlemeye yardımcı olur ve çalışanların durumunu takip etmeyi sağlar.</p><p>Doğru konumlandırıldığında, yani kalıcı veri deposu olarak değil, koordinasyon ve geçici durum yönetimi için kullanıldığında hem güçlü hem de işletmesi kolay bir çözüm sunar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*pF5dyAqF8M0srNNb_kNIdg@2x.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c46b2a929828" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/otomasyonun-sessiz-kahraman%C4%B1-redisin-kuyruk-kilit-ve-koordinasyon-rol%C3%BC-c46b2a929828">Otomasyonun Sessiz Kahramanı: Redis’in Kuyruk, Kilit ve Koordinasyon Rolü</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My First AI Hackathon: Coding with an AI CLI Agent]]></title>
            <link>https://medium.com/softtechas/my-first-ai-hackathon-coding-with-an-ai-cli-agent-228e7b27d644?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/228e7b27d644</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-hackathon]]></category>
            <dc:creator><![CDATA[Seydi Alkan]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 14:45:45 GMT</pubDate>
            <atom:updated>2026-11-02T14:45:44.210Z</atom:updated>
            <content:encoded><![CDATA[<p>My First AI Hackathon: Coding with an AI CLI Agent</p><p>In the “<a href="https://medium.com/@seydialkan/is-ai-a-rival-or-an-assistant-for-software-developers-6598697df857">Is AI a Rival or an Assistant for Software Developers?</a>” article, I introduced my AI article series. In this article, I will talk about my hackathon experience. The workplace I work that announced several AI tools, and we wanted use them on real backlog projects to see what they could do. So the teams selected tasks from their own backlogs. There were more than ten teams, each with four members. In this hackathon I was a mentor for the teams. The teams selected specific topics from the master backlog. These topics included things business owners care about, manuel operational processes, new products, and infrastructure refactoring. We had been working from home, and after a long time we worked in the same place. It was a chance to work together in the same place after years.</p><p>Before the Hackathon, let me explain how we used AI assistants. In company we started with coding and business AI assistants. They were extensions for code explanation, code review, commit messages, business analysis, document review etc. With a Visual Studio extension, we started using AI to explain some legacy projects. It worked. But it didn’t give us a general overview. It was more effective with code blocks. Code refactor using is similar that too. We also started to use it for commit messages. Actually, it seems make somethings. They felt like first steps to walk and later we run. After these assistans, the company announced a CLI agent. With the agent, we could use different models for different tasks (Plan, build). Actually, from the very first try, the agent was much better than the earlier internal assistants. It had reached the point where it could be used in a real project. So, we used the agent for development in this hackathon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gZIwdylPmwd0BsI6r-JyuQ.png" /></figure><p>The hackathon had two important aims : <strong><em>to practice and see the power of the CLI agent, and to measure effort the general development with and without the AI agent.</em></strong></p><p>First, the teams had different tasks. Some teams developed a part of a live product, some teams migrated an API project to a new framework, and some teams fixed technical debt. And one team focused on improving a SaaS project. The teams had two days. The teams already knew the details of their backlog tasks. The first hours went to finalizing the analysis and use/adapt the CLI agent and models. After all, this was a hackathon competition. And all teams focused on finishing as many story points (SP) as possible, ready to go live. The models take time to give answers. This was an advantage to give prompt and while the agent worked, the team could <strong><em>think</em></strong> about other parts. Actually, time has passed since the hackathon, but this has not changed. Still, when we prompt a task, we have to wait. Especially to contextfully plans. <strong><em>So what do we do during this time ? I think this is a big oppurtunity for us to spend more time on thinking.</em></strong> A few days ago I saw a tweet from Uncle Bob. Thinking time is important for being more efficient.</p><blockquote><a href="https://x.com/unclebobmartin/status/2105647907705868659?s=20">“People seem shocked that the author of Clean Code doesn’t read code anymore. But that should not be surprising. Why did I write Clean Code? What is the goal of keeping code clean? To get it out of the way of the real job — thinking.”</a></blockquote><p>As I said in the earlier article, I think one of the biggest effects of AI will be that engineering becomes more important.</p><p>The second thing that excites me is that the agents can handle some basic software development life cycle (SDLC) tasks (unit tests, frontend fixes, preparing data for presentations). We don’t always develop a product or software. Sometimes we need to present a project’s architecture/topology, or we need some data to make a decision. I saw that agents can be used as assistants for managers and product managers.</p><p>With these opportunities, I also saw some areas where we need to be careful when using AI agents. First, it was slow. A developer gives a detailed prompt, and press Enter, and then waits or takes a break (this was true at first times and now it is better) but in a hackathon, time is important for finishing tasks. Second, and more important thing is when you cannot follow the changes in more complex parts, or when you give all the tasks at once without a plan, things become chaotic and it is difficult to get them back under control. That is why company standards and software architecture discipline are even more important. If companies do not develop software within strict boundaries and clear system designs, this chaotic process cannot be controlled in the long term.</p><p>Big companies especially differ from small companies in these systems and frameworks. Big companies have many employees, but they usually write in the same frameworks with the same standarts. So big companies usually cannot be as agile as startups, but this controlled development has many advantages, such as “standart tools/languages, developers who can work on different projects, quick learning, and easy maintability”. Each company has its own development culture. This has many advantages for companies.<strong><em> With AI, companies should not lose this. For this, skills/markdown files that teach LLM agents are crucial</em></strong>. Maybe we will find new control gates and solutions in the coming years.</p><p>For us, it was a nice experiement. Some developers had already practiced AI, but the benefit of the hackathon was that developers saw the abilities of our internal agent and felt the future. After the hackathon, I saw my friends use agents in different solutions with AI. This was also a significant achievement. Internal AI agents have become a part of our toolkit. We should consider AI first, but we should remain in control. Nobody can ignore AI when planning and setting goals in the software ecosystem. This does not mean AI should always make our decisions, but it is a very important input when making our decisions.</p><p>Of course, we cannot expect the same fast delivery in daily work. The teams knew their tasks and had the opportunity to focus on their tasks. They did not spend any effort on things like production problems, emails, and meetings. In real life, it does not work like that.</p><p>As for the results, we saw that tasks in known projects from the team backlog were completed very fast with AI. I don’t want to share how many SP each team completed in two days, but the result was very impressive. We saw that some waiting tasks can be delivered quickly if they are planned well. Some technical debt was waiting to be fixed, and fixing it has a more critical effect, especially in operational processes. Before AI, these cases would wait. Now, we can plan and develop with less effort. Before starting, every task was given a certain number of SP. At the end, we compared how many days the tasks would normally take with how long they took with AI in two days. For managers, this is a very important result because it affects team efficiency. Before AI, we could not imagine this speed. But in my role, I have to say that this is not the only metric to focus on. A product’s performance is not only about delivery speed. Long-term maintainability, understandability, and measurability are important too. Since the first day we heard about AI, I have always thought that AI helps us be more efficient and take over some tasks. But with these ability, it becomes more important to focus on systems, products, and the more complex parts of large corporate projects.</p><p>To be continued… In the next article, we will move from CLI agents to zero-code product delivery: ‘Building a Product with Business People: Zero Code with Lovable’.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=228e7b27d644" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/my-first-ai-hackathon-coding-with-an-ai-cli-agent-228e7b27d644">My First AI Hackathon: Coding with an AI CLI Agent</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Circular Buffer with Foreign Function And Memory API Implementation]]></title>
            <link>https://medium.com/softtechas/circular-buffer-with-foreign-function-and-memory-api-implementation-553ba5b31f4?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/553ba5b31f4</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[foreign-function-memory]]></category>
            <category><![CDATA[circular-buffer]]></category>
            <category><![CDATA[jdk-25]]></category>
            <category><![CDATA[ffm]]></category>
            <dc:creator><![CDATA[Cengiz YILMAZ]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 11:10:50 GMT</pubDate>
            <atom:updated>2026-11-02T11:10:49.171Z</atom:updated>
            <content:encoded><![CDATA[<p>In 1976, U.S. Patent 3,979,733 titled <em>‘Digital Data Communications System Packet Switch’</em>, filed by Bell Telephone Laboratories Inc., described a hardware packet switch for time-division digital communications. The patent outlines a hardware-based queue control structure that closely resembles a circular buffer implementation</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SPipoPODJJ10MzMU.png" /><figcaption>Figure-1: Diagram for Circular buffer implementation.(Image from <a href="https://patents.google.com/patent/US3979733A/en?utm_source=chatgpt.com">Google Patents</a>)</figcaption></figure><p>The basically there are 3 important component in this design (<a href="https://patents.google.com/patent/US3979733A/en?utm_source=chatgpt.com">Google Patents</a>).</p><ol><li><strong>Packet store in FIFO queues: </strong>a “packet store” memory (array of memory cells),</li><li><strong>Pointers / Counters for read and write:</strong> read position counters and write position counters,</li><li><strong>Logic for wrap-around (“circular”): </strong>when write pointer reaches the end of the queue it “wraps” back (via overflow logic) to the start, comparator logic determines “empty” vs “full” based on pointer equality</li></ol><p>This is a typical circular buffer implementation but <strong>The circular buffer (ring buffer) concept dates to the very early 1950s</strong>, emerging independently in several early computer systems.</p><p>But this patent gives a structure for us to implement the circular buffer. But first, let’s define what is circular buffer</p><h4>Circular Buffer</h4><p>Circular Buffer is a fixed size data structure as if its ends were connected. There is no dynamic allocation and read-write in constant-time.</p><p>There are 3 key points for circular buffer</p><ul><li><strong>A fixed array</strong> of size <em>N</em></li><li>A <strong>write pointer</strong> (head)</li><li>A <strong>read pointer</strong> (tail)</li></ul><p>The advantage of fixed array size is to allocate the memory in a contiguous address. Only operation is move the pointer so time complexity is O(1).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/0*KGnITi1RueI3_QN6.png" /><figcaption>Figure-2: Illustration of Ring Buffer from <a href="https://commons.wikimedia.org/wiki/File:Ring_buffer.svg">Wikimedia</a></figcaption></figure><p>These benefits are best for using in real time operation and streaming operation. Ideal usage for this structure is producer-consumer pattern usage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/0*duSuu84p9QwXpbei" /><figcaption>Figure-3: Sequence Diagram for Ring Buffer. (Image generated by the help of AI)</figcaption></figure><h4>Foreign Function and Memory API (FFM)</h4><p>Java is capable of call the native code since JDK 1.1 via JNI (Java Native Interface). JNI provides to mechanism to call the native language code with the defined method. This mechanism allow to call your C/C++ code from your Java application.</p><p>Beside this mechanism, there is also method to access off-heap memory address access by using sun.misc.Unsafe implementation. It gives access to low-level memory access but it is unsafe. The Unsafe implementation appeared in Java 1.4. java.nio.ByteBuffer implementation introduced but it is less capable compared to Unsafe implementation.</p><p>In order to solve these problems, <strong>Project Panama </strong>which aims to improve the connection between Java and native code and solve the off-heap memory access was introduced as a incubator in Java 14.</p><p>First aim for Project Panama was to solve off-heap memory access, as a result MemorySegment, MemoryAddress, MemoryLayout classes was introduced firtst.</p><p>After Java 17, It was also aimed to replace JNI and 1st Incubator introduced as Foreign Function &amp; Memory API. The Final stable version released in Java 22 and it can be used in the latest versions as an official release.</p><p>The FFM API is a modern Java API for:</p><ul><li>Calling <strong>native (non-Java) functions</strong> such as C libraries</li><li>Safely accessing <strong>off-heap</strong> or <strong>native memory</strong></li><li>Replacing JNI with a faster, safer, simpler mechanism</li></ul><p>An example of sun.misc.Unsafe as follows</p><pre>public static void main(String[] args) {<br>        long address = UNSAFE.allocateMemory(SIZE);<br>        System.out.println(&quot;Allocated memory at address: &quot; + address);<br><br>        try {<br>            // Write a long value<br>            UNSAFE.putLong(address, 123456789L);<br><br>            // Read the long back<br>            long value = UNSAFE.getLong(address);<br>            System.out.println(&quot;Read value: &quot; + value);<br>        } finally {<br>            // Free the memory<br>            UNSAFE.freeMemory(address);<br>            System.out.println(&quot;Memory freed&quot;);<br>        }<br>    }</pre><p>When using FFM, equivalent for the above implementation as follows</p><pre> public static void main(String[] args) {<br>        // Create a confined (auto-close) memory arena<br>        try (Arena arena = Arena.ofConfined()) {<br><br>            // Allocate 8 bytes for a long<br>            MemorySegment segment = arena.allocate(ValueLayout.JAVA_LONG);<br><br>            // Write a long value at offset 0<br>            segment.set(ValueLayout.JAVA_LONG, 0, 123456789L);<br><br>            // Read the long back<br>            long value = segment.get(ValueLayout.JAVA_LONG, 0);<br><br>            System.out.println(&quot;Value read: &quot; + value);<br>        } // memory automatically freed here<br>    }</pre><h4>Implementation of Circular Buffer with FFM</h4><p>Let’s dive into an implementation of a Circular Buffer using FFM (Foreign Function &amp; Memory API). In this implementation, price information is written to off-heap memory using a defined memory layout.</p><p>The first step is allocating memory of a defined capacity with a defined layout. The layout has two parts: <strong>Header</strong> and <strong>PriceInfo</strong>.</p><h4><strong>Header</strong></h4><p>The header stores the index of the circular buffer and flags indicating whether an entry is processed or free.</p><pre>public record BufferEventHeader(Integer flags, Integer index) {<br>    <br>}</pre><p>The <strong>flags</strong> could be possible options</p><pre>public class Flags {<br>    public static final int FREE = 1;<br>    public static final int PUBLISH_ACQUIRED = 1 &lt;&lt; 4;<br>    public static final int PUBLISH_COMPLETED = 1 &lt;&lt; 3;<br>}</pre><p>In order access to <strong>Header</strong> record from FFM api, it needs to define <strong>MemoryLayout</strong> according to fields. <strong>HEADER_INFO</strong> StructLayout is defined according <strong>Header</strong> records names</p><pre>public class BufferEventHeaderUtil {<br>    public static final ValueLayout JAVA_INT_LE = JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN);<br><br><br>    public static final StructLayout HEADER_INFO = MemoryLayout.structLayout(<br>            JAVA_INT_LE.withName(&quot;flags&quot;),<br>            JAVA_INT_LE.withName(&quot;index&quot;));<br>    public static final VarHandle FLAGS = varHandle(&quot;flags&quot;);<br>    public static final VarHandle INDEX = varHandle(&quot;index&quot;);<br><br>    private static VarHandle varHandle(String fieldName) {<br>        return HEADER_INFO.varHandle(MemoryLayout.PathElement.groupElement(fieldName));<br>    }<br><br>    public static void flag(MemorySegment memorySegment, int to) {<br>        MemorySegment headerSegment = PriceInfoBufferEventUtil.segment(PriceInfoBufferEventUtil.HEADER, 0L, memorySegment);<br><br>        FLAGS.set(memorySegment, 0L, to);<br><br>    }<br><br>}</pre><p>PriceInfo is the payload of the every index memory layout.</p><pre>public record PriceInfoRecord(<br>        @Override Long price,<br>        @Override Long lastPrice,<br>        @Override Long symbol,<br>        @Override Long priceDecimal,<br>        @Override Long time) implements PriceInfo {<br>    <br>}</pre><p>PriceInfo record should also be associated to a MemoryLayout. <strong>PRICE_INFO</strong> StructLayout is defined for this purpose.</p><pre>public class PriceInfoUtil {<br>    public static final ValueLayout JAVA_LONG_LE = JAVA_LONG.withOrder(ByteOrder.LITTLE_ENDIAN);<br><br><br>    public static final StructLayout PRICE_INFO = MemoryLayout.structLayout(<br>            MemoryLayout.paddingLayout(JAVA_LONG.byteSize()),<br>            JAVA_LONG_LE.withName(&quot;price&quot;),<br>            JAVA_LONG_LE.withName(&quot;lastPrice&quot;),<br>            JAVA_LONG_LE.withName(&quot;time&quot;),<br>            JAVA_LONG_LE.withName(&quot;symbol&quot;),<br>            JAVA_LONG_LE.withName(&quot;priceDecimal&quot;));<br><br>    public static final VarHandle PRICE = varHandle(&quot;price&quot;);<br>    public static final VarHandle LAST = varHandle(&quot;lastPrice&quot;);<br>    public static final VarHandle TIME = varHandle(&quot;time&quot;);<br>    public static final VarHandle SYMBOL = varHandle(&quot;symbol&quot;);<br>    public static final VarHandle PRICE_DECIMAL = varHandle(&quot;priceDecimal&quot;);<br><br>    private static VarHandle varHandle(String fieldName) {<br>        return PRICE_INFO.varHandle(MemoryLayout.PathElement.groupElement(fieldName));<br>    }<br>}</pre><p>Header and PriceInfo record are in the every element of the circular buffer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dDjpdJXRfdPm9U4DmlmYkw.jpeg" /><figcaption>Figure-4: PRICE_INFO_EVENT structure. (Image generated by the help of AI)</figcaption></figure><p>This is an UnionStruct MemoryLayout and compose HEADER_INFO and PRICE_INFO.</p><p>These are the memory layout for the one element of the Circular Buffer. When the circular buffer is started, Memory allocated according to desired capacity of the circular buffer.</p><pre>public MemorySegment allocate(Arena arena, int capacity) {<br>    MemorySegment memorySegment = arena.allocate(PriceInfoBufferEventUtil.PRICE_INFO_EVENT, capacity);<br>    for (int index = 0; index &lt; capacity; ++index) {<br>        MemorySegment eventSegement = memorySegment.asSlice(index * PriceInfoBufferEventUtil.PRICE_INFO_EVENT.byteSize(), PriceInfoBufferEventUtil.PRICE_INFO_EVENT.byteSize());<br>        MemorySegment headerSegment = PriceInfoBufferEventUtil.segment(PriceInfoBufferEventUtil.HEADER, PriceInfoBufferEventUtil.HEADER_OFFSET, eventSegement);<br>        BufferEventHeaderUtil.INDEX.set(headerSegment, 0L, index);<br>        BufferEventHeaderUtil.FLAGS.set(headerSegment, 0L, Flags.FREE);<br>    }<br>    System.out.printf(&quot;Initialized Circular Buffer with %s capacity %n Memory Segment : %n %s %n&quot;, capacity, PriceInfoBufferEventUtil.toHex(memorySegment));<br>    return memorySegment;<br>}</pre><p>Allocation from arena return the <strong>MemorySegment</strong> object. In this case, MemorySegment is the capacity sized <strong>PRICE_INFO_EVENT</strong> unionStruct memory block. As per example, the memorySegment for the 8 capacity circular buffer initial values as follow</p><blockquote><strong>Memory Segment </strong>: <br> 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 06 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><blockquote>01 00 00 00 07 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00</blockquote><p>As mentioned before, memory allocation should be done from an Arena. There are different types of Arena in FFM. In this implementation, memory access is needed between threads, because there are two structures that access memory asynchronously: <strong>Publisher</strong> and <strong>Consumer</strong>.</p><p>The <strong>Publisher</strong> accesses the off-heap memory using an ever-increasing sequence number, and tries to access the <strong>MemorySegment</strong> for a given sequence. This sequence number can be larger than the capacity of the circular buffer. In that case, it should wrap around to an index within the circular buffer. For example, if the capacity is 8 and the sequence becomes 8, it should return index 0.</p><p>The <strong>Publisher</strong> should also wait if a <strong>Consumer</strong> is processing the requested index. In this implementation, a busy-waiting strategy is used if the requested index is busy — whether by the publisher or the consumer. The <strong>Publisher</strong> implementation is as follows.</p><pre>public void publish(PriceInfoRecord priceInfoRecord) {<br>    MemorySegment memorySegment = circularBuffer.segment(sequence);<br>    waitingStrategy.waitFor(sequence, circularBuffer, memorySegment, Flags.FREE, Flags.PUBLISH_ACQUIRED);<br>    circularBuffer.set(circularBuffer.segment(sequence), priceInfoRecord);<br>    BufferEventHeaderUtil.flag(memorySegment, Flags.PUBLISH_COMPLETED);<br>    BufferEventHeader header = circularBuffer.header(memorySegment);<br>    System.out.printf(&quot;Publish : { %n        %s   %n      Address: %s %n      Hex: %s %n      %s%n}%n&quot;, header.toString(), memorySegment.address(), PriceInfoBufferEventUtil.toHex(memorySegment), circularBuffer.get(memorySegment).toString());<br>    sequence++;<br>}</pre><p>The consumer continuously waiting a record from the circular buffer memory segment from its current sequence number.</p><pre>public void start() {<br><br>    for (; ; ) {<br>        MemorySegment memorySegment = circularBuffer.segment(sequence);<br>        BufferEventHeader header = waitingStrategy.waitFor(sequence, circularBuffer, memorySegment, Flags.PUBLISH_COMPLETED, Flags.FREE);<br>        PriceInfoRecord event = circularBuffer.get(memorySegment);<br>        workerHandler.handle(event, memorySegment, circularBuffer.header(memorySegment));<br>        LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(500));<br>        sequence++;<br>    }<br>}</pre><p>In order to acquire for the memory segment Publisher or Consumer wait respectively each other. BusyWaiting is implemented for this implementation. Publisher or Consumer waits until header flag value is a desired value.</p><pre>public BufferEventHeader waitFor(int sequence, CircularBuffer&lt;R, T&gt; circularBuffer, MemorySegment memorySegment, int mask, int updateFlag) {<br>    BufferEventHeader bufferEventHeader = circularBuffer.header(memorySegment);<br>    AtomicInteger flags = new AtomicInteger(bufferEventHeader.flags());<br>    while (!flags.compareAndSet(mask, updateFlag)) {<br>        Thread.onSpinWait();<br>        LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(1000));<br>        bufferEventHeader = circularBuffer.header(memorySegment);<br>        flags.set(bufferEventHeader.flags());<br>        System.out.printf(&quot;%n Not allowed for flags %s compare to mask %s in order to get %s index %n&quot;, flags, mask, bufferEventHeader.index());<br>    }<br>    BufferEventHeaderUtil.flag(memorySegment, updateFlag);<br>    return circularBuffer.header(memorySegment);<br>}</pre><p>Publisher writes this value in the circular buffer as follow.</p><blockquote>Publish : { <br> Header: (<br> flags : 8<br> index : 0<br> )<br> <br> Address: 54172889856 <br> Hex: 08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 65 8e 5e d5 9f bf 00 00 00 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 <br> Price Info: (<br> price : 0<br> last : 0<br> symbol : 0<br> decimal : 2<br> time : 210693200449125<br> )</blockquote><blockquote>}<br>Publish : { <br>Header: (<br> flags : 8<br> index : 1<br> )<br> <br>Address: 54172889904 <br>Hex: 08 00 00 00 01 00 00 00 14 00 00 00 00 00 00 00 1c 00 00 00 00 00 00 00 68 6b 0a 1e a1 bf 00 00 10 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 <br> Price Info: (<br> price : 20<br> last : 28<br> symbol : 16<br> decimal : 2<br> time : 210698714639208<br> )</blockquote><blockquote>}</blockquote><p>Consumer writes these memory segment after publisher writes in the defined index value</p><blockquote>Consume Output Handler:{<br> Header: (<br> flags : 1<br> index : 0<br> )<br> <br> Address: 54172889856 <br> Hex: 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 65 8e 5e d5 9f bf 00 00 00 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 <br> Price Info: (<br> price : 0<br> last : 0<br> symbol : 0<br> decimal : 2<br> time : 210693200449125<br> )</blockquote><blockquote>}</blockquote><blockquote>Consume Output Handler:{<br> Header: (<br> flags : 1<br> index : 1<br> )<br> <br> Address: 54172889904 <br> Hex: 01 00 00 00 01 00 00 00 14 00 00 00 00 00 00 00 1c 00 00 00 00 00 00 00 68 6b 0a 1e a1 bf 00 00 10 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 <br> Price Info: (<br> price : 20<br> last : 28<br> symbol : 16<br> decimal : 2<br> time : 210698714639208<br> )</blockquote><blockquote>}</blockquote><p>If the consumer wants to an index which is not written by publisher yet, it should wait until its requested index written.</p><blockquote>Not allowed for flags 1 compare to mask 8 in order to get 3 index</blockquote><p>Also if the requested sequence exceeds the capacity of circular buffer, publisher and consumer go to the 0 index.</p><blockquote>Not allowed for flags 8 compare to mask 8 in order to get <strong>7</strong> index</blockquote><blockquote>Consume Output Handler:{<br> Header: (<br> flags : 1<br> index : 7<br> )<br> <br> Address: 54172890192 <br> Hex: 01 00 00 00 07 00 00 00 8c 00 00 00 00 00 00 00 c4 00 00 00 00 00 00 00 f7 e3 55 d0 a8 bf 00 00 70 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 <br> Price Info: (<br> price : 140<br> last : 196<br> symbol : 112<br> decimal : 2<br> time : 210731770700791<br> )</blockquote><blockquote>}</blockquote><blockquote>Not allowed for flags 1 compare to mask 8 in order to get <strong>0 </strong>index</blockquote><h4>Conclusion</h4><p>A circular buffer is an important structure for performance-required applications that need low memory usage and low latency. With the FFM implementation in Java, implementing it in off-heap memory has become much more structured.</p><p>FFM also allows execution of native libraries like C++, because it works with off-heap memory.</p><p>Sample code for a circular buffer implementation using FFM can be accessed through the following link. <a href="https://github.com/cengizyilmaz/circularbuffer">https://github.com/cengizyilmaz/circularbuffer</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=553ba5b31f4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/circular-buffer-with-foreign-function-and-memory-api-implementation-553ba5b31f4">Circular Buffer with Foreign Function And Memory API Implementation</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Really Destroyed Jurassic Park?]]></title>
            <link>https://medium.com/softtechas/who-really-destroyed-jurassic-park-d87e67086467?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/d87e67086467</guid>
            <category><![CDATA[jurassic-park]]></category>
            <category><![CDATA[bus-factor]]></category>
            <category><![CDATA[team-culture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Burak Acar]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 10:36:11 GMT</pubDate>
            <atom:updated>2026-11-02T10:36:10.157Z</atom:updated>
            <content:encoded><![CDATA[<h4>A bus factor of one, and the man who knew the magic word.</h4><figure><img alt="A Tyrannosaurus rex skeleton with open jaws on display in a museum" src="https://cdn-images-1.medium.com/proxy/0*u8OryQVM09nzRfyK" /><figcaption>Photo by <a href="https://unsplash.com/@tofanteo?utm_source=medium&amp;utm_medium=referral">Tofan Teodor</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>We all remember the roar. The T. rex in the rain, the trembling glass of water, the jeep sliding down the tree. But the moment Jurassic Park was truly lost came earlier, and it was much quieter. In the film, a programmer stood up from his desk, said he was going to the vending machine, and left the control room.</p><p>He never came back. And neither did the park.</p><p>Michael Crichton wrote a story about cloning dinosaurs. Read it again as a software developer and you find a different story underneath: a billion-dollar system that depended on a single person. Developers have a name for that: the <strong>bus factor</strong>.</p><h3>The Brain of the Park Had One Owner</h3><p>John Hammond spared no expense on the dinosaurs. The software was another story. It came down to one man.</p><p>Dennis Nedry, whose Cambridge firm won the contract, was the architect of the system that ran the island: the fences, the doors, the cameras, the animal tracking, the phones. In the novel, he then watches the requirements shift month after month. Hammond treats every new request as a defect Nedry must fix for free. By the time the first guests arrive, the deepest knowledge of how the park’s brain works sits with Nedry, and he is also the person who resents it the most.</p><p>The bus factor is a simple, slightly morbid question: <em>how many people would have to be hit by a bus before this project stops?</em> At Jurassic Park, for the system that kept the dinosaurs inside their fences, the answer was effectively one.</p><p>The question is older than it sounds. Back in 1994, the Python community was already openly asking what would happen to the language if its creator, Guido van Rossum, were hit by a bus. And it isn’t a problem of small, forgotten projects. A 2016 study by Avelino and colleagues measured the truck factor of 133 popular GitHub projects and found that 65% of them had a truck factor of two or less. Some of the most-starred code in the world was, in effect, one or two Nedrys away from standing still. A later analysis by Metabase of the 1,000 most-starred repositories told the same story: almost half had a bus factor of two or less, and popularity didn’t predict it at all.</p><blockquote><em>“Truck Factor helps to measure how prepared a project is to deal with developer turnover.” — Avelino et al., A Novel Approach for Estimating Truck Factors (ICPC 2016)</em></blockquote><p>Think of a restaurant where a single chef knows every recipe, holds the only key to the pantry and writes the inventory report. The food can be excellent. Service can be perfect. But the restaurant doesn’t really belong to the owner. It belongs to the chef. The day the chef doesn’t show up, there is no restaurant.</p><p>That was Hammond’s park. He owned the island, the patents, the animals. Nedry owned the only thing that kept them apart from the guests: the knowledge of how it all worked.</p><h3>The Assumption Only Nedry Knew</h3><p>The novel gives us a warning long before the storm, in a scene the film left out.</p><p>The control room tracks every animal on the island with motion sensors. Ask for a count and the screen proudly answers: 238 animals expected, 238 found. Everyone relaxes. Then Ian Malcolm asks Arnold to try something odd: search for <em>more</em> than 238. The count keeps climbing, well past the number that was ever bred. The dinosaurs have been breeding all along.</p><p>Hammond’s first reaction is the one every manager has had: it must be a bug. It isn’t. Nedry calmly explains that he designed it this way. To make the count faster, the system lets the operator enter the number of animals they expect, and it stops looking once it finds them. It could notice missing animals. It could never notice extra ones.</p><p>The counting bug is only a symptom. The real problem is where the knowledge was kept. The most important assumption in the park’s safety system existed in one place: Nedry’s head. The people watching the screens every day didn’t know it existed, so they trusted a number that could only ever agree with them. It took an outsider asking a naive question to expose it.</p><p>That is the cost of a low bus factor. Long before the person leaves, their decisions are already invisible to everyone else. The system keeps working, until someone asks about the assumption its author never wrote down.</p><h3>The Day the Bus Came</h3><figure><img alt="Lightning flashing through dark storm clouds over the sea at night" src="https://cdn-images-1.medium.com/proxy/0*RFLZH23rTpqa2sXZ" /><figcaption>Photo by <a href="https://unsplash.com/@mischievous_penguins?utm_source=medium&amp;utm_medium=referral">Casey Horner</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Nedry’s bus arrives on a stormy night. A rival company has paid him to steal dinosaur embryos. To get them off the island, he runs a hidden program (in the film, a file called <em>whte_rbt.obj</em>) that switches off the park’s security for a few minutes, then drives toward the docks. He gets lost in the rain, and a dinosaur makes sure he never returns.</p><p>Most people remember this scene as the story’s betrayal. Look closer: this is the moment the bus factor drops from one to zero.</p><p>Back in the control room, chief engineer Arnold (John in the novel, Ray in the film) faces the screen. He knows something is wrong. He knows Nedry did it. But he cannot undo it, because he cannot read the system. A huge codebase, shaped by one person’s decisions, that no one else on the island had ever needed to understand.</p><blockquote><em>“I can’t get Jurassic Park back online without Dennis Nedry.” — Ray Arnold, Jurassic Park (1993)</em></blockquote><p>In the film, the system answers his attempts with a looping animation of Nedry wagging his finger: <em>Ah ah ah, you didn’t say the magic word.</em></p><p>That little animation is the perfect symbol of the bus factor. The system is still running. The servers are fine. The code hasn’t changed. Nothing is broken. Someone is missing. The magic word left the building with Nedry.</p><p>Nedry didn’t need to be a villain for this to happen. If he had simply fallen ill, quit, or taken a long vacation, the park would have faced the same wall. The theft just made it arrive faster. A backdoor is dangerous. A system only one person can read is a backdoor that’s always open.</p><h3>Knowledge Dies One Person at a Time</h3><figure><img alt="Rows of server racks glowing green in a dark data center" src="https://cdn-images-1.medium.com/proxy/0*e_xiJi7Jpt0UDHLp" /><figcaption>Photo by <a href="https://unsplash.com/@tylergm?utm_source=medium&amp;utm_medium=referral">Tyler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>With Nedry gone, the park’s survival now depends on the next person who knows a little more than everyone else. That person is Arnold.</p><p>Arnold decides on the only move left: shut everything down and restart. The film and the novel tell this part differently, but they arrive at the same place.</p><p>In the film, the reboot brings the computers back while the park’s breakers stay off, and someone has to reset them by hand at the maintenance shed. In the novel, the restart leaves the park running on auxiliary power, which eventually runs dry, and the main generators have to be brought back from the shed. Either way, the person who goes is Arnold, because he is the one who knows how. He doesn’t come back either.</p><p>The bus factor covers more than the person who built the system. It also covers everyone who knows how to recover it. Nedry was one point of failure. Arnold, it turns out, was another. Each time one of them disappears, the knowledge needed to save the park gets smaller, and the people left behind get more desperate.</p><p>This is where the bus factor splits in two. There is the <strong>code bus factor</strong>: how many people understand how the system is built. And there is the <strong>operational bus factor</strong>: how many people can keep it alive when something breaks in production. They are not the same number. Five engineers can work on the same module every day, yet if only one of them knows how to diagnose and recover it at 3 a.m., the operational bus factor is still one.</p><p>In a large microservice architecture, this gap multiplies. Every service has its owners, but the knowledge of how failures travel between services, which one to restart first and which alarms actually matter often lives in very few heads. Jurassic Park lost both at once: Nedry took the code knowledge with him, and Arnold took the recovery knowledge to the shed.</p><p>💡 Code bus factor tells you who can change the system. Operational bus factor tells you who can save it.</p><p>In the end, the park is saved by a child. In the film it is Lex who sits at the terminal and says the line every programmer has laughed at: <em>“It’s a Unix system! I know this!”</em> (In the novel, it’s her brother Tim.) Fun fact: the 3D interface she flies through was real. It was <em>fsn</em>, an experimental file manager from Silicon Graphics.</p><p>The uncomfortable part is that the survival of everyone in that building depended on a kid who happened to be in the room and happened to know Unix. That is not a recovery plan. That is luck.</p><p>Every company has had its Lex moment. The production incident at 3 a.m. that only gets fixed because someone who left the team two years ago still answers their phone. The legacy module nobody touches because the only person who understood it is now a manager. We tell these stories as hero stories. They are warnings.</p><p>Reality even has its own Nedry. In 2008, a network administrator in San Francisco refused to hand over the passwords to the city’s network, and for days no one else could manage it. The city learned what Hammond learned: the system belonged to whoever knew how it worked.</p><h3>What Hammond Should Have Done</h3><figure><img alt="Two developers sitting side by side, looking at code on a monitor together" src="https://cdn-images-1.medium.com/proxy/0*WG1d1BorQGyT6ZkL" /><figcaption>Photo by <a href="https://unsplash.com/@flipsnack?utm_source=medium&amp;utm_medium=referral">Flipsnack</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Hammond didn’t need a better programmer. He needed a second one. Let’s rewind the story and replay each scene with a higher bus factor.</p><p><strong>Scene 1: Only Nedry really knows the code.</strong> With code review and pair programming, every change to the park’s control system would have passed through at least one more pair of eyes. Code review is usually sold as a quality tool. Its less visible and more valuable job is spreading knowledge. Review is not a guarantee: a determined insider can still hide something, and reviewers miss things. But it makes a hidden routine much harder to slip through, and if one does get through, someone else knows the code well enough to know where to look.</p><p><strong>Scene 2: Arnold can’t read the system.</strong> If the people running the park had rotated through the codebase, Arnold wouldn’t have been staring at a stranger’s code. Ownership rotation, shared on-call duties and “you build it, you teach it” sessions turn a single expert into a team that can operate the system.</p><p><strong>Scene 3: Only Arnold knows how to restore the power.</strong> A runbook, a written, step-by-step recovery guide, would have meant anyone in the control room could restore the fences. Not just the chief engineer. Not just whoever was brave enough to walk into the dark.</p><p>There is data behind this. In <em>Site Reliability Engineering</em>, Google’s SRE team reports that writing best practices down in a playbook ahead of time gives “roughly a 3x improvement in MTTR” compared with improvising during an incident. Arnold walked into the dark with a plan that existed only in his head. A playbook would have let someone else carry it.</p><p><strong>Scene 4: A child saves the day by luck.</strong> Recovery that works only if the right person happens to be in the room was never tested. Practicing recovery, with people who didn’t build the system, is how you find out your bus factor before the storm does.</p><p>You don’t have to guess your own bus factor. Your version control history already knows. A quick look at who has touched a critical module tells you whether you have a team or a Nedry:</p><pre># Who actually knows the park&#39;s control system?<br>git shortlog -sn -- src/park-control/</pre><pre>412  Dennis Nedry<br>    3  John Arnold</pre><p>If the first name is responsible for almost every commit, you already know who the park belongs to.</p><p>Then ask four questions about every system that matters:</p><ul><li><strong>Review:</strong> Can at least two people review and approve a change to it?</li><li><strong>Runbook:</strong> Is there a written recovery guide, and has someone other than its author actually followed it?</li><li><strong>On-call:</strong> Has someone who didn’t build it handled a real incident in it recently?</li><li><strong>History:</strong> When you run git shortlog on it, does one name dominate?</li></ul><blockquote><em>A system isn’t owned by the person who pays for it. It’s owned by the people who understand it.</em></blockquote><h3>Who Knows the Magic Word?</h3><p>Jurassic Park is remembered as a warning about playing with nature. But Hammond’s dinosaurs didn’t escape because science failed. They escaped because a whole island depended on what one man kept in his head.</p><p>The real risk was walking around the control room, eating snacks and complaining about his contract.</p><p>Every team has a Nedry. Usually not a villain, just a brilliant, overloaded person everyone relies on. The kindest thing you can do for them, and for your system, is to make sure they are not the only one.</p><p>So before the next storm, ask yourself the question Hammond never did: <strong>If your Nedry left tomorrow, who would know the magic word?</strong></p><h3>Further Reading</h3><ul><li>Michael Crichton, <em>Jurassic Park</em> (1990): the novel, where the counting scene and Nedry’s background appear.</li><li>Steven Spielberg, <em>Jurassic Park</em> (1993): the film, source of the “magic word” and “It’s a Unix system!” scenes.</li><li>Avelino, Passos, Hora, Valente, <a href="https://arxiv.org/abs/1604.06766">A Novel Approach for Estimating Truck Factors</a> (ICPC 2016).</li><li>Beyer, Jones, Petoff, Murphy, <a href="https://sre.google/sre-book/introduction/">Site Reliability Engineering: How Google Runs Production Systems</a> (O’Reilly, 2016).</li><li>Metabase, <a href="https://www.metabase.com/blog/bus-factor">Bus factor of top GitHub projects</a>: a later look at 1,000 popular repositories.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d87e67086467" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/who-really-destroyed-jurassic-park-d87e67086467">Who Really Destroyed Jurassic Park?</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eylül 2026 YZ Araştırma Trendleri]]></title>
            <link>https://medium.com/softtechas/eyl%C3%BCl-2026-yz-ara%C5%9Ft%C4%B1rma-trendleri-1b93ac0671cf?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/1b93ac0671cf</guid>
            <category><![CDATA[ai-research]]></category>
            <category><![CDATA[yz-araştırmaları]]></category>
            <category><![CDATA[yz-makale-özeti]]></category>
            <category><![CDATA[yz-makaleleri]]></category>
            <category><![CDATA[y-araştırma-trendleri]]></category>
            <dc:creator><![CDATA[Cahit Barkin Ozer]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 08:38:27 GMT</pubDate>
            <atom:updated>2026-10-15T08:38:26.106Z</atom:updated>
            <content:encoded><![CDATA[<p>Eylül 2026&#39;daki temel yapay zeka araştırma eğilimlerini belirlemek amacıyla Hugging Face Daily Papers’ı inceledim ve bu eğilimleri özetledim.</p><p><a href="https://huggingface.co/papers/month/2026-09">Daily Papers - Hugging Face</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Djkai2YTvxPTMgx44x2Tg.png" /></figure><p>Eylül 2026 boyunca Hugging Face Daily Papers’da öne çıkan makaleleri inceledim ve aralarında tekrar eden fikirleri bir araya getirerek araştırmanın hangi yönlere doğru ilerlediğini anlamaya çalışıyorum.</p><p>Ağustos’un en belirgin sonucu şuydu: Yapay zekâ sistemlerinin performansını artık yalnızca kullanılan model belirlemiyor. Modelin etrafındaki harness, tool’lar, hafıza, bağlam yönetimi, ortam ve onaylama katmanları da en az model kadar önemli hale geliyor.</p><p>Eylül ayında ise bu fikir devam ediyor. <strong>Sistemin kendi harness’ını geliştirmesi, yeni skill’ler öğrenmesi, geçmiş deneyimini tekrar kullanması, keşif stratejisini değiştirmesi ve hatta neyi öğrenmesi gerektiğine kendisinin karar vermesi</strong> araştırma konusu haline geliyor.</p><p>Kısacası Eylül’de temel soru: <em>Ajanik bir sistem kendi çalışma biçimini zaman içinde geliştirebilir mi? </em>Cevap: şimdilik bir noktaya kadar evet. Fakat kendini iyileştirme başladığı anda klasik makine öğrenmesi problemleri bu kez ajan sistemi seviyesinde tekrar ortaya çıkıyor: Aşırı uyum, kötü değerlendirme, eğitimin teste sızması, yanlış hedef seçimi, karmaşıklık artışı ve genelleştirme sorunları.</p><h3>1. Harness artık sadece yazılım altyapısı değil, öğrenilen bir yapı</h3><p>Ajan sistemlerinde harness (koşum) dediğimiz katman kabaca modelin etrafındaki çalışma mekanizmasını ifade ediyor. Bu parçalar genel olarak prompt’lar (istemler), tool kullanımı, kontrol akışı, bağlam yönetimi, hafıza, tekrar deneme mantığı, görevin tamamlandığının tespiti ve benzeri parçalardan oluşuyor. Bir süre öncesine kadar bunların tamamı çoğunlukla insanlar tarafından manuel kodlanıyordu. Eylül ayındaki çalışmalar ise harness’ın kendisini doğrudan bir <strong>optimizasyon hedefi </strong>haline getiriyor.</p><h4>Raven: Harness’ların harness’ı</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*QW-R4Pt9V7iimbbCeAW4kA.png" /></figure><p>Raven bu ayın en kapsayıcı örneklerinden biri.</p><p>Temel fikir, her probleme genel amaçlı ajanlar göndermek yerine farklı model-harness çiftlerini uzmanlaşmış zeka birimleri olarak kullanmak.</p><p>Bir ajan kodlama konusunda güçlü olabilir, başka biri araştırma konusunda, başka bir harness ise multimodal işlemlerde daha iyi olabilir. Raven’ın Host Agent’ı büyük görevi alt görevlere ayırıyor, uygun uzmanları seçiyor, bağımlılıkları yönetiyor ve ortaya çıkan sonuçları birleştiriyor.</p><p>Daha ilginç taraf ise sistemin deneyimi kaybetmemesi. Raven geçmiş çalıştırmalardan elde ettiği bilgiyi arşivleme ve Skill birleştirme gibi mekanizmalarla tekrar kullanılabilir prosedürlere dönüştürmeye çalışıyor.</p><p>Yani ajan sistemi yalnızca “bir görevi tamamlayan program” olmaktan çıkıyor. Görev tamamlandıkça biriken tecrübe, sonraki görevlerde kullanılabilecek yeni bir yeteneğe dönüşüyor.</p><h3>HarnessDev: Agent kendi harness’ını gerçekten geliştirebiliyor mu?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*py3sgCav9JntG1i_A0T0vQ.png" /></figure><p>Raven bunun yapılabileceğini önerirken HarnessDev doğrudan şu soruyu benchmark haline getiriyor:</p><blockquote><em>Bir model, kendisi için iyi bir çalıştırma sistemi oluşturabilir mi?</em></blockquote><p>HarnessDev’de agent başlangıçta çok basit bir sistem ve birkaç örnek görüyor. İlk aşamada sıfırdan bir harness oluşturuyor.</p><p>İkinci aşamada ise bu harness’ı aşağı yönlü çalıştırma geribildirimi kullanarak tekrar tekrar değiştiriyor. Burada yalnızca görev başarısı değil, çalıştırma sırasında harcanan token miktarı da ölçülüyor.</p><p>Sonuçlar kendi kendini geliştirme fikrinin şu anki sınırlarını oldukça iyi gösteriyor.</p><p>Üretilen harness’lar yazma ve bazı makine öğrenmesi deneyleri görevlerinde insan yapımı referansları yakalayabiliyor veya geçebiliyor. Ancak kodlama ile arama/araştırma tarafında hâlâ olgun insan yapımı sistemlerin gerisinde kalıyorlar. Daha da önemlisi, evrilme sırasında elde edilen kazanımlar her zaman stabil değil.</p><p>Bir harness belirli bir modelde iyileşirken başka bir çalışma zamanı modelinde aynı şekilde çalışmayabiliyor. Bu önemli çünkü harness’ın modelden bağımsız, tamamen tekrar kulanılabilir bir yazılım katmanı olduğunu düşünme eğilimindeyiz. Gerçekte ise model ile harness arasında güçlü bir coupling (bağlantı) olabilir.</p><h3>2. Kendi kendini iyileştiren harness kendi araştırma alanına dönüşüyor</h3><p>Bu ay araştırmacılar harness self-improvement’a dair çok daha spesifik sorular soruyor:</p><ul><li>Harness evrimi mekanizmaları benchmark’lara aşırı uyum sağlar mı?</li><li>Tek bir hatadan yapılan değişiklik gerçekten genellenebilir mi?</li><li>Hangi harness bileşeni değiştirilmeli?</li><li>Bir iyileşme başka modellere transfer ediyor mu?</li><li>Harness sürekli büyüyüp pahalı hale mi geliyor?</li><li>Bir değişikliğin neden işe yaradığını nasıl anlayabiliriz?</li></ul><p>Yani harness optimizasyonu artık tek bir teknik değil; kendi genelleme ve düzenlileştirme (regularization) problemleri olan ayrı bir araştırma alanına dönüşüyor.</p><h3>RRSI: Kendini iyileştirme de düzenlileştirmeye muhtaç</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*aharOxvi8a_WR-qLZj7zig.png" /></figure><p>RRSI çalışması harness evolution’ın en temel problemlerinden birine odaklanıyor. Bir agent aynı benchmark üzerinde tekrar tekrar kendi sistemini geliştirirse, gerçekten daha iyi bir agent haline gelmek yerine benchmark’ı ezberlemeye başlayabilir.</p><p>Bu klasik makine öğrenmesindeki aşırı öğrenme probleminin ajan mimarisi seviyesindeki karşılığı. RRSI bu nedenle evrim sürecine düzenlileştirme (regularization) ekliyor.</p><p>Aday harness değişiklikleri aynı anda sınırsız şekilde büyüyemiyor. Sistem daha önce yeterince araştırılmamış evrim yollarına yönlendiriliyor. Daha sonra bir eleştirmen benchmark’a fazla spesifik değişiklikleri elerken budayıcı ise artık işe yaramayan, çok küçük katkı sağlayan veya fazla pahalı hale gelen bileşenleri çıkartıyor. Sonuç oldukça ilginç.</p><p>Düzenlileştirilmiş harness yalnızca bazı dağıtım dışı benchmark’larda daha iyi genellemekle kalmıyor, aynı zamanda düzenlileştirilmemiş evrime göre yaklaşık %30 daha az policy token kullanıyor.</p><p>Bu bize önemli bir şeyi hatırlatıyor:</p><blockquote><em>Daha gelişmiş agent, mutlaka daha karmaşık agent anlamına gelmiyor.</em></blockquote><p>Kendi kendini geliştirme mekanizması kontrolsüz bırakılırsa sistem yalnızca kendisine yeni özellikler ekleyerek şişebilir. Gerçek iyileşme bazen yeni şey eklemek değil, gereksiz mekanizmaları kaldırmak olabilir.</p><h3>ModularRSI: Harness neden monolitik olmak zorunda?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*3wJFFgWknU0FlrOerZHsZw.png" /></figure><p>ModularRSI benzer problemi farklı bir açıdan çözüyor. Bir harness’ın tamamını tek parça olarak optimize etmek atıf sorununa yol açıyor. Örneğin agent bir görevde başarısız olduğunda. Sorun nerede olabilir? Tool seçimi mi kötüydü? Bağlam yönetimi mi? Gözlem çok mu uzundu? Ajan döngüsü yanlış mı çalıştı? Yoksa ajan görevi tamamladığını yanlış mı düşündü? Monolitik bir harness değiştirildiğinde bunların tamamı birbirine karışabiliyor.</p><p>ModularRSI harness’ı beş fonksiyonel modüle ayırıyor: Ajan döngüsü, araç kullanımı, gözlem yönetimi, bağlam yönetimi, görev tamamlama tespiti. Her modül kendi sınırları içinde evriliyor ve sonrasında tekrar entegre ediliyor.</p><p>Ayrıca sistem tek bir başarısız yörüngeye bakmak yerine aynı görevin başarılı ve başarısız çalıştırmalarını karşılaştırıyor ve farklı görevlerde tekrar eden arıza desenlerini arıyor.</p><p>Bu oldukça önemli bir değişim çünkü amaç artık: <em>Bu görev neden başarısız oldu? </em>sorusundan çok: <em>Bu ajan sisteminin tekrar eden yapısal problemi ne? </em>sorusuna cevap vermek.</p><p>Daha da önemlisi, evrilme esnasında kullanılan 2.000 görev, çalıştırılan benchmark’lardan ayrı tutuluyor. Yani benchmark doğrudan optimizasyon verisi olarak kullanılmıyor. Bu basit gibi görünse de harness araştırması için önemli bir metodolojik gelişme.</p><p>Ajan sistemleri araştırması klasik makine öğrenmesinin yıllar önce öğrendiği eğitim-validasyon-test ayrımına yeniden ihtiyaç duyuyor.</p><h3>3. Kendi kendini geliştirmenin en zor tarafı kendini değiştirmek değil, neyin gerçekten daha iyi olduğunu anlamak</h3><p>ASPIRE çalışması kendini geliştirme kavramını biraz daha zor bir seviyeye taşıyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zolFzp7N02OPAJNw0eTsmw.png" /></figure><p>Bugünkü birçok “self-improving agent” aslında çok net bir objective alıyor:</p><ul><li>“Bu benchmark’ta doğruluğu yükselt.”</li><li>“Bu kodlama görevlerini daha iyi çöz.”</li><li>“Bu ödülü maksimize et.”</li></ul><p>Bu durumda modelin yaptığı şey gerçek anlamda neyi öğrenmesi gerektiğini keşfetmek değil; insanın tanımladığı metriği optimize etmek. ASPIRE ise ajana yalnızca belirsiz bir doğal dilli hedef veriyor. Örneğin:<em>“Daha iyi bir fizikçi ol.” </em>veya <em>“araştırma konusunda kendini geliştir.”</em></p><p>Evrim süreci ise gizli. Agent’ın kendi kendine şunları belirlemesi gerekiyor:</p><ul><li>Bu hedef hangi yetenekleri içeriyor?</li><li>Nerede eksiğim?</li><li>Hangi veriyi toplamalıyım?</li><li>Ağırlıkları mı değiştirmeliyim yoksa harness’ı mı?</li><li>Değerlendirme kümem nasıl olmalı?</li><li>Ne zaman değerlendirme yapmalıyım?</li><li>Gerçekten geliştiğimi nasıl anlayacağım?</li></ul><p>Bu, kendini iyileştirme sürecini çok daha gerçekçi hale getiriyor.</p><p>Sonuçlar ise bugünkü sistemlerin temel zayıflığını gösteriyor. Agent’lar eğitim döngüsü çalıştırabiliyor. Harness değiştirebiliyor. Dataset seçebiliyor. Model eğitebiliyor. Fakat sık sık <strong>yanlış şeyi optimize ediyorlar</strong>.</p><p>Hedef ile tam uyuşmayan data seçilebiliyor. Dar bir kendini değerlendirme kümesi üzerinde gelişim görülüyor. Agent bunu gerçek yetenek gelişimi sanıyor. Ancak gizli değerlendirme geldiğinde kazanım ortadan kaybolabiliyor. Daha kötüsü, ajan eğitime devam ettikçe daha önce elde ettiği kazanımları bile silebiliyor.</p><p>Buradan benim çıkardığım önemli sonuç şu: <em>Kendini geliştirmenin darboğazı değişiklik üretmek değil, doğru değerlendirme üretmek olabilir.</em></p><p>Bir ajan kendi prompt’unu değiştirebilir. LoRA train edebilir. Yeni tool ekleyebilir. Skill yazabilir. Fakat bütün bunların gerçekten genel bir iyileştirme olup olmadığını güvenilir şekilde anlayamıyorsa özyinelemeli kendini iyileştirme kolayca özyinelemeli aşırı öğrenmeye (overfit’e) dönüşebilir.</p><p>Bu, Ağustos ayında gördüğümüz “üretim kolaylaşıyor, doğrulama zorlaşıyor” sonucunun Eylül’de bir üst seviyeye taşınması gibi. Artık yalnızca agent’ın cevabını doğrulamıyoruz. <strong>Agent’ın kendisinde yaptığı değişikliğin doğru yönde olup olmadığını doğrulamamız gerekiyor.</strong></p><h3>4. Kabiliyet giderek model ağırlıklarının dışına taşınıyor</h3><p>Eylül’deki ikinci çok güçlü yön, ajanın yeteneklerinin kaynak modelin ağırlıklarına bağımlılığının azalması. Uzun zamandır, yeni bir yetkinlik istediğimizde ilk refleksimiz modeli değiştirmekti:</p><p>Yeni veri toplar, finetune eder, multimodal mimari ekler, daha büyük model kullanırdık. Yeni çalışmalar ise farklı bir yaklaşım gösteriyor: <em>Kaynak model aynı kalsın. yetkinliği sistem seviyesinde ekleyelim.</em></p><h4>Omni-IO: Modeli yeniden eğitmeden multimodal ajan kullanmak</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*4Js935Y8t1TUb0BkV8D1UQ.png" /></figure><p>Omni-IO Skills bunun en net örneklerinden biri. Bugün text, image, audio, video, document, 3D ve code gibi modality’lerin her biri farklı modeller ve tool’lar gerektirebiliyor.</p><p>Bir seçenek kaynak modeli bütün modality’leri native olarak destekleyecek şekilde büyütmek. Ancak bu pahalı. Diğer seçenek specialist tool ve modelleri agent’a bağlamak. Fakat bu kez de orkestrasyon problemi ortaya çıkıyor.</p><p>Bir görsl modelin çıktısı hangi video model’e gidecek? Bir ses çıktısı nasıl kaydedilecek? Bir artifact birkaç tur sonra tekrar nasıl kullanılacak? Hangi operasyonlar paralel çalıştırılabilir?</p><p>Omni-IO bunun için hiyerarşik Skill’ler, standardize edilmiş çalıştırma arayüzü, bağımlılık farkında orkestrasyon ve kalıcı varlık kaydı kullanıyor.</p><p>İş akışları çalıştırma graflarına dönüştürülüyor. Bağımsız işler paralel çalıştırılabiliyor. Üretilen artifact’ler registry’ye kaydediliyor. Sonraki işlemler veya sonraki konuşma turları bu artifact’leri tekrar kullanabiliyor.</p><p>Sonuçta host model’in muhakeme çekirdeği değişmeden girdi destek oranı yaklaşık %40 seviyesinden %100’e çıkarılabiliyor. Buradaki büyük fikir şu: <em>Bir yetkinlik modelin içinde olmak zorunda değil. </em>Model o yetkinliği doğru zamanda çağırabiliyor, çıktısını anlayabiliyor, diğer işlemlerle bağlayabiliyor ve gerekirse revize edebiliyorsa sistem açısından yetkinlik zaten mevcuttur.</p><p>Bu nedenle gelecekte “Bu model video üretebiliyor mu?” sorusundan çok: <em>Bu ajan sistemi video ürtimi yetkinliğini bir iş akışı içerisinde kullanabiliyor mu? </em>sorusu daha anlamlı olabilir.</p><h3>Repo-To-Skill: Bilmek başka, yapabilmek başka</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*VDnWwXBnyJsy81RApE1_ew.png" /></figure><p>Repo-To-Skill ise yetkinliğin farklı bir türünü model dışına taşıyor: <strong>operasyonel bilgi</strong>. Bir LLM belirli bir ML yönteminin ne olduğunu biliyor olabilir. Ama gerçek bir repository içinde bunu çalıştırmak için gereken komutları, bağımlılıkları, konfigürasyon seçeneklerini ve pratik hata modlarını bilmiyor olabilir.</p><p>DisCo sistemi GitHub repository’lerinde bulunan bu know-how’ı tekrar kullanılabilir skill’lere dönüştürüyor.</p><p>Yaklaşık 1.000 yaygın ML reposundan 5.000’den fazla onaylı skill çıkarılmış. GPT-5.5 altyapısı, harness ve çalıştırma bütçesi sabit tutulduğunda sadece bu skill’leri eklemek MLE-bench üzerinde %134,3, PaperBench üzerinde %34,4 performans artışı sağlıyor.</p><p>Bu oldukça önemli çünkü kazanım daha büyük modelden gelmiyor. Daha fazla işlem gücünden de gelmiyor. Sisteme yalnızca daha iyi <strong>operasyonel bağlam </strong>ekleniyor. RAG çoğunlukla şu soruya cevap verir: <em>Bu konu hakkında ne biliyoruz? </em>Skill sistemi ise şuna daha yakın: <em>Bu işi pratikte nasıl yapıyoruz? </em>Bu nedenle RAG’den procedure retrieval’a doğru bir geçiş görüyor olabiliriz.</p><h4>Yeni agent stack’i</h4><p>Bu çalışmaların sonunda ortaya çıkan sistem kabaca şöyle görünüyor:</p><ul><li>Kaynak Model</li><li>Harness</li><li>Araçlar</li><li>Hafıza</li><li>Skills</li><li>Özelleşmiş Modeller</li><li>Varlık Kaydı</li><li>Çalıştırma Ortamı</li><li>Onaylayıcı</li></ul><p>Burada kaynak model hâlâ merkezi muhakeme motoru olabilir. Ancak sistemin toplam yetkinliği giderek daha büyük kısmı model ağırlıkların dışında bulunuyor. Bu da yz mimarilerini “tek dev model” yaklaşımından daha modüler sistemlere doğru taşıyabilir.</p><h3>5. Agent deneyimi artık sadece log değil</h3><p>Eylül’de tekrar tekrar karşıma çıkan başka bir fikir daha var: Bir agent’ın geçmiş çalıştırmaları artık yalnızca debug için saklanan loglar değil. Aynı deneyim farklı çalışmalarda tamamen farklı amaçlarla tekrar kullanılıyor.</p><h4>Atria Dawn: Deneyim eğitim sinyali oluyor</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/971/1*BfBW0mDUOQJLZIC6cN3kdQ.png" /></figure><p>Atria Dawn bilimsel araştırma ve mühendislik için tasarlanmış bir kaynak ajan modeli. Model Doğrulama Deneyimi İşlem Hattı üzerinden araç kullanıyor, çalıştırılabilir ortam ile etkileşime giriyor ve sonuçlar dış onaylayıcı ile kontrol ediliyor.</p><p>Yani eğitim sinyali yalnızca metin tercihlerinden gelmiyor. Agent’ın gerçekten yaptığı işler eğitim materyali haline geliyor.</p><p>Bu yaklaşımda temel döngü şöyle:</p><p><strong>Ajan eyleme geçer → ortam tepki verir → çıktı onaylanır → deneyim eğitim sinyali olur.</strong></p><p>Bu, dil modeli post-training’in giderek daha fazla gerçek çalıştırma geribildirimine bağlanabileceğini gösteriyor.</p><h4>Dream-RSI: Deneyim bu kez simülatör oluyor</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*1HB_EGrhlA1Ty2_83dAQNA.png" /></figure><p>Dream-RSI daha da farklı bir şey yapıyor. Agent’ın geçmiş keşif yörüngelerini bir tekrar oynatma simülatörüne dönüştürüyor. Yeni keşif policy’lerini gerçek ortamda tekrar tekrar denemek çok pahalı. Bunun yerine geçmiş keşif ağaçları üzerinde çevrimdışı şekilde “rüya görüyor”.</p><p>Yeni policy burada ucuz şekilde test ediliyor, geliştiriliyor ve daha sonra yeniden gerçek ortama gönderiliyor. Yeni çevrimiçi keşifler geldikçe simülatör da zenginleşiyor.</p><p>Böylece şu döngü oluşuyor:</p><p><strong>Daha iyi keşif yeteneği → yeni keşifler → daha zengin tekrar oynatma simülatörü → daha iyi keşif yeteneği</strong></p><p>Burada geçmiş deneyim artık hafıza bile değil. Doğrudan yeni policy’lerin üzerinde test edildiği bir <strong>ortam</strong> haline geliyor.</p><h4>WMRL: Environment’ın kendisini modellemek</h4><p>World Model RL aynı maliyet problemine başka taraftan yaklaşıyor. Araştırma ajanı eğitim sırasında model üretimi GPU üzerinde batch edilebiliyor. Ancak agent’ın yazdığı kodu gerçek sandbox’larda çalıştırmak veya deney yapmak makine zamanı tüketiyor.</p><p>Yörünge (trajectory) sayısı arttığında asıl darboğaz çıkarım süreci değil, ortam çalıştırma haline geliyor.</p><p>WMRL gerçek çalıştırmanın bir kısmını öğrenilmiş dünya modeli ile değiştiriyor.</p><p>Ajanın aksiyonunun olası sonucu ve ödülün gerçek ortam yerine dünya modeli tarafından tahmin ediliyor. Elbette dünya modelleri yani world modeller de kusursuz değiller. Ödül tahminleri önyargılı veya gürültülü olabilir.</p><p>Bu nedenle sistem Çevrimiçi Önyargıdan Arındırma ve Ters Varyans Gürültü Azaltma gibi mekanizmalar kullanıyor. Sonuçta eğitim 3–4 kat hızlandırılabiliyor. Burada tekrar aynı deseni görüyoruz: Çalıştırma geri bildirimi <em>çok değerli ama pahalı.</em></p><p>Bu nedenle araştırma, gerçek deneyimi nasıl daha etkili yeniden kullanabileceğimizi arıyor.</p><p>Deneyim:</p><ul><li>Atria’da eğitim verisi.</li><li>Dream-RSI’da simülatör.</li><li>Raven’da tekrar kullanabilir skill.</li><li>Dr. Claw’da kalıcı proje durumu.</li></ul><p>Agent geçmişi artık “geçmişte ne oldu?” kaydı değil. <strong>Sistemin gelecekte nasıl davranacağını belirleyen bir kaynak.</strong></p><h3>6. YZ Ajanı Bilimci fikri görev otomasyonundan proje işbirliğine kayıyor</h3><p>Bilimsel araştırma ajanları bu ay ayrı bir küme oluşturuyor. Bir süre otonom bilim insanı fikri genellikle şöyle anlatılıyordu: Literatür tara, hipotez üret, kod yaz, deney çalıştır, sonuçları analiz et, makale yaz. Eylül’deki çalışmalar ise bunun gerçek kullanımının çok daha fazla durum, koordinasyon ve insan kararı gerektirdiğini gösteriyor.</p><h4>Atria Dawn: İnsan nasıl konumlanıyor?</h4><p>Atria Dawn çalışması gerçek geliştirme sürecinde insan yz işbirliğini incelemesi. 56 katılımcının 769 task kaydı analiz ediliyor. Katılımcılar tamamlanmış yz destekli görevlerin yaklaşık üçte birinin yz olmadan gerçekleştirilemeyeceğini söylüyor.</p><p>Ancak bu, insanın sistemden tamamen çıktığı anlamına gelmiyor. Agent’lar method öneriyor, implementation yapıyor, revizyon gerçekleştiriyor.</p><p>İnsanlar ise çoğunlukla:</p><ul><li>hangi fikrin takip edilmeye değer olduğuna,</li><li>hangi evidence’ın yeterli olduğuna,</li><li>hangi direction’ın daha anlamlı olduğuna,</li><li>ne zaman durulması gerektiğine</li></ul><p>karar veriyor.</p><p>Yani iş bölümü değişiyor. <strong>Eylemi gerçekleştirme yz’ye, karar insana kayıyor. </strong>Bu nedenle araştırmacılar görev seviyesi otomasyon yerine <strong>proje seviyesi işbirliği</strong> kavramını kullanıyor.</p><h4>Dr. Claw: Research için kalıcı çalışma alanı</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/657/1*pJDzkqDAvtfJG39t1rK11Q.png" /></figure><p>Dr. Claw bu fikri mimari seviyeye taşıyor. Yeni bir kaynak model geliştirmek yerine Claude Code veya Gemini CLI gibi mevcut kodlama ajanlarının etrafına kalıcı ve denetlenebilir bir araştırma alanı kuruyor.</p><p>Problem şu: Bugün araştırma iş akışı sohbeti, terminal, IDE, jupyter notebook ve yazma ortamı arasında dağılmış durumda. Bir deney başarısız olduğunda ne denendiği kaybolabiliyor. Bir kararın neden alındığı birkaç gün sonra hatırlanmayabiliyor. Agent sohbeti uzadıkça bağlam dağılabiliyor.</p><p>Dr. Claw kalıcı durum nesneleri, görev grafı ve skill kütüphanesi kullanarak bunu tek bir kurtarılabilir iş akışı haline getiriyor. Burada özellikle <strong>kurtarılabilirlik</strong> önemli. Uzun agent çalıştırmalarında başarısızlık kaçınılmazdır.</p><p>Asıl soru artık: <em>Agent hiç hata yapmayacak mı? </em>değil. <em>Hata yaptıktan sonra nerede kaldığını anlayıp düzgün şekilde devam edebilecek mi? </em>Bu, canlıdaki ajan sistemleri için doğruluk kadar önemli bir özellik olabilir.</p><h4>“Vibe Research” ama denetim izi ile</h4><p>Dr. Claw çalışması buna “Vibe Research” diyor. Vibe coding’de olduğu gibi insan yüksek seviye niyet ve geribildirim verirken yapay zeka uygulaması büyük bölümünü gerçekleştiriyor.</p><p>Fakat bilimsel araştırma için bunun kontrolsüz versiyonu tehlikeli. Son makalenin güzel görünmesi yeterli değil. Hangi hipotez denendi? Hangi kod çalıştırıldı? Hangi deney başarısız oldu? Hangi sonuç hangi kanıta dayanıyor? Bunların tamamının izlenebilir olması gerekiyor.</p><p>Bu nedenle geleceğin YZ araştırma asistanı yalnızca güçlü bir model olmayabilir. Daha çok: kalıcı durum + çalıştırma + kanıt + insan kararları + menşe birleşiminden oluşan bir çalışma alanı olabilir.</p><h3>7. Model ağırlıklarına sürekli yeni bilgi yazmak hâlâ zor</h3><p>Eylül’deki iki çalışma ajan sistemlerinden biraz ayrılıp doğrudan model ağırlıklarının zaman içinde nasıl değiştiğine bakıyor. Bunları ayrı tutmak faydalı çünkü diğer makalelerin büyük kısmı yetkinliği model dışına taşırken bu çalışmalar tam tersine ağırlık seviyesi adaptasyonunun ne kadar karmaşık olduğunu gösteriyor.</p><h4>Sürekli öğrenme: 100 update sonra ne hatırlıyoruz?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*9cH2r8ZJgUJA28zPFREXkg.png" /></figure><p>‘’Continual Learning Mechanisms Compose’’ çalışması modeli sırayla 100 farklı görev üzerinde fine-tune ediyor. Eski eğitim örnekleri tutulmuyor. Naif ardışık ince ayarlama sonucunda yıkıcı unutma durumu çok büyük.</p><p>Final retention yalnızca %1,2 seviyesine kadar düşüyor. Tek bir sürekli öğrenme yöntemi de problemi çözmüyor. En iyi yöntem veri, fonksiyon ve ağırlık anchor’ları merged LoRA ile birlikte kullanıyor ve ortalama retention’ı %34,9’a çıkarıyor. Bu yaklaşık 28 kat improvement.</p><p>Buradaki önemli mesaj şu: <em>Forgetting tek bir problem değil. </em>Geçmiş verinin temsil edilmesi, işlev kayması, ağırlık kayması ve yeni güncellemelerin nerede saklandığı farklı mekanizmalar.</p><p>Dolayısıyla sürekli öğrenme de composition gerektiriyor. Bu aynı zamanda gelecek ajan hafızası mimarileri için ilginç bir soru oluşturuyor. Her yeni bilgi ağırlıklara mı yazılmalı? Hayır. Bazıları bağlam içinde kalabilir.</p><p>Bazıları dış hafıza olabilir. Bazıları tekrar kullanılabilir skill olabilir. Sadece gerçekten içselleştirilmesi gereken bilgi ağırlıkları veya adaptörlere yazılabilir.</p><p>Dolayısıyla gelecekte ajanlarda bir çeşit hafıza hiyerarşisi görebiliriz: Çalışan bağlam <strong>→ dış hafıza → skill → adaptör ağırlıkları.</strong></p><p>Asıl problem yalnızca hatırlamak değil, <strong>hangi bilginin hangi katmanda tutulacağını seçmek</strong> olabilir.</p><h3>8. Post-training düşündüğümüzden daha fazla iz bırakıyor olabilir</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F_7qRAQfY_XpXVKSUmE0BA.png" /></figure><p>Post-Training Leaves Behavioral Shadows on Unrelated Decisions bu ayın en garip ama en ilginç çalışmalarından biri. Temel bulgu şu: Bir model belirli bir yetkinlik üzerinde post-train edildiğinde, bu değişimin izleri yalnızca o yetkinlik ile ilgili cevaplarda kalmıyor.</p><p>Modelin tamamen alakasız görünen kelime tercihleri bile sistematik olarak değişebiliyor. Araştırmacılar Aktif Görevsiz Distilasyon adını verdikleri yöntemde öğretmen model’den hedef görev çözümünü almıyor.</p><p>Öğretmen logit’leri yok. Ağırlıklar yok. Hedef görev eğitim örnekleri yok. Her prompt için yalnızca <strong>tek bir normal kelime</strong> alınıyor. Prompt’lar ortak ata modelin iki kelime arasında neredeyse kararsız kaldığı durumlar arasından seçiliyor. Öğretmen post-training gördükten sonra bu iki kelimeden birine hafifçe kayıyor. Öğretmen yalnızca bu istem-kelime çiftleriyle eğitiliyor. Buna rağmen kodlama yetkinliğinde ölçülebilir. iyileşme oluşuyor.</p><p>Qwen2.5–1.5B deneyinde HumanEval+ üzerinde yaklaşık +5,34 yüzde puan fark görülüyor. Benzer transfer bilimsel bilgi, sağduyu muhakemesi ve okuduğunu anlama tarafında da raporlanıyor.</p><p>Bunu basitleştirirsek ortaya çok tuhaf bir durum çıkıyor:</p><ul><li><strong>Öğretmen kodlama öğrendi.</strong></li><li><strong>Kodlamayla ilgisiz kelime tercihleri biraz değişti.</strong></li><li><strong>Öğretmen bu kelime tercihlerini öğrendi.</strong></li><li><strong>Öğretmenin kodlama performansı yükseldi.</strong></li></ul><p>Bu, yetkinliklerin sinir ağı içinde düşündüğümüz kadar lokal olmayabileceğini gösteriyor. Post-training bir davranışı izole şekilde değiştirmek yerine modelin genel olasılık dağılımında çok küçük ama sistematik izler bırakabiliyor.</p><p>Bunun güvenlik açısından da ilginç sonuçları olabilir. Bir modelin post-training geçmişi doğrudan görevi sormadan davranışlarından çıkarılabilir mi? Sentetik veri kümeleri görünüşte alakasız yetkinlik sinyallerini başka modellere taşıyabilir mi? Fine-tuning sırasında yalnızca hedef metriğe bakarak başka davranışlarda oluşan değişiklikleri kaçırıyor olabilir miyiz? Henüz erken, ancak model adaptasyonunu düşündüğümüzden daha global bir süreç olabileceğini gösteriyor.</p><h3>9. Özyinelemeli Kendini İyileştirme Geliyor ama Sandığımız Biçimde Değil</h3><p>”Recursive self-improvement” deyince akla bazen yapay zekanın kendi mimarisini yeniden yazıp sürekli daha güçlü hale geldiği bilimkurguya yakın bir senaryo geliyor. Eylül paper’larında gördüğümüz şey daha dar ama daha gerçekçi.</p><p>Kendini iyileştirme şu anda çoğunlukla şu seviyelerde gerçekleşiyor:</p><ul><li>harness modifikasyonu,</li><li>keşif politikası optimizasyonu,</li><li>skill elde etme,</li><li>deneyimi tekrar kullanma,</li><li>araç orkestrasyonu,</li><li>veri seçimi,</li><li>sınırlı ağırlık güncelleme.</li></ul><p>Dream-RSI örneğin kodlama ajanının kendisini değiştirmiyor. Onun <strong>nasıl araştırma yaptığı</strong> geliştiriliyor. RRSI model ağırlıklarına dokunmuyor. Harness’ın öneri ve seçme işlemleri geliştiriliyor. ModularRSI agent’ın muhakeme çekirdeğini değiştirmiyor.</p><p>Çalıştırma sistemindeki tekrar eden hata modları bulup ilgili modülü değiştiriyor. Raven farklı özelleştirilmiş model-harness çiftlerini daha iyi compose etmeye çalışıyor.</p><p>Bu nedenle bugünkü RSI için daha doğru tanım belki şu:</p><blockquote><em>Modelin kendisini yeniden tasarlamasından çok, yz sisteminin kendi çalışma mekanizmalarını deneyim üzerinden optimize etmeye başlaması.</em></blockquote><p>Bu daha az dramatik görünebilir. Ama production açısından muhtemelen çok daha önemli. Çünkü aynı model ağırlıklarıyla çalışan bir sistem daha iyi araç seçebilir, daha iyi bağlam oluşturabilir, daha iyi specialist çağırabilir, daha iyi arıza kurtarma yapabilir, daha iyi keşif politikası kullanabilir, ve bütün bunlar final yetkinliği ciddi biçimde değiştirebilir.</p><h4>Sonuç</h4><p>Eylül ayında benim için en belirgin değişim, <strong>harness engineering’in yavaş yavaş harness learning’e dönüşmesi</strong> oldu. Artık yalnızca istem, araç ve kontrol akışı tasarlamıyoruz; harness’ların nasıl evrileceğini, başka görevlere nasıl transfer olacağını, benchmark’a overfit edip etmediğini, hangi modülün gerçekten sorun çıkardığını ve karmaşıklığın nasıl kontrol edileceğini araştırıyoruz. Bununla birlikte agent mimarisi de giderek daha birleştirilebilir hale geliyor. Geleceğin ajanı tek bir dev model yerine bir muhakeme çekirdeğinin etrafındaki specialist modeller, skills, araçlar, hafıza, varlık deposu ve çalıştırma ortamı bileşiminden oluşabilir. Yetkinliğin tamamını model ağırlıklarının içine sıkıştırmak zorunda olmayabiliriz.</p><p>Bu sistemlerde <strong>deneyim giderek daha değerli bir varlık haline geliyor</strong>. Agent’ın geçmiş çalıştırmaları artık yalnızca log olarak tutulmuyor; eğitim verisine, tekrar kullanılabilir skill’e, hafızaya, değerlendirme verisine veya yeni politikaların test edildiği bir simülatöre dönüşebiliyor. Bilimsel ajan çalışmalarında da benzer bir değişim var. Tamamen otonom bilim insanı yerine, yapay zekanın çalıştırma, implementasyon, arama ve revizyon tarafında daha fazla sorumluluk aldığı; insanın ise problem seçimi, yargı, yön ve kanıt yorumlama tarafında kaldığı bir <strong>insan-yz araştırma takımı </strong>modeli daha gerçekçi görünüyor.</p><p>Ancak bütün bu kendini iyileştirme çalışmalarının ortak bir problemi var: <strong>Sistemin kendisini değiştirebilmesi, gerçekten geliştiği anlamına gelmiyor.</strong> Agent prompt’unu değiştirebilir, yeni skill oluşturabilir, harness’ını evolve edebilir veya ağırlık güncelleyebilir; fakat local benchmark’taki artış gerçek-dünya iyileştirmelere transfer etmeyebilir. ASPIRE, HarnessDev ve RRSI gibi çalışmalar tekrar tekrar değerlendirme, aşırı uyum ve zayıf transfer problemlerini gösteriyor. Ağırlık seviyesi öğrenme tarafında da durum çok temiz değil: sürekli öğrenme yıkıcı unutma ile uğraşırken davranış-gölge çalışmaları bir yetkinlik güncellemenin alakasız görünen davranışlara bile iz bırakabildiğini gösteriyor.</p><p><strong>Ağustos’ta modelin etrafındaki sistem daha zeki hale getiriliyordu; Eylül’de ise sisteme kendini geliştirme yeteneği kazandırmaya çalışıyorlar.</strong> Ancak asıl soru hâlâ aynı: <strong>Sistem, yaptığı değişikliğin gerçekten daha iyi olduğunu nasıl anlayacak?</strong> Bu yüzden önümüzdeki dönemin temel problemi otonomiden çok, güvenilir geri bildirim, doğrulama ve genelleştirme olabilir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b93ac0671cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/eyl%C3%BCl-2026-yz-ara%C5%9Ft%C4%B1rma-trendleri-1b93ac0671cf">Eylül 2026 YZ Araştırma Trendleri</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ağustos 2026 Yapay Zeka Araştırma Trendleri]]></title>
            <link>https://medium.com/softtechas/a%C4%9Fustos-2026-yapay-zeka-ara%C5%9Ft%C4%B1rma-trendleri-e4b061312e0b?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/e4b061312e0b</guid>
            <category><![CDATA[yz-makaleleri]]></category>
            <category><![CDATA[yapay-zeka-araştırma-yönü]]></category>
            <category><![CDATA[yz-çalışmaları]]></category>
            <category><![CDATA[yz-araştırma-trendleri]]></category>
            <category><![CDATA[yznin-geleceği]]></category>
            <dc:creator><![CDATA[Cahit Barkin Ozer]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 08:36:44 GMT</pubDate>
            <atom:updated>2026-10-15T08:36:43.287Z</atom:updated>
            <content:encoded><![CDATA[<p>Ağustos 2026&#39;daki temel yapay zeka araştırma eğilimlerini belirlemek amacıyla Hugging Face Daily Papers’ı inceledim ve bu eğilimleri özetledim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uxSQEMRRkfIC5s1d4HceTw.png" /></figure><h3>Giriş</h3><p>Hugging Face Daily Papers, araştırmacıların yeni makaleleri paylaştığı ve topluluğun bu çalışmalara oy verebildiği bir platform. Makaleler aldıkları upvote sayısına göre günlük, haftalık ve aylık olarak sıralanıyor; böylece belirli bir dönemde en fazla ilgi gören çalışmalar kolayca takip edilebiliyor.</p><p>Ben de buradan yola çıkarak her ay, o dönemde öne çıkan yapay zekâ araştırmalarını incelemeye karar verdim. Temel motivasyonlarımdan biri şu varsayımdı: <strong>Araştırmaların bugün hangi yöne ilerlediğini anlayabilirsek, gelecekteki teknolojik gelişmelerin hangi alanlarda yoğunlaşacağını da kısmen öngörebiliriz.</strong></p><p>Bu nedenle, Hugging Face üzerinde Ağustos 2026 döneminde (<a href="https://huggingface.co/papers/month/2026-08">Hugging Face Papers — August 2026</a>) öne çıkan preprint makaleleri inceleyerek bunlardan çıkan temel eğilimleri aşağıda kısa şekilde özetledim.</p><p>Ağustos 2026’daki çalışmalardaki en belirgin değişim: <strong>Araştırma odağı daha iyi model üretmekten, modelin içinde çalıştığı tüm sistemi geliştirmeye doğru kayıyor. </strong>Araştırmacılar artık “modeli biraz daha büyütelim” demekten çok, context nasıl yönetiliyor, agent hangi tool’ları kullanıyor, agent’in yaptığı iş nasıl doğrulanıyor, environment nasıl tasarlanıyor ve hatalar nasıl yakalanıyor sorularına odaklanıyor.</p><h4>1. Agent runtime artık model kadar önemli</h4><p>Uzun görevlerde güçlü modeller bile zamanla context içinde kaybolabiliyor, önceki adımları unutabiliyor veya işin gerçekten tamamlanıp tamamlanmadığını yanlış değerlendirebiliyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rTqbPHgJ_ocKACtibrmLnw.png" /></figure><p>StateM ve LongHorizon-Harness gibi çalışmalar bunun için görevi aşamalara bölüyor, state’i modelin konuşma geçmişi yerine dışarıda tutuyor ve her aşamada bağımsız doğrulama çalıştırıyor.</p><p>Buradaki fikir basit:</p><p><strong>Model her şeyi hatırlamak zorunda değil. Sistem doğru bilgiyi doğru anda modele vermeli.</strong></p><p>Hatta bazı çalışmalarda daha zayıf bir modelin etrafına iyi bir harness kurmak, modeli değiştirmeden çok ciddi performans artışı sağlayabiliyor.</p><p>Ancak bu yöntemler her modele aynı şekilde taşınmıyor. Bir modelde işe yarayan runtime başka bir model ailesinde aynı sonucu vermeyebiliyor.</p><h4>Buradan ne çıkarıyoruz?</h4><p>Agent geliştirirken ilk refleksimiz fine-tuning olmamalı.</p><p>Önce şunlara bakmak daha mantıklı olabilir:</p><ul><li>context yönetimi,</li><li>state tracking,</li><li>tool routing,</li><li>görev aşamalarının ayrılması,</li><li>deterministic verification.</li></ul><h4>2. Harness’ler artık kendi kendini optimize etmeye başlıyor</h4><p>Runtime tasarlamak da insan emeği gerektiriyor. Yeni çalışmalar bu işi de otomatikleştirmeye çalışıyor.</p><p>DarwinX farklı agent yapılarını evrimsel olarak deneyip iyi çalışan parçaları koruyor. Ouroboros ise daha ileri giderek agent’ın kendi tool’larını, prompt’larını ve runtime kodunu değiştirmesine izin veriyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WrbddO5aGwUEKd6zYQOs3w.png" /><figcaption><a href="https://arxiv.org/abs/2608.09819">https://arxiv.org/abs/2608.09819</a></figcaption></figure><p>Macaron-V1 gibi sistemler de tek bir sabit agent yerine farklı runtime ve LoRA konfigürasyonlarını deneyerek göreve uygun kombinasyonu bulmaya çalışıyor.</p><p>Buradaki trend: <strong>Artık yalnızca model ağırlıkları optimize edilmiyor; modelin etrafındaki yazılım sistemi de arama uzayı haline geliyor.</strong></p><p>Fakat burada önemli bir risk var: Aynı benchmark üzerinde sürekli harness ararsanız, sistemi gerçekten genelleştirmek yerine benchmark’a overfit edebilirsiniz.</p><p>Ayrıca “100 görevin tamamı çözüldü” denildiğinde bunun tek bir agent tarafından mı, yoksa yüzlerce farklı konfigürasyon arasından en iyi sonuçların birleştirilmesiyle mi elde edildiğine dikkat etmek gerekiyor.</p><h4>3. Agent’lar kendi deneyimlerinden öğreniyor</h4><p>Bir agent’ın yaptığı her adımı insan eliyle etiketlemek çok pahalı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_l9B8-94KeTJCvDTcUb6Vw.png" /></figure><p>Bu yüzden araştırmacılar agent’ın kendi rolloutlarından eğitim sinyali çıkarmaya çalışıyor.</p><p>Bazı yöntemler modelin farklı cevaplarını karşılaştırıp çoğunluğun doğru olduğunu varsayıyor. Bazıları başarısız bir uzun trajectory içinde “hangi adımın sonucu gerçekten değiştirdi?” sorusunu bulmaya çalışıyor. Bazıları ise farklı modellerin birbirlerini eleştirmesini kullanıyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fIL_JNddhIQxHJqcIaAZyw.png" /><figcaption><a href="https://arxiv.org/abs/2608.06296v2">https://arxiv.org/abs/2608.06296v2</a></figcaption></figure><p>Temel fikir şu: <strong>Başarılı veya başarısız execution’ın kendisi yeni training data olabilir.</strong></p><p>Bu önemli çünkü gelecekte YZ sistemleri yalnızca insan tarafından hazırlanmış verilerden değil, kendi çalışmaları sırasında topladıkları deneyimlerden de gelişebilir.</p><p>Fakat burada büyük bir problem var: Eğer modeller aynı yanlış fikre birlikte inanırsa sistem hatasını kendi kendine güçlendirebilir. Yani <strong>self-learning kadar independent verification da önemli.</strong></p><h4>4. Environment artık hem eğitim aracı hem saldırı yüzeyi</h4><p>Bir agent’ı geliştirmek için yalnızca yeni sorular üretmek yerine, içinde çalıştığı environment de değiştirilmeye başlanıyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wZhklVpeM43pC23DBAtKUQ.png" /></figure><p>EnvHarness gibi sistemler mevcut simülatörü bozmadan görevleri zorlaştırıyor, bazı kolay yolları kapatıyor veya birden fazla görevi zincir haline getiriyor. Böylece modelin gerçekten eksik olduğu becerilere yönelik otomatik curriculum üretilebiliyor.</p><p>Synthetic task üretiminde de benzer bir yaklaşım var: Yeni görev üretmek kolay, fakat görevin gerçekten tutarlı ve çözülebilir olduğunu garanti etmek zor. Bu nedenle generated taskların deterministic checkerlardan geçirilmesi gerekiyor.</p><p>Diğer tarafta OpenART önemli bir güvenlik problemi gösteriyor: <strong>Saldırı her zaman prompttan gelmeyebilir.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3rV51ZlrcGVvNmky5TSbKg.png" /></figure><p>Agent’ın workspace’indeki bir dosya, database state’i veya tool çıktısı manipüle edilerek çok daha sonra yanlış bir davranış tetiklenebilir. Bu yüzden uzun süreli çalışan agent sistemlerinde güvenlik yalnızca input moderation değildir. <strong>Environment state (ortam durumu) sürekli denetlenmelidir.</strong></p><h4>5. Benchmark’lar tek cevaptan gerçek workflow’lara kayıyor</h4><p>Bir modelin tek bir doğru cevap üretmesi, gerçek dünyada bir işi tamamlayabileceği anlamına gelmiyor.</p><p>Yeni benchmarklar bu yüzden tüm execution sürecini incelemeye başlıyor.</p><p>Örneğin ,bilimsel araştırma görevlerinde yalnızca final rapora değil, verinin gerçekten işlendiğine, deneyin çalıştırıldığına ve ara artefaktların gerçekten üretildiğine bakılıyor.</p><p>Software engineering benchmarkları da tek dosyalık bu fixlerden repository çapında değişikliklere doğru ilerliyor.</p><p>Bunun nedeni şu: <strong>LLM’ler bazen görevin bir bölümünde başarısız olduktan sonra işi tamamlamış gibi davranabiliyor.</strong></p><p>Dolayısıyla gelecekte önemli metrik yalnızca “cevap doğru mu?” değil: <strong>sistem gerçekten işi yaptı mı?</strong></p><p>Deepfake detection tarafında da benzer bir sonuç görülüyor. Laboratuvar ortamında çok iyi çalışan dedektörler, sosyal medya sıkıştırması veya gerçek görüntülerden üretilmiş videolar gibi gerçek dünya koşullarında ciddi şekilde bozulabiliyor.</p><p>Yani benchmark başarısı ile deployment başarısını birbirinden ayırmak gerekiyor.</p><h3>6. YZ araştırma sürecinin kendisini otomatikleştirmeye başlıyor</h3><p>Spark-to-Paper ve Mechanist gibi çalışmalar, YZ’yi yalnızca paper okumak veya özetlemek için değil, doğrudan araştırma yapmak için kullanıyor.</p><p>Bir sistem: literature search yapıyor → hypothesis oluşturuyor → deney tasarlıyor → kod yazıyor → deney çalıştırıyor → sonuçları analiz ediyor → paper taslağı oluşturuyor.</p><p>Mechanist ise bunu model behaviour araştırmasına uyguluyor ve model içinde belirli davranışların neden oluştuğunu deneylerle test etmeye çalışıyor.</p><p>Bu bence önemli bir yön değişimi: <strong>YZ</strong> <strong>artık sadece bilgi üretmiyor; evidence üretmeye çalışıyor.</strong></p><p>Fakat burada da verification temel problem.</p><p>Deney yanlış tasarlanırsa, sistem çok ikna edici ama yanlış bir bilimsel açıklama oluşturabilir.</p><p>Bu nedenle tamamen autonomous research henüz güvenilir değil; güçlü verifier ve human oversight gerekiyor.</p><h4>7. Reasoning sadece yazılı Chain-of-Thought olmak zorunda değil</h4><p>Bugün reasoning (muhakeme) denildiğinde genellikle modelin uzun uzun düşünce tokenleri üretmesi akla geliyor.</p><p>Yeni çalışmalar bunun zorunlu olmadığını gösteriyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oQGbhoEjaUelw_e_idoWHA.png" /><figcaption><a href="https://arxiv.org/abs/2608.09888">https://arxiv.org/abs/2608.09888</a></figcaption></figure><p>BDH-CQ gibi modeller reasoning’i language token üretmeden, recurrent latent state içinde yapmaya çalışıyor.</p><p>Başka çalışmalarda ise model ara adımlarda text yerine image üretiyor ve bu görüntüleri çalışma belleği gibi kullanıyor.</p><p>Özellikle spatial reasoning görevlerinde intermediate visual state kaldırıldığında performansın ciddi şekilde düşmesi önemli bir işaret:</p><p><strong>Bazı problemler için en iyi reasoning medium language olmayabilir.</strong></p><p>Gelecekte modellerin düşünme süreci text, latent state, image veya bunların birleşiminden oluşabilir.</p><h4>8. Deployment sorunları araştırmanın merkezine geliyor</h4><p>Son trend teorik model performansından çok gerçek deployment problemleriyle ilgili.</p><p>Sparse Modeller edge cihazlarda çalıştırılmaya çalışılıyor. Bunun için VRAM, RAM ve NVMe birlikte kullanılarak yalnızca gerekli expertlerin belleğe alınması gibi yöntemler geliştiriliyor.</p><p>API tarafında ise reasoning modellerinin kullandığı opaque stattokenlarının düşündüğümüz kadar güvenli olmayabileceği gösteriliyor. Eğer bu state farklı sessionlar arasında veya modeller arasında taşınabiliyorsa, proprietary reasoning bilgisi sızabilir.</p><p>Son olarak, ComBodied Agents gibi çalışmalar farklı bir problemi gündeme getiriyor: <strong>Kişisel YZ her şeyi bizim yerimize yapmalı mı?</strong></p><p>Bir agent sürekli bütün işleri otomatikleştirir; kullanıcının kendi becerileri zamanla körelebilir.</p><p>Bu nedenle gelecekte bazı personal agent’lar yalnızca “görevi en hızlı nasıl tamamlarım?” sorusunu değil, <strong>“Bu görevi kullanıcı adına yapmam uzun vadede kullanıcıya zarar verir mi?” </strong>sorusunu da değerlendirebilir.</p><h3>Ana Çıkarımlar</h3><p>Bu çalışmalara bakınca, tek tek yöntemlerden daha önemli birkaç ortak yön ortaya çıkıyor.</p><h4>1. Model performansı artık sistem performansından ayrı düşünülemez</h4><p><a href="https://cdn-images-1.medium.com/max/1056/1*iGQhGbeesCRxEztChsHi1Q.png">image</a></p><p>Bir YZ sisteminin başarısını yalnızca kullandığı model belirlemiyor. <strong>Harness, tools, memory, environment ve verification</strong> katmanları birlikte performansı belirleyen sistemin parçaları haline geliyor.</p><p>Bu yüzden önümüzdeki dönemde yalnızca “hangi model daha iyi?” değil, <strong>“hangi model hangi sistem tasarımı içinde daha iyi çalışıyor?”</strong> sorusu daha önemli olabilir.</p><h4>2. Ölçek büyüdükçe asıl problem güvenilirlik oluyor</h4><p>Generation giderek ucuz ve kolay hale geliyor. Buna karşılık sistemin ürettiği sonucun gerçekten doğru olduğunu, kodun çalıştığını veya uzun bir görevin gerçekten tamamlandığını kanıtlamak hâlâ zor.</p><p>Bu yüzden <strong>verification</strong>, agent sistemlerinin temel altyapı problemlerinden biri haline geliyor.</p><p>Bu aynı zamanda neden coding, formal reasoning veya simulator tabanlı alanlarda daha hızlı ilerleme gördüğümüzü de açıklayabilir: Bu alanlarda başarının daha objektif şekilde ölçülebileceği verifier’lar bulunuyor.</p><h4>3. Agent geliştirme giderek bir optimization problemine dönüşüyor</h4><p>Bugün prompt engineering olarak düşündüğümüz şey daha geniş bir arama problemine dönüşebilir.</p><p>Sistemin;</p><ul><li>hangi tool’ları kullanacağı,</li><li>context’i nasıl yöneteceği,</li><li>hangi bilgiyi memory’de tutacağı,</li><li>hangi control flow’u izleyeceği,</li><li>sonucu nasıl doğrulayacağı</li></ul><p>elle tasarlanmak yerine otomatik olarak aranabilir ve optimize edilebilir.</p><p>Bu durumda agent geliştirmek yalnızca prompt yazmak değil, <strong>bir runtime architecture search problemi</strong> haline geliyor.</p><h4>4. En ilginç döngü: Sistemin çalışması, sistemin eğitim verisine dönüşebilir</h4><p><a href="https://cdn-images-1.medium.com/max/1056/1*QgFM-jfb1mnLcT4RgGVQpA.png">image</a></p><p>Uzun vadede agent’ların en değerli veri kaynaklarından biri kendi execution history’leri olabilir.</p><p>Başarılı trajectory’ler, failure’lar, tool kullanımı ve diğer modellerden gelen feedback yeni training signal’lara dönüştürülebilir. Böylece deployment ile training arasındaki sınır giderek bulanıklaşabilir.</p><p>Buradaki kritik koşul ise bağımsız doğrulama. Sistem kendi hatalarını training data haline getirirse self-improvement yerine <strong>self-reinforcing error loop</strong> oluşabilir.</p><h4>5. Gerçek agent problemi aslında uzun süre güvenilir çalışabilmek</h4><p>Bütün trendler bir araya geldiğinde benim için en önemli değişim burada ortaya çıkıyor.</p><p>Artık asıl soru yalnızca:</p><p><strong>“Model bu sorunun cevabını biliyor mu?”</strong></p><p>değil.</p><p>Daha zor soru:</p><p><strong>“Bu sistem gerçek bir environment içinde uzun süre çalışabilir, doğru state’i koruyabilir, gerektiğinde tool kullanabilir, hatalarını fark edebilir ve sonunda görevin gerçekten tamamlandığını doğrulayabilir mi?”</strong></p><p>Bu soru model capability’den çok <strong>system reliability</strong> ile ilgili.</p><h3>Sonuç</h3><p>Bu çalışmalar bana bir sonraki büyük ilerlemenin yalnızca daha büyük modellerden gelmeyebileceğini düşündürüyor.</p><p>Daha olası görünen yön, güçlü modelleri; daha iyi runtime, verification, memory, environment ve experience-based learning mekanizmalarıyla birleştirmek.</p><p>Ancak sonuçları fazla genellememek gerekiyor. İncelenen çalışmaların büyük bölümü henüz peer review görmemiş preprint’ler ve bazı güçlü sonuçlar benchmark-specific optimization veya harness overfitting kaynaklı olabilir.</p><p>Ayrıca bugün external scaffolding olarak gördüğümüz birçok yöntem zamanla foundation model post-training süreçlerine gömülebilir. Yani bugün ayrı ayrı gördüğümüz <strong>model ve harness</strong> katmanları gelecekte yeniden birbirine yaklaşabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iuqCwr7AMhx1UI5e3PeoKQ.png" /></figure><p>Benim bu makalelerden çıkardığım en kısa sonuç şu:</p><blockquote><strong><em>YZ araştırması yalnızca daha zeki modeller üretmeye değil, mevcut zekâyı uzun süre güvenilir şekilde kullanabilecek daha iyi sistemler kurmaya doğru genişliyor.</em></strong></blockquote><h4>1. Model tek başına ürün değil</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iGQhGbeesCRxEztChsHi1Q.png" /></figure><p>Güçlü bir YZ sistemi artık kabaca: <strong>Model + Harness + Tools + Memory + Environment + Verifier </strong>olarak düşünülmeli. Model aynı kalsa bile, bu katmanları değiştirerek ciddi performans kazanımı elde edilebiliyor.</p><h4>2. Asıl darboğaz generation değil verification olabilir</h4><p>Modelin bir şey üretmesi giderek kolaylaşıyor.</p><p>Zor olan: <strong>Ürettiği şey gerçekten doğru mu, gerçekten çalışıyor mu, görev gerçekten tamamlandı mı?</strong></p><p>Bu nedenle unit test, deterministic checker, simulator veya external verifier bulunan alanlarda agent sistemleri çok daha hızlı ilerliyor.</p><h4>3. Uzun görevlerde state yönetimi kritik</h4><p>Uzun context’e her şeyi doldurmak iyi bir memory sistemi değil. State’i dışarıda tutmak, verified bilgiyi saklamak ve gerektiğinde modele yalnızca ilgili kısmı vermek daha sağlam bir yaklaşım gibi görünüyor.</p><h4>4. Runtime da optimize edilebilir bir katmana dönüşüyor</h4><p>Prompt engineering’in daha genel bir versiyonuna doğru gidiyoruz.</p><p>Artık sadece prompt değil;</p><ul><li>tool set,</li><li>control flow,</li><li>memory,</li><li>verifier,</li><li>context policy</li></ul><p>otomatik olarak optimize edilebilir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4b061312e0b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/a%C4%9Fustos-2026-yapay-zeka-ara%C5%9Ft%C4%B1rma-trendleri-e4b061312e0b">Ağustos 2026 Yapay Zeka Araştırma Trendleri</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java Virtual Threads: Carrier Thread ve Scheduler Nasıl Çalışır?]]></title>
            <link>https://medium.com/softtechas/java-virtual-threads-carrier-thread-ve-scheduler-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-7db9d40c2d64?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/7db9d40c2d64</guid>
            <category><![CDATA[virtual-threads]]></category>
            <category><![CDATA[threading-in-java]]></category>
            <category><![CDATA[carrier-threads]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[threads]]></category>
            <dc:creator><![CDATA[Didem AĞDOĞAN]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 08:06:31 GMT</pubDate>
            <atom:updated>2026-09-08T08:06:30.107Z</atom:updated>
            <content:encoded><![CDATA[<p>Java Virtual Thread serisinin önceki yazılarında Virtual Thread’lerin ne olduğunu, neden ortaya çıktığını ve uygulamalarda nasıl kullanılabileceğini incelemiştik. Ancak Virtual Thread’lerin arkasındaki scheduler mekanizması çoğu zaman bir “kara kutu” olarak kalmaktadır.</p><blockquote><em>10.000 Virtual Thread oluşturduğumuzda bunların kaçı aynı anda gerçekten çalışabilir?</em></blockquote><blockquote><em>Carrier Thread nedir?</em></blockquote><blockquote><em>Scheduler kaç Thread oluşturur?</em></blockquote><blockquote><em>Runtime.getRuntime().availableProcessors() değeri neden önemlidir?</em></blockquote><blockquote><em>Bir Virtual Thread I/O beklemeye başladığında carrier thread’e ne olur?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s4-7uTGgSqS1OmYiYOcu6Q.png" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Bu yazıda Virtual Thread scheduler’ın çalışma mantığını, carrier thread kavramını ve scheduler ayarlarının uygulamanın çalışma davranışına etkilerini daha yakından inceleyeceğiz.</p><p>Önceki yazıda Virtual Thread kullanımının yalnızca <strong><em>spring.threads.virtual.enabled=true </em></strong>ayarını etkinleştirmekten ibaret olmadığını; ThreadLocal, connection pool, concurrency limitleri ve mevcut thread pool tasarımlarının da değerlendirilmesi gerektiğini görmüştük.</p><p>Şimdi ise bir katman daha aşağı inerek JVM’in binlerce Virtual Thread’i sınırlı sayıdaki carrier thread üzerinde nasıl çalıştırabildiğine bakalım.</p><p>Spring Boot kullanmadan bir Virtual Thread’i doğrudan Java API’si ile oluşturabiliriz:</p><pre>Thread.startVirtualThread(() -&gt; {<br>   System.out.println(&quot;Hello Virtual Thread&quot;);<br>});<br>veya<br>Thread.ofVirtual().start(() -&gt; { <br>   System.out.println(&quot;Hello Virtual Thread&quot;);<br>});</pre><p>Her iki kullanım da Java 21 ile gelen saf Java API’sidir. Burada Virtual Thread’i oluşturmak oldukça basit görünüyor. Ancak asıl ilginç soru şudur:</p><blockquote><em>Bu Virtual Thread gerçekte hangi Thread üzerinde çalışıyor?</em></blockquote><p>Virtual Thread doğrudan bir işletim sistemi thread’ine kalıcı olarak bağlı değildir. Çalışabilmesi için JVM tarafından bir <strong>Carrier Thread</strong> üzerine mount edilir. Carrier thread ise işletim sistemi tarafından schedule edilen bir platform thread’dir.</p><p>Basitleştirilmiş olarak çalışma modelini şöyle düşünebiliriz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/278/1*tHCNzqXzucpNeIiG4ZxtXQ.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>JVM, çok sayıdaki Virtual Thread’in sınırlı sayıdaki carrier thread üzerinde çalıştırılmasını bir <strong>Virtual Thread Scheduler</strong> aracılığıyla yönetir. Java 21&#39;de bu scheduler, Virtual Thread’ler için kullanılan özel bir ForkJoinPool implementasyonuna dayanır.</p><p>Burada karşımıza önemli bir kavram çıkıyor: <strong>Parallelism</strong>.</p><p>Çünkü scheduler’ın kaç Virtual Thread’i aynı anda carrier thread’ler üzerinde çalıştırabileceğini anlamak için önce hedef paralellik seviyesine bakmamız gerekir.</p><p>Virtual Thread scheduler’ın varsayılan target parallelism değeri JVM’in gördüğü kullanılabilir işlemci sayısına dayanır:</p><p><strong><em>Runtime.getRuntime().availableProcessors()</em></strong></p><p>Basitleştirilmiş olarak:</p><p><strong><em>default parallelism = availableProcessors()</em></strong></p><p>Örneğin JVM <strong><em>availableProcessors()</em></strong> değerini 16 olarak görüyorsa scheduler’ın varsayılan <strong>target parallelism</strong> değeri de 16 olur.</p><p>Burada önemli bir ayrım vardır:</p><p><strong>parallelism = 16, JVM her zaman tam olarak 16 carrier thread oluşturur anlamına gelmez.</strong></p><p>Parallelism, scheduler’ın hedeflediği eşzamanlı çalışma seviyesidir. Scheduler’ın gerçek carrier/worker thread sayısı çalışma sırasında farklılaşabilir.</p><p>Burada dikkat edilmesi gereken nokta, JVM’in doğrudan fiziksel çekirdek sayısını değil, <strong><em>Runtime.getRuntime().availableProcessors() </em></strong>ile gördüğü kullanılabilir işlemci sayısını esas almasıdır. Modern işlemcilerde Hyper-Threading (Intel) veya SMT (AMD) nedeniyle bir fiziksel çekirdek birden fazla mantıksal işlemci olarak görülebilir.</p><p><strong><em>-Djdk.virtualThreadScheduler.parallelism=100</em></strong></p><p>Parallelism değerini 100 yapmak, 100 carrier thread’in CPU üzerinde gerçekten paralel olarak çalışacağı anlamına gelmez. Özellikle CPU-bound workload’larda runnable carrier sayısını işlemci kapasitesinin çok üzerine çıkarmak ek context switching ve scheduling overhead oluşturabilir. Virtual Thread’in amacı carrier thread sayısını çok artırmak değil, bekleyen Virtual Thread’leri az sayıda carrier thread üzerinde verimli şekilde çalıştırabilmektir.</p><p>Bu ayar ancak özel ve ölçülmüş senaryolarda değiştirilmelidir. Genel kural olarak varsayılan değerle başlamak ve gerçek metriklere göre karar vermek daha doğru bir yaklaşımdır.</p><p>Bu nedenle:</p><p><strong><em>Virtual Thread sayısı ≠ Carrier Thread sayısı ≠ Scheduler parallelism değeri</em></strong></p><p>Scheduler bazı blocking operasyonlarında carrier thread’in bloke olması durumunda, hedef parallelism seviyesini koruyabilmek için geçici olarak ek carrier thread’ler oluşturabilir. Bu davranış scheduler’ın <strong>compensation</strong> mekanizmasının bir parçasıdır. Burada üç farklı blocking davranışını birbirinden ayırmak gerekir:</p><p><strong>Virtual Thread’in unmount edilebildiği blocking:</strong> Virtual Thread carrier’dan ayrılır ve carrier başka bir Virtual Thread’i çalıştırabilir. Bu durumda compensation gerekmez.</p><p><strong>Carrier’ın bloke olduğu bazı JDK operasyonları:</strong> Virtual Thread unmount edilemediğinde carrier da bloke olabilir. Scheduler, desteklenen bazı blocking durumlarında target parallelism’i korumak amacıyla geçici olarak ek carrier thread oluşturabilir. Buna <strong>compensation</strong> diyebiliriz.</p><p><strong>Pinning:</strong> Virtual Thread carrier’a pinned durumda blocking yaparsa carrier da bloke olur. Ancak Java 21&#39;de scheduler pinning nedeniyle kaybedilen carrier’ı telafi etmek için parallelism’i artırmaz.</p><p><strong>Parallelism ve MaxPoolSize Aynı Şey mi?</strong></p><p>Parallelism, scheduler’ın hedeflediği çalışma paralelliğini ifade eder. MaxPoolSize ise scheduler’ın belirli blocking durumlarında compensation amacıyla oluşturabileceği carrier thread’ler için pool’un ulaşabileceği üst sınırı belirler.</p><p><strong>-Djdk.virtualThreadScheduler.maxPoolSize </strong>parametresi de vardır. Ve Java 21 için default’un 256 değeridir.</p><p>parallelism = hedef paralellik</p><p>maxPoolSize = pool’un büyüyebileceği üst sınır</p><p>Bu nedenle parallelism=16 olması, scheduler’ın yaşamı boyunca carrier thread sayısının hiçbir zaman 16&#39;nın üzerine çıkamayacağı anlamına gelmez. Compensation gereken durumlarda pool size geçici olarak target parallelism değerinin üzerine çıkabilir.</p><p><strong>10.000 Virtual Thread, 16 Carrier Thread: Hangisi Çalışacak?</strong></p><p>Şu ana kadar scheduler’ın target parallelism değerinin nasıl belirlendiğini anlattık. Ancak burada başka bir soru ortaya çıkıyor:</p><p><strong>10.000 Virtual Thread çalışmaya hazırsa ve scheduler’ın target parallelism değeri 16 ise, hangi Virtual Thread hangi carrier thread üzerinde çalışacak?</strong></p><p>Virtual Thread scheduler, JDK implementasyonunda ForkJoinPool tabanlı özel bir scheduler kullanır. Ancak bu pool, CompletableFuture veya parallelStream() gibi yapılarda karşımıza çıkan ForkJoinPool.commonPool() değildir. Virtual Thread&#39;lerin scheduling işlemi için JVM tarafından ayrı olarak yönetilir.</p><p>ForkJoinPool’un önemli özelliklerinden biri <strong>work-stealing</strong> mekanizmasıdır. Worker thread’ler çalıştırılmayı bekleyen işleri queue’lardan alır. Bir worker’ın yapacak işi kalmadığında, başka bir worker’ın queue’sundaki işleri alarak çalıştırabilir. Böylece bazı carrier thread’ler boşta beklerken diğerlerinin queue’larında çok sayıda iş birikmesinin önüne geçilmeye çalışılır. ForkJoinPool dokümantasyonu da worker’ların diğer worker’lardan görev almasını work-stealing olarak tanımlar.</p><p>Basitleştirilmiş olarak şöyle düşünebiliriz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*Hq0m23Rfj6FziNgQW7tOQw.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Örneğin Carrier-1 kendi çalışabileceği işleri tüketti ancak Carrier-2 tarafında çalıştırılmayı bekleyen işler varsa, scheduler’ın work-stealing mekanizması sayesinde boşta kalan worker başka bir queue’dan iş alabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*XIdKogneDmXttkKCJBhBUA.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Carrier-1 bir işi steal ederek çalıştırabilir. Buradaki amaç bütün carrier thread’leri mümkün olduğunca verimli kullanmaktır.</p><p>Dolayısıyla <strong>10.000 Virtual Thread için 10.000 carrier thread gerekmez.</strong> Runnable durumdaki Virtual Thread’ler scheduler tarafından mevcut carrier thread’ler üzerinde çalıştırılır. Work-stealing pool’larda gerçek worker sayısı da target parallelism ile birebir sabit olmak zorunda değildir.</p><p><strong>Mount, Unmount ve Park: Carrier Nasıl Başka Bir Virtual Thread’e Geçiyor?</strong></p><p>Work-stealing bize <strong>hangi runnable işin çalıştırılabileceğini</strong> anlatıyor. Ancak Virtual Thread’lerin asıl ölçeklenebilirlik avantajını anlamak için başka bir mekanizmaya bakmamız gerekir: <strong>mount/unmount.</strong></p><p>Bir Virtual Thread çalıştırılacağı zaman bir carrier thread üzerine <strong>mount</strong> edilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/532/1*q4F6wh5-3LGc-V7iI6bVTQ.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Bu sırada Java kodunu çalıştıran thread mantıksal olarak hala VT1&#39;dir. Örneğin kod içerisinden:</p><p><em>Thread.currentThread()</em></p><p>çağrıldığında carrier değil, Virtual Thread elde edilir. Virtual Thread üzerinde çalışan kod underlying carrier thread’i doğrudan görmez.</p><p>Şimdi VT1&#39;in bir network çağrısı yaptığını düşünelim:</p><p><em>String response = httpClient.send(…);</em></p><p><em>httpClient.send(…) </em>response gelene kadar çağrıyı yapan Virtual Thread&#39;i bekletir. Bu bekleme sırasında JVM, VT1&#39;i carrier thread&#39;den unmount edebilir. Böylece carrier thread bloke olmak yerine başka bir runnable Virtual Thread&#39;i çalıştırmak için kullanılabilir.</p><p>Network işlemi tamamlandığında VT1 tekrar runnable hale gelir ve scheduler tarafından yeniden çalıştırılabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*LnNzZRMa5ZDB-jGGWJ4i5Q.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Buradaki kritik nokta:</p><p><strong>VT1&#39;in tekrar aynı carrier thread’e mount edilmesi gerekmez.</strong></p><p>Virtual Thread’in kimliği carrier’dan bağımsızdır. Bu nedenle Virtual Thread’ler özellikle çok fazla <strong>I/O beklemesi bulunan</strong> uygulamalarda ölçeklenebilir. Carrier’ın işi I/O sonucunu beklemek değil, o sırada çalışabilecek başka Virtual Thread’lere CPU zamanı sağlamaktır.</p><p><strong>Peki Virtual Thread Carrier’dan Ayrılamazsa?</strong></p><p><strong>Her blocking işlemde Virtual Thread carrier’dan unmount edilebilir mi?</strong></p><p>Cevap: <strong>Hayır.</strong></p><p>Bazı durumlarda Virtual Thread blocking durumuna geçmesine rağmen carrier thread’den ayrılamaz. Buna <strong>pinning</strong> denir.</p><p>Pinning önemli çünkü Virtual Thread’in temel avantajlarından birini azaltır: <strong>beklerken carrier’ı serbest bırakabilmek.</strong></p><p><strong>Java 21&#39;de Pinning</strong></p><p>Java 21 döneminde önemli pinning durumlarından biri Virtual Thread’in synchronized bir bölge içerisinde blocking operation gerçekleştirmesiydi.</p><pre>synchronized (lock) {<br>    callRemoteService();<br>}</pre><p>callRemoteService() blocking bir çağrıysa Virtual Thread’in carrier üzerinde pinned kalması mümkün olabiliyordu. Böyle bir durumda:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/372/1*Wq32Fnk0wjWaoDxjIWxaOQ.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Ve burada önceki maxPoolSize bölümümüzle çok önemli bir ayrım yapmalıyız:</p><p><strong>Java 21 scheduler, pinning nedeniyle bloke olan carrier thread’leri telafi etmek için otomatik olarak yeni carrier oluşturmaz.</strong></p><p>Bu yüzden Java 21 uygulamalarında uzun süren blocking işlemleri synchronized içerisinde yapmak Virtual Thread scalability’sini olumsuz etkileyebiliyordu.</p><p><strong>Java 24 ile Ne Değişti?</strong></p><p>Bu konu JDK 24 ile önemli ölçüde değişti. <strong>JEP 491 — Synchronize Virtual Threads without Pinning</strong> ile synchronized monitor’lara bağlı pinning problemi giderildi. JEP’in amacı Virtual Thread’lerin synchronized kullanırken carrier thread’e pinlenmeden blocking/yield edebilmesini sağlamaktı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*wzOVr3gGx4l-JXVcErLQuQ.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><p>Ancak bu:</p><p><strong>“Java 24 ile pinning tamamen ortadan kalktı.”</strong></p><p>anlamına gelmiyor.</p><p>Native/foreign code gibi Virtual Thread’in carrier’dan ayrılamadığı başka durumlar hala olabilir.</p><p><strong>Peki Virtual Thread hiç beklemiyorsa ne olur?</strong></p><p>Şimdiye kadar Virtual Thread’in I/O sırasında carrier thread’i serbest bırakabildiğini gördük. Ancak CPU-bound bir işte Virtual Thread uzun süre boyunca hesaplama yapıyorsa ortada carrier’ı serbest bırakacak bir bekleme noktası bulunmayabilir. Bu durumda ölçeklenebilirliği belirleyen faktör artık Virtual Thread sayısı değil, CPU kapasitesidir.</p><p><strong>CPU-bound vs I/O-bound: Tasarıma etkisi</strong></p><p>JVM’in 8 kullanılabilir işlemci gördüğünü düşünelim. 10.000 Virtual Thread oluşturmak, 10.000 CPU-bound işin gerçekten paralel çalışabileceği anlamına gelmez. CPU üzerinde aynı anda yürütülebilecek iş miktarı hala işlemci kapasitesiyle sınırlıdır. Çok sayıdaki runnable görev scheduler ve işletim sistemi tarafından CPU zamanı almak için yarışacaktır.</p><p>Bu yüzden CPU-heavy işlerde öneri şudur:</p><p><em>ExecutorService</em><strong><em> executor =</em></strong></p><p><em>Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());</em></p><p>Yani CPU-bound işler için <strong>bounded/fixed thread pool</strong> daha mantıklıdır. Ama bu illa “platform thread şart” demek değil; önemli olan <strong>sınırsız concurrency vermemek</strong>. Bunun için bounded executor, semaphore veya workload’a uygun başka bir concurrency-limiting mekanizması kullanılabilir.</p><p>Spring Boot tarafında request başına virtual thread kullanıyorsan, endpoint içinde CPU-heavy iş varsa sistem boğulabilir. Çünkü çok fazla request aynı anda CPU tüketmeye çalışır.<br> Bu durumda en iyi yaklaşım:</p><ul><li>I/O kısmı virtual thread ile olabilir</li><li>CPU-heavy kısmı ise bounded executor’a aktarılabilir</li></ul><p><strong>Virtual thread = bekleyen işleri ucuzlatır.<br>CPU-heavy iş = bekleme azdır, CPU limiti vardır. Bu yüzden concurrency sınırlandırılmalıdır.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*85yiC8gwVd5GhuBPtL0AHA.jpeg" /><figcaption>AI ile üretilmiştir.</figcaption></figure><h4><strong>Virtual Thread’leri Nasıl Gözlemleyebiliriz?</strong></h4><p>Virtual Thread’lerin çalışma mantığını anlamak kadar, production ortamında nasıl davrandıklarını gözlemleyebilmek de önemlidir. Özellikle çok sayıda Virtual Thread kullanılan uygulamalarda klasik thread dump yaklaşımı tek başına yeterli olmayabilir.</p><p>Virtual Thread’leri gözlemlemek için JDK tarafında <strong>thread dump, Java Flight Recorder (JFR) ve scheduler metrikleri</strong> kullanılabilir.</p><p><strong>Thread Dump</strong></p><p>Virtual Thread’ler için thread dump almak amacıyla jcmd kullanılabilir:</p><p>jcmd &lt;PID&gt; Thread.dump_to_file -format=json threads.json</p><p>JSON formatı özellikle çok sayıda Virtual Thread bulunduğunda kullanışlıdır. Dump üzerinden hangi Virtual Thread’lerin çalıştığını ve thread hiyerarşisini inceleyebiliriz.</p><p>Burada önemli bir nokta var: Virtual Thread’lerin sayısı çok yüksek olabileceği için klasik thread dump’larda binlerce thread’i tek tek incelemek pratik değildir. Amaç genellikle tek tek thread’lerden ziyade <strong>çok sayıda thread’in aynı noktada bekleyip beklemediğini</strong> veya belirli bir operasyonun darboğaz oluşturup oluşturmadığını anlamaktır.</p><p><strong>Java Flight Recorder (JFR)</strong></p><p>Scheduler davranışını ve Virtual Thread kaynaklı problemleri incelemek için daha güçlü araçlardan biri <strong>Java Flight Recorder</strong>’dır.</p><p>Java 21 ile Virtual Thread’lere özel bazı JFR event’leri bulunur. Özellikle:</p><p>jdk.VirtualThreadStart</p><p>jdk.VirtualThreadEnd</p><p>jdk.VirtualThreadPinned</p><p>jdk.VirtualThreadSubmitFailed</p><p>Event’leri Virtual Thread davranışını analiz etmek için kullanılabilir.</p><p>Özellikle Java 21 açısından; <strong>jdk.VirtualThreadPinned </strong>event’i önemlidir. Bir Virtual Thread carrier thread’e pinned durumda blocking yaptığında bunun tespit edilmesine yardımcı olabilir.</p><p>Örneğin JFR kaydı:</p><p>jcmd &lt;PID&gt; JFR.start name=virtual-threads settings=profile</p><p>ile başlatılıp daha sonra:</p><p>jcmd &lt;PID&gt; JFR.dump name=virtual-threads filename=virtual-threads.jfr</p><p>ile alınabilir.</p><p>Oluşan .jfr dosyası <strong>JDK Mission Control (JMC)</strong> ile analiz edilebilir.</p><p>Böylece sadece:</p><p>“Uygulamada Virtual Thread kullanıyorum.”</p><p>demek yerine;</p><p>“Virtual Thread’ler nerede bekliyor, pinning oluşuyor mu ve hangi kod noktaları problem yaratıyor?”</p><p>sorularına cevap arayabiliriz.</p><p><strong>Scheduler’ı Doğrudan İzlemek</strong></p><p>JDK’nin daha yeni sürümlerinde VirtualThreadSchedulerMXBean üzerinden scheduler’ın kendisi de gözlemlenebilir.</p><p>Örneğin aşağıdaki metrikler elde edilebilir:</p><p><strong>Parallelism</strong>: scheduler’ın target parallelism değeri</p><p><strong>Pool Size:</strong> scheduler’ın oluşturduğu mevcut carrier/platform thread sayısı</p><p><strong>Mounted Virtual Thread Count:</strong> o anda carrier üzerinde çalışan/mount edilmiş VT sayısı</p><p><strong>Queued Virtual Thread Count: </strong>çalışmayı bekleyen VT sayısı</p><p>Virtual Thread kullanılan bir uygulamada yalnızca toplam thread sayısına bakmak yeterli değildir. Scheduler’ın target parallelism değeri, carrier thread’lerin durumu, runnable veya queued Virtual Thread sayısı ve blocking/pinning noktaları birlikte değerlendirilmelidir. Özellikle production ortamında scheduler ayarlarını değiştirmeden önce JFR ve ilgili JVM metrikleriyle gerçek darboğazın nerede olduğunu gözlemlemek daha doğru bir yaklaşımdır.</p><p>Bu yazıdan çıkarılması gereken en önemli sonuç şudur:</p><ul><li>Virtual Thread sayısı ile Carrier Thread sayısı aynı şey değildir.</li><li>Daha fazla Virtual Thread oluşturmak daha fazla CPU çekirdeği oluşturmaz.</li><li>Virtual Thread scheduler’ın varsayılan target parallelism değeri availableProcessors() değerine dayanır.</li><li>CPU-bound işlerde Virtual Thread tek başına performans mucizesi yaratmaz.</li><li>Virtual Thread’in asıl gücü, çok sayıda bekleyen (I/O-bound) işi düşük maliyetle yönetebilmesidir.</li></ul><p>Virtual Thread ile ilgili diğer yazılara burdan ulaşabilirsiniz.</p><p>Virtual Thread Giriş yazısına <a href="https://medium.com/softtechas/java-virtual-threads-milyonlarca-thread-nas%C4%B1l-m%C3%BCmk%C3%BCn-oldu-dc7c49fd16fa">buradan</a> ulaşabilirsiniz.</p><p>Java Virtual Threads: Concurrency’yi Yeniden Düşünmek yazısına <a href="https://medium.com/softtechas/java-virtual-threads-concurrencyyi-yeniden-d%C3%BC%C5%9F%C3%BCnmek-507d628d2b00">buradan</a> ulaşabilirsiniz.</p><p>Başka yazılarda görüşmek üzere.</p><p>@VirtaualThread @Thread @Java @CarrierThread @Concurrency</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7db9d40c2d64" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/java-virtual-threads-carrier-thread-ve-scheduler-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-7db9d40c2d64">Java Virtual Threads: Carrier Thread ve Scheduler Nasıl Çalışır?</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sigortacılıkta İnovatif Dönüşüm]]></title>
            <link>https://medium.com/softtechas/sigortac%C4%B1l%C4%B1kta-i%CC%87novatif-d%C3%B6n%C3%BC%C5%9F%C3%BCm-5964fda6734f?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/5964fda6734f</guid>
            <dc:creator><![CDATA[Softtech]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 13:25:10 GMT</pubDate>
            <atom:updated>2026-08-12T13:25:10.810Z</atom:updated>
            <content:encoded><![CDATA[<p>Anadolu Sigorta Genel Müdürü Z. Mehmet Tuğtan tarafından Softtech 2026 Teknoloji Raporu için kaleme alınmıştır.</p><p>Teknolojik trendler ve tüketici beklentilerine kusursuz bir müşteri deneyimi ile yanıt verme ihtiyacı, tüm sektörlerin olduğu gibi sigortacılık sektörünün de dijital dönüşümüne yön veriyor. Sigortacılık, konvansiyonel bir alan ve finansal bir endüstri olarak bilinirdi. Artık bugün için bunu söylemek pek mümkün değil.</p><p>Yeni dönemde bir sigorta şirketinin başarısı, sadece poliçe üretimi veya teknik kârlılıkla değil, dijital dönüşüme uyum yeteneği ve teknolojiyi müşterinin yaşamına nasıl entegre ettiği ile ölçülüyor. Sigortacılık sektöründeki dönüşümün merkezinde, müşteri deneyimini yeniden tanımlama ve veri temelli karar alma yer alıyor.</p><p><strong>DİJİTALLEŞME VE MÜŞTERİ ODAKLI YENİ NESİL HİZMETLER</strong></p><p>Sektörde dijital dönüşüm ve teknolojik trendler açısından ana akımlar sigortalı beklentileri ekseninde şekilleniyor. İhtiyaca en uygun sigorta ürününü ve teminat yapısını hızla belirlemek için yalın bilgiye pratik ve şeffaf erişim sağlayan çok kanallı yapılanmalar, risk analizi bazlı dinamik fiyatlandırma modelleri ve ürün/hizmet kişiselleştirme teknolojileri öne çıkıyor. Son yıllarda giderek yaygınlaşan, sigortacılıkta risk koruma yaklaşımından risk önleme yaklaşımına geçişin anahtarını ise mobilite, telematik ve nesnelerin interneti (IoT) teknolojileri ile birlikte büyük veriye dayalı modeller oluşturuyor. Sigorta ürün ve hizmetlerini doğru zamanda müşteriyle buluşturma aşamasında gömülü sigortacılık ve bağlamsal pazarlama yetkinliklerini güçlendirmenin önemini görüyoruz. Satış sonrası hizmetlerde ve hasar operasyonlarında hızlı refleks verebilme, ekosistem temelli iş birliklerine dayalı dijital platformlar ve self-servis yapıların yaygınlaşmasıyla mümkün oluyor. Sigortacılıkta penetrasyonun artırılmasını sağlayacak maliyet düşürücü alternatifler, mikro sigorta çözümlerinin yanı sıra modüler/parametrik sigortacılık alanındaki yenilikçi iş modelleriyle şekilleniyor.</p><p>Trendlerdeki ana akımların tamamına hizmet edebilecek şekilde ve merkezde konumlanan teknolojinin ise yapay zekâ olduğunu görüyoruz. Yapay zekâ, otomasyon ve büyük veri temelli yaklaşımlar artık sigorta sektörünün “geleceği” değil, “bugünü”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J-qqXB-xdp_YJExuOf5sSw.png" /></figure><p>Belirtilen modeller sayesinde fiyatlama, teklif yönetimi, risk analizi ve kişiselleştirilmiş poliçe oluşturma adımlarına yönelik yüksek doğrulukla çalışan teknolojik çözümler geliştiriyoruz. Bu sayede, sigortalılarımıza en uygun ürünleri önererek varlıklarını en doğru şekilde güvence altına almayı sağlıyoruz. Yapay zekâ bizler için verimlilik, hız, güven ve müşteri memnuniyetini aynı anda artıran stratejik bir kaldıraç.</p><p>Diğer taraftan, bu teknolojilerden en yüksek verimi elde etmek ancak şirket stratejileri ile bütüncül bir şekilde ele alınmaları ve değişim yönetimi odağıyla iş gücünün bu dönüşüme uyumunun sağlanmasıyla mümkün. McKinsey&amp;Company’nin araştırmalarına göre, son 5 yılda yapay zekâ teknolojileri yatırımlarında öne çıkan şirketler, rakiplerine göre 6,1 kat daha fazla hisse getirisi sağlıyor.</p><p><strong>YAPAY ZEKÂ: SİGORTACILIĞIN STRATEJİK KALDIRACI</strong></p><p>Yapay zekâ teknolojilerinin temel sigortacılık iş modelleri açısından kullanımında, dinamik fiyatlama modelleriyle kişiselleştirilmiş teklifler oluşturma ve müşteri deneyimini kişiselleştirme öne çıkıyor. Müşteri için risk faktörlerini analiz eden bu modeller en uygun sigorta primini otomatik belirliyor. Ayrıca, büyük veri modeli tabanlı sanal asistanlar müşterilerimizin anlık bilgi ve çözüm taleplerine 7/24 yanıt vermemizi sağlıyor. Poliçe oluşturma, hasar yönetimi, sağlık tazminat ve acente desteği gibi sigortacılığın uzmanlık gerektiren alanlarında, farklı teknolojiler ve bilgi mimarileri ile çalışan sanal asistanların orkestrasyonu, Agentic Yapay Zekâ (AI) tabanlı modellerle gerçekleştiriliyor. Hasar süreçlerinin otomasyonunda yapay zekâ teknolojilerinin kullanımı, bu alanda müşteri deneyiminin iyileştirilmesine ve operasyonel verimlik artışına önemli katkılar sağlıyor.</p><p>Pandemi sonrası dönem sağlık hizmetlerinin yalnızca maliyet odaklı değil, değer odaklı bir modele yönelmesini hızlandırdı. Sağlık sigortacılığında dönüşüm, sadece teknolojik ilerlemeyi değil, etik bir sorumluluğu da temsil ediyor. Bu alanın temelini oluşturan güven ve toplumsal refah unsurları açısından merkeze, teknolojiyi insana yaklaştırmayı ve insani teması artırmayı koyuyoruz. Yapay zekâ, otomasyon ve büyük veri tabanlı teknolojilerle, “ödeyici sigortacı”dan sigortalının sağlık yolculuğunu yöneten “sağlık ortağına” dönüşmeye odaklanıyoruz. Başvuru anında devreye giren akıllı risk değerlendirme modelleri ile “hangi hastalıkta hangi kararlar alınmalı” sorusuna otomatik öneriler üretiyoruz. Gelecek tazminat yükünü tahmin ederek ürünü ve fiyatını tasarlamayı, yüksek riskli alanlarda sadece prim artırmak yerine, kapsam, limit ve katılım payı gibi araçlarla maliyeti dengeleyebilmeyi sağlıyoruz. Sağlık provizyon süreçlerinde geçmiş vaka verilerini tarayarak riskli ve istisnai durumları işaretleyebilen yapay zekâ tabanlı karar destek mekanizmaları kuruyoruz. Tüm bu çözümlerle birlikte, tıbbi süreçlerde hizmet kalitesi artarken maliyet optimizasyonu sağlanıyor.</p><p>Temel sigortacılık iş yapış biçimlerini dönüştüren yapay zekânın diğer teknolojilerle buluşması, insan sağlığına bakışımızı kökten değiştiriyor. 5G ve yapay zekâ teknolojilerinin bütünleşmesi, uzaktan fizyoterapi seanslarının gerçek zamanlı izlenmesini ve yönlendirilmesini sağlayan platformları hayata geçirmemize imkân sağlıyor. Belirtilen gelişmeler uzaktan rehabilitasyon hizmetlerinde bölgesel erişim zorluklarını kaldırarak, dijital terapi yöntemlerini ölçeklendirme ve klinik erişimi artırma açısından fırsatlar sunuyor. Dijital ikiz ve yapay zekâ teknolojilerinin birlikte kullanımıyla, giyilebilir cihazlardan sağlık verilerine erişerek kronik hastalıkların erken sinyallerini tespit etmeyi amaçlıyoruz. Bu sayede, erken tetkik ve müdahale imkânı ile insan sağlığına katkı sağlanırken, uzun dönemli, etik ve güvenli veri setleri ile tıbbi keşiflerin öncüsü olacak algoritmaların geliştirilmesi mümkün oluyor.</p><p><strong>OTONOM SİGORTACILIK MODELLERİ</strong></p><p>Gartner’ın 2025 yılında yayımladığı araştırmanın sonuçları, hayat dışı branşlarda sigortacılığın geleceğini orta/uzun vadede şekillendirecek önemli trendler arasında Agentic AI, üretken yapay zekâ, dijital ikiz, kuantum bilgi işlem, gömülü sigortacılık ve açık sigortacılık başlıklarının bulunduğunu gösteriyor. 2000’li yıllara damga vuran e-ticaret çağı ve günümüzde yükselişi devam eden dijitalleşme çağının ardından, önümüzdeki 20 yıllık dönemde sigortacılık dâhil tüm sektörlerde yeni dönüşüm çağını Agentic AI öncülüğünde, otonom model ve organizasyonların getireceği öngörülüyor. Programlanabilir ekonomi temalı bu oluşumu, mevcut iş gücünün yetkinliklerine ek olarak; tüketici adına karar alabilen, iş birimi operasyonlarını self-servis sonuçlandırabilen ve ürünleri/hizmetleri tüketici özelliğine göre anlık şekillendirebilen otonom yapıların karşılıklı diyaloğu şekillendirecektir.</p><p>2030 yılında, tüketici adına karar alabilme potansiyeline sahip 12 milyarı aşkın IoT temelli cihazı kapsayacak programlanabilir ekonominin toplam ekonomik büyüklük içerisindeki payının %22’ye ulaşması bekleniyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zckl_ELN5YSLzO5zhVCHrg.png" /></figure><p><strong>SONUÇ: POTANSİYELİ GERÇEKLEŞTİRMEK</strong></p><p>Türkiye Sigorta Birliği’nin açıklamaları çerçevesinde, ülkemizde bugün itibarıyla 22 milyar USD seviyesinde olan sigortacılık sektörü prim üretim hacminin 2030 yılında 44 milyar dolara ulaşması hedefleniyor. Bu hedef gerçekleştiğinde, %2,5 seviyesindeki sigortacılık penetrasyon oranımızın %4,8 seviyesinde olacağı ve bu alanda dünyada ilk 20 ülke arasında yer alacağımız tahmin ediliyor.</p><p>McKinsey&amp;Company 2025 Global Sigortacılık Raporu’nda ülkeler; gelişmiş pazarlar, yüksek büyüme potansiyeline sahip pazarlar ve uzun vadede büyüme fırsatı sunacak pazarlar olarak sınıflandırılıyor. Bu raporda büyüme fırsatları açısından yüksek potansiyeli vurgulanan 6 ülkeden birinin Türkiye olduğunu görüyoruz.</p><p>Sigortacılıkta gelişmiş pazarlar arasında yer almaya adayız, doğru yoldayız ve iyi bir gelecek vaat ediyoruz. Bu yolculuktaki hızımızı her geçen gün ivmelendirerek artırmanın yolunun, teknolojik gelişmelere uyum kapasitesini sürekli geliştirerek dönüşümü hızlandırma ve inovatif iş modellerinin sürekli keşfine odaklanmaktan geçtiğine inanıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nef_Z2GVUj14M7IP2Jix5Q.png" /></figure><p>Raporun tamamına ulaşmak için  <a href="https://bit.ly/3NC00rH">https://bit.ly/3NC00rH</a></p><p>Kategorilere göre yapay zekâ destekli ses teknolojisi kullanılarak Softtechliler tarafından seslendirilen içerikleri dinlemek için  <a href="https://bit.ly/4boSr1c">https://bit.ly/4boSr1c</a></p><p><strong><em>Kaynaklar</em></strong></p><p><em>McKinsey&amp;Company, “Global Insurance Report 2025: The Pursuit of Growth”, November 2024</em></p><p><em>Gartner, “Hype Cycle for Property and Casualty Insurance”, 16 June 2025</em></p><p><em>McKinsey&amp;Company, “The future of AI in the Insurance Industry”, 15 July 2025</em></p><p><em>Gartner, “What Is Autonomous Business, and Why is it Important in the Age of AI?”, September 2025</em></p><p><em>Gartner, “Autonomous Business: What’s Next After Digital Business?”, November 2025</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5964fda6734f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/sigortac%C4%B1l%C4%B1kta-i%CC%87novatif-d%C3%B6n%C3%BC%C5%9F%C3%BCm-5964fda6734f">Sigortacılıkta İnovatif Dönüşüm</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Zekânın Yeniden Tanımlandığı Eşik: 2026 ve Sonrası İçin Bir Çerçeve]]></title>
            <link>https://medium.com/softtechas/zek%C3%A2n%C4%B1n-yeniden-tan%C4%B1mland%C4%B1%C4%9F%C4%B1-e%C5%9Fik-2026-ve-sonras%C4%B1-i%CC%87%C3%A7in-bir-%C3%A7er%C3%A7eve-42c0d6e14896?source=rss----78ea619c4d2c---4</link>
            <guid isPermaLink="false">https://medium.com/p/42c0d6e14896</guid>
            <dc:creator><![CDATA[Softtech]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 13:21:02 GMT</pubDate>
            <atom:updated>2026-08-12T13:21:02.585Z</atom:updated>
            <content:encoded><![CDATA[<p>Teknolojide Kadın Derneği Kurucu ve Yönetim Kurulu Başkanı Zehra Öney tarafından Softtech 2026 Teknoloji Raporu için kaleme alınmıştır.</p><p>İnsanlık tarihinde bazı dönemler vardır ki, yalnızca teknolojiler değişmez, düşünme biçimi değişir.</p><p>2026 ve sonrası tam olarak böyle bir eşiğe işaret ediyor. Bugün karşı karşıya olduğumuz dönüşüm, çoğu zaman “yapay zekâ” başlığı altında tartışılsa da asıl mesele teknolojiden çok daha derindedir. Mesele; zekânın ne olduğu, nasıl üretildiği ve kiminle birlikte çalıştığıdır. Uzun yıllar boyunca zekâ, bireysel bir kapasite olarak ele alındı. İnsan zihninin biyolojik sınırları, hafızası, muhakeme gücü ve sezgisi üzerinden tanımlandı. Ancak gelinen noktada bu tanım yetersizdir. Çünkü artık zekâ, tekil bir varlığa ait değildir. Zekâ, birlikte çalışan sistemlerin toplamıdır. İnsan sezgisi, veri altyapıları, hesaplama gücü, otonom ajanlar ve kolektif iletişim ağları; tek başına değil, birlikte anlamlıdır. 2026 ve sonrasında zekâ, bireysel kapasiteden ziyade, iş birliği kapasitesi üzerinden ölçülecektir.</p><p><strong>HİBRİT ZEKÂ ÇAĞI</strong></p><p>Bu dönüşüm, komut bekleyen basit sistemlerden amaç belirleyebilen ve insanla birlikte çözüm üreten bir zekâ düzeyine geçişi ifade etmektedir. Agentic Yapay Zekâ’nın (AI) sunduğu bu yeni modelde, sistemler yalnızca veri işleyen araçlar değil, inisiyatif alabilen karar ortaklarıdır. Bu değişimi anlamak için sadece teknolojilere odaklanmak yerine, teknolojinin dönüştürdüğü yaşam katmanlarına bakmak kritik öneme sahiptir: İş yaşamı, yapay yaşam, fiziksel yaşam ve dijital yaşam. Bu dört alan; veri, hesaplama ve karar mekanizmalarıyla bütünleşerek tek ve uyumlu bir ekosistem oluşturuyor. Bu yeni dönemin temelini atan Agentic AI, zekâyı insanın biyolojik kapasitesinin ötesine taşıyarak, insan yapay zekâ ağları ve otonom sistemlerin birleşik gücü olarak tanımlanan bir sistemin çekirdeğini oluşturmaktadır. Bu, hibrit bir zekânın doğuşudur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gvxo4TzOmgXeryJJOa9txg.png" /></figure><p>Bu hibrit zekâ çağının felsefi bir zemine oturtulması, teknolojik yetkinlik ile birlikte etik ilkelere ve yöntemsel açıklığa dayalı bir yaklaşımı zorunlu kılar. René Descartes’in felsefe ile matematiği birleştirme girişimi, bilgiyi kesin bir matematiksel düzene oturtma ve analitik geometriyi kurma çabası, günümüzün karar alma sistemlerine ve veri bilimine temel oluşturmuştur. Bugün, düşünceyi matematiksel bir düzene oturtma arayışı, düşüncenin algoritması kavramını öne çıkarır: Düşünce, doğru bir algoritmayla düzenlenmedikçe doğrusunu hiç üretmez. Günümüz karar alma, etik sorgulama ve problem çözme süreçleri, bir bilgi akışından çok, algoritmik bir akışa dönüşmektedir. Zihinsel netlik, doğru algoritma tasarımıyla; zihinsel kaos ise yanlış kural setiyle modellenebilir. Agentic AI, insan aklının sezgisel gücünü, algoritmik netlikle birleştirerek bu yeni zihinsel netlik arayışının teknolojik karşılığı haline gelmiştir.</p><p><strong>ZEKÂNIN ALTYAPISI: KARAR ORTAĞI İNSAN MODELİ</strong></p><p>Fiziksel altyapının küresel çapta yeniden inşa edilmesi, bu derinlikli dönüşümün ilk adımı için zemin hazırlamaktadır. Dünya, yapay zekâ uygulamalarını geliştirmeden önce, bu uygulamaları mümkün kılacak devasa hesaplama altyapısını inşa etme yarışındadır. JPMorgan’ın öngörülerine göre, önümüzdeki beş yılda, veri merkezleri, hızlandırıcı çipler ve enerji altyapısına trilyonlarca dolar yatırım yapılacaktır. Bu yatırım, jeopolitik bir güç kaymasına işaret eden, yeni bir ekonomik ve stratejik savaşın altyapı adımıdır. Geleneksel CPU merkezli mimarinin yerini, GPU tabanlı hızlandırılmış hesaplama almıştır. Bu, büyük modellerin temel mimarisidir ve yazılım ve donanımın birlikte evrildiği bir ekosistem yaratmaktadır. Hızlandırılmış bilgi işlem (accelerated computing) yeni endüstri standardı haline gelmiştir. Sanayi çağının petrol rafinerileri bugün “AI fabrikaları”na dönüşmektedir. Bu merkezler, yalnızca veri depolama işlevi görmüyor; hammadde (veri) kullanarak çıktı (zekâ, model) üreten, yüksek enerji gerektiren üretim tesisleri olarak yeniden konumlanıyor. Devasa ölçekte açıklanan yatırımlar, enerji güvenliği, veri egemenliği ve ulusal stratejilerin bu yeni AI altyapısının merkezinde yer aldığını kanıtlamaktadır. Bu altyapının kurulum hızı, bir ülkenin gelecekteki ekonomik ve askeri rekabet gücünü doğrudan belirleyecektir. Bu yeni altyapı üzerinde iş yaşamı, insan operatör modelinden, karar ortağı modeline hızla geçiş yapmaktadır. Agentic AI, rutin görevleri otomatize edilmiş, özerk iş akışlarına devrederken, insan rolü, çıktının bağlamını ve etik sınırlarını belirleyen stratejik dengeleyici haline gelmektedir. İş gücünde temel gereklilik, teknolojiyle çalışabilme, veriyi bağlam içinde yorumlayabilme ve karar süreçlerinin insani boyutunu anlayabilme becerileri etrafında şekillenmektedir. Robotik süreçler ne kadar gelişirse gelişsin, “neden” sorusunun cevabını, stratejik yönü belirleme ve kriz anlarında etik liderlik yetisi, insanda kalmaktadır.</p><p>Bu yeni dönemde, bilişsel esneklik ve sistem düşüncesi temel kariyer yetkinlikleri haline gelmiştir. Global yetkinlik raporları da bu değişimi stratejik bir gereklilik olarak desteklemektedir. Teknolojiyi herkes satın alabilir ancak farkı yaratan, yapay zekânın ürettiği analize güvenen, deneme–yanılmayı kültürel olarak teşvik eden ve etik sınırları net olan çevik kurum kültürüdür.</p><p>Agentic sistemler büyük ölçüde geçmiş verilere dayandığı için, çeşitliliğin düşük olduğu ekiplerde hata ve önyargı riski katlanarak artar. Bu durum, sosyal gerekliliklerin ötesinde, sistemin teknik bir gerekliliği olarak kabul edilmelidir. Türkiye’de bu dönüşüm, güçlü dijital altyapı sayesinde hızla pratik uygulamaya dökülmektedir. Örneğin, yerel bankacılık ve telekom sektörlerinde, müşteri hizmetleri süreçlerini optimize eden ve kredi kararlarını bağlamsal olarak destekleyen Agentic sistem pilot uygulamalarına başlanmıştır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uPQKuVfAG5emPdXTAUzEoQ.png" /></figure><p><strong>İŞİN YENİ DOĞASI: DİNAMİK VE ÖZERK SİSTEMLER</strong></p><p>Yapay yaşam alanı doğrudan fiziksel robotik sistemleri değil, dijital ikizler, simülasyonlar, bilimsel araştırmalar ve yaratıcı üretim modellerini kapsayan, gerçekliğin sınırlarını zorlayan bir alandır. Enerji şebekeleri, karmaşık kent planlaması, iklim senaryoları ve tedarik zinciri gibi kritik alanlarda senaryolar, önce dijital ikizler üzerinde yüksek hızda test edilip ardından optimize edilmiş haliyle gerçek hayata uygulanmaktadır. Bu yöntem, maliyet ve riskleri azaltırken, sistemlerin daha dayanıklı (resilient) olmasını ve beklenmedik durumlarla başa çıkabilmesini sağlamaktadır.</p><p>Bilimsel alanda, kimya, biyoloji, materyal bilimi ve sağlık alanlarında AI destekli simülasyonlar, yeni ilaç ve materyal keşif süreçlerini onlarca kat hızlandırmaktadır. Büyük laboratuvarlar, “AI-first bilim” stratejisini temel bilimlerin ve Ar-Ge’nin merkezine yerleştirmiştir. Yapay zekâ, hipotez üretme, deney tasarlama ve veri analizi süreçlerini otonomlaştırarak insan bilimciyi daha yaratıcı ve bağlamsal düşünme rolüne yükseltmektedir. Yaratıcı üretimde ise, metin, görsel, video ve müzik üretimi yapay zekâ ile ortak ilerlerken, insan burada bir teknisyen olmaktan ziyade, yaratıcılığı yöneten “orkestra şefi” rolünden değer kazanmaktadır. Yapay zekâ teknik üretimi ve varyasyonları sağlarken, asıl farkı yaratan, teknik üretimden çok, kültürel bağlamı taşıyan, anlam kuran ve sanatsal yönü derinleştiren insanlardır.</p><p>Fiziksel yaşamın geleceği, yalnızca sensörlerle izlenen pasif sistemler yerine, sensör + veri + özerk karar ile yönetilen dinamik ve aktif bir modele dayanmaktadır. Akıllı şehirler, trafik akışı, enerji tüketimi, su yönetimi ve atık döngüsü gibi kritik parametreler, Agentic AI tarafından anlık olarak okunup optimize edilen yaşayan organizmalara dönüşmektedir. Şehir yönetimi, bütüncül senaryolar ve merkezi karar ajanları aracılığıyla entegre bir yapı içinde yürütülmektedir. Enerji yönetiminde, yenilenebilir enerjinin dalgalı ve öngörülmesi zor doğası, yapay zekâ destekli tahmin sistemleri ve otonom şebeke yönetim mekanizmaları sayesinde güvenilir şekilde kontrol edilmekte; bu da enerji kayıplarını en aza indirirken, karbon ayak izini ciddi oranda düşürebilmektedir. Üretim ve lojistikte ise, robotlar ve insanlar artık Agentic sistemlerin yönettiği ortak bir düzende, sıfır hata hedefine doğru çalışmaktadır. Üretim bandındaki sistem, arızayı oluşmadan saatler önce öngörebilmekte, tedarik zinciri ise değişen pazar koşullarına anlık adapte olabilmektedir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JSGQv9lM9KTX1VRbJJV3Cg.png" /></figure><p><strong>GÜVEN KATMANI İNŞA ETMEK</strong></p><p>Son olarak, dijital yaşamdaki dönüşüm, yeni uygulamaların ötesine geçerek kimlik, mahremiyet, temsil ve algoritmik adalet gibi temel soruları derinlemesine gündeme getirmektedir. Sağlık verilerimiz, sosyal ilişkilerimiz ve davranış örüntülerimiz bir araya geldiğinde, dijital kimliğimiz fiziksel kimliğimiz kadar gerçek ve hassas bir yapıya dönüşmektedir. Bu kimliğin korunması ve temsili, en önemli güvenlik başlıklarından biri olacaktır.</p><p>Bu bağlamda, yapay zekânın ürettiği büyük veri ve otomatize kararların ötesinde, anlamlandırma süreci, en kritik unsurlardan biri haline gelmektedir. Veriyi sadece işlemek değil, onun kültürel ve etik bağlamını oluşturmak zorunludur. Bu yeni dijital gerçeklik, geleneksel merkezi otoritelere olan güveni sorgularken, Web3 felsefesiyle uyumlu, merkeziyetsiz ve şeffaf bir güven katmanının inşasını da zorunlu kılmaktadır. Blokzincir tabanlı sistemler, kişisel ajanların aldığı kararların izlenebilirliğini ve dijital kimliğin mutlak kontrolünü sağlamak için kritik bir rol oynayacaktır. Yakın gelecekte bireyleri temsil eden kişisel yapay zekâ ajanları; e-posta yazacak, karmaşık planlama yapacak, bizim adımıza fiyat pazarlığı yapacak ve karar destek süreçlerine özerk olarak katılacaktır.</p><p>Bu durum, temsil hakkı ve ajanın sorumluluğu gibi yeni hukuki ve etik sorunları beraberinde getirecektir. Kredi skoru, işe alım, sağlık tanısı ve hukuki süreçler gibi alanlarda yapay zekâ kararlarının şeffaflığı ve doğruluğu temel bir soru haline gelmektedir. Bu nedenle, sistemlerin neden böyle karar verdiğini açıklayabilen açıklanabilir yapay zekâ (XAI) mekanizmalarının ve adalet mekanizmalarının güçlendirilmesi şarttır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xlDuOd5xN29eHVbnp1X2xQ.png" /></figure><p><strong>DİJİTAL DÖNÜŞÜM LABORATUVARI OLMAK</strong></p><p>Küresel ölçekte büyük güçler, AI altyapısına gigawatt ölçeğinde ve yüz milyarlarca dolarlık yatırımlar yaparken, Türkiye bu resimde, ölçek olarak aynı ligde yer almasa d hız, adaptasyon yeteneği, genç nüfus ve güçlü finans–telekom–kamu dijital altyapısı ile önemli bir konumda durmaktadır. Türkiye’nin güçlü e-devlet uygulamaları, bölgesel ticaret ağları ve büyüyen girişimcilik ekosistemi sayesinde, Agentic AI çağında hızlı uygulama ve kullanım senaryoları geliştirebilecek bir laboratuvar niteliği taşıdığı açıktır. Asıl fırsat; dev veri merkezleriyle rekabet etmekten çok, insan kaynağı, kurum kültürü ve toplumsal ihtiyaçları merkeze alan çözümlerle bölgesel bir “sorumlu ve insan odaklı dijital dönüşüm” üssü olmaktır.</p><p><strong>Sonuç: Bir Yaşam Tasarımı Olarak Agentic AI</strong></p><p>Agentic Yapay Zekâ Çağı bir teknoloji olmaktan öte, bir Yaşam Tasarımıdır. Yaşamın dört katmanını birbirine bağlayan bütüncül bir yapı kurulurken, merkezin hâlâ insan olduğu unutulmamalıdır. Yapay zekâ karar verebilir fakat kararların değerini, bağlamını, etik sınırını ve stratejik yönünü belirleyen yine insandır.</p><p>Bu büyük dönüşümün nihai aşaması, transhümanizm ve robotsal yaklaşım kavramlarıyla şekillenmektedir. Agentic AI, insan ve makine arasındaki fiziksel ve bilişsel sınırları muğlaklaştırarak, “uyum” (alignment) kavramını merkeze taşımaktadır. Uyum, gelecekteki toplumsal refah ve istihdam için kritik bir beceri haline gelecektir. Bu nedenle, ulusal düzeyde eğitim ve yeniden beceri kazandırma programlarına (reskilling) yatırım yapmak, bu yeni çağda hiçbir kesimin geride kalmamasını sağlamanın temel yolu olacaktır.</p><p>Burada asıl soru “Yapay zekâ ne yapabilir?” değil, “Biz nasıl bir gelecek tasarlıyoruz?” olmalıdır. Doğru değerlerle birleşen teknoloji, daha verimli, adil ve sürdürülebilir bir yaşamın temelini oluşturabilir. 2026 ise bu dönüşümde yeni bir hızlanma ve derinleşme evresine işaret etmektedir.</p><p><strong>AKADEMİK NOT VE KISA LİTERATÜR BAĞLANTISI</strong></p><p>Agentic AI, iş ve toplum dinamiklerini dönüştürürken akademik literatürde de “insan–makine ortaklığı” etrafında yoğun bir tartışma alanı yaratmaktadır. Bu tartışmaların en kapsamlılarından biri, Brian Cantwell Smith’in The Promise of Artificial Intelligence: Reckoning and Judgment (2019) adlı çalışmasıdır.</p><p>Smith, yapay zekânın hesaplama gücünün insanın yargı, bağlam okuma ve değer belirleme yetileriyle aynı kategoriye konamayacağını, geleceğin teknolojik düzeninde en kritik unsurun hâlâ insanın dünyayı anlama biçimi olduğunu savunmaktadır. Ona göre gerçek özerklik ve anlam üretme kapasitesi, yalnızca veriyi işleyen sistemlere ait değildir, dünyayı yorumlayan varlıklara aittir. Bu bakış açısı, Agentic AI’ın iş ve yaşamın dört katmanında üstlendiği rolü anlamlandırmak açısından büyük önem taşımaktadır. Smith’in değerlendirmesi, teknolojik sistemlerin karar verebilme kapasitesinin giderek arttığı bir dönemde, nihai yargı ve yön belirleme sorumluluğunun insanda kalmaya devam ettiği yönündeki analitik çerçeveyi desteklemektedir. Bu yaklaşım, hesaplama gücüne sahip sistemlerle insanın değer ve bağlam üretme kapasitesi arasındaki iş bölümünü görünür kılarak, Agentic AI döneminde etik ve insan-merkezli bir gelecek tasarımına güçlü bir teorik dayanak oluşturur.</p><p>Raporun tamamına ulaşmak için  <a href="https://bit.ly/3NC00rH">https://bit.ly/3NC00rH</a></p><p>Kategorilere göre yapay zekâ destekli ses teknolojisi kullanılarak Softtechliler tarafından seslendirilen içerikleri dinlemek için  <a href="https://bit.ly/4boSr1c">https://bit.ly/4boSr1c</a></p><p><strong><em>Kaynak</em></strong></p><p><em>The Promise of Artificial Intelligence: Reckoning and Judgment. MIT Press. Smith, B. C. (2019).</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42c0d6e14896" width="1" height="1" alt=""><hr><p><a href="https://medium.com/softtechas/zek%C3%A2n%C4%B1n-yeniden-tan%C4%B1mland%C4%B1%C4%9F%C4%B1-e%C5%9Fik-2026-ve-sonras%C4%B1-i%CC%87%C3%A7in-bir-%C3%A7er%C3%A7eve-42c0d6e14896">Zekânın Yeniden Tanımlandığı Eşik: 2026 ve Sonrası İçin Bir Çerçeve</a> was originally published in <a href="https://medium.com/softtechas">Softtech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>