214
I will send you newest post from subreddit /r/programming
Code Lifecycles
https://www.reddit.com/r/programming/comments/1kg88g8/code_lifecycles/
submitted by /u/switz213 (https://www.reddit.com/user/switz213)
[link] (https://saewitz.com/code-lifecycles) [comments] (https://www.reddit.com/r/programming/comments/1kg88g8/code_lifecycles/)
A Critical look at MCP
https://www.reddit.com/r/programming/comments/1kg6zws/a_critical_look_at_mcp/
<!-- SC_OFF -->Is it me or is it Anthropic... <!-- SC_ON --> submitted by /u/--raz (https://www.reddit.com/user/--raz)
[link] (https://raz.sh/blog/2025-05-02_a_critical_look_at_mcp) [comments] (https://www.reddit.com/r/programming/comments/1kg6zws/a_critical_look_at_mcp/)
git stash driven refactoring
https://www.reddit.com/r/programming/comments/1kg37vm/git_stash_driven_refactoring/
submitted by /u/Kobzol (https://www.reddit.com/user/Kobzol)
[link] (https://kobzol.github.io/programming/2025/05/06/git-stash-driven-refactoring.html) [comments] (https://www.reddit.com/r/programming/comments/1kg37vm/git_stash_driven_refactoring/)
Introducing HTML Helpers for Elm (my first official public package!)
https://www.reddit.com/r/programming/comments/1kg2h9n/introducing_html_helpers_for_elm_my_first/
submitted by /u/cekrem (https://www.reddit.com/user/cekrem)
[link] (https://cekrem.github.io/posts/introducing-html-helpers-for-elm/) [comments] (https://www.reddit.com/r/programming/comments/1kg2h9n/introducing_html_helpers_for_elm_my_first/)
The Hidden Challenges of AI Agents
https://www.reddit.com/r/programming/comments/1kg0ab5/the_hidden_challenges_of_ai_agents/
submitted by /u/paul_nameless (https://www.reddit.com/user/paul_nameless)
[link] (https://paul-nameless.com/ai-agent.html) [comments] (https://www.reddit.com/r/programming/comments/1kg0ab5/the_hidden_challenges_of_ai_agents/)
Mastering Kafka in .NET: Schema Registry, Error Handling & Multi-Message Topics
https://www.reddit.com/r/programming/comments/1kfzmkp/mastering_kafka_in_net_schema_registry_error/
<!-- SC_OFF -->Hi everyone! Curious how to improve the reliability and scalability of your Kafka setup in .NET? How do you handle evolving message schemas, multiple event types, and failures without bringing down your consumers?
And most importantly — how do you keep things running smoothly when things go wrong? I just published a blog post where I dig into some advanced Kafka techniques in .NET, including: Using Confluent Schema Registry for schema management Handling multiple message types in a single topic Building resilient error handling with retries, backoff, and Dead Letter Queues (DLQ) Best practices for production-ready Kafka consumers and producers Fun fact: This post was inspired by a comment from u/Finickyflame (https://www.reddit.com/u/Finickyflame) on my previous Kafka blog — thanks for the nudge! Would love for you to check it out — happy to hear your thoughts or experiences! You can read it here:
https://hamedsalameh.com/mastering-kafka-in-net-schema-registry-amp-error-handling/ <!-- SC_ON --> submitted by /u/DotDeveloper (https://www.reddit.com/user/DotDeveloper)
[link] (https://hamedsalameh.com/mastering-kafka-in-net-schema-registry-amp-error-handling/) [comments] (https://www.reddit.com/r/programming/comments/1kfzmkp/mastering_kafka_in_net_schema_registry_error/)
What does this mean by memory-safe language? | namvdo's technical blog
https://www.reddit.com/r/programming/comments/1kfyq46/what_does_this_mean_by_memorysafe_language/
<!-- SC_OFF -->- 90% of Android vulnerabilities are memory safety issues. - 70% of all vulnerabilities in Microsoft products over the last decade were memory safety issues. - What does this mean that a programming language is memory-safe? Let's find out in this blog post! <!-- SC_ON --> submitted by /u/vannam0511 (https://www.reddit.com/user/vannam0511)
[link] (https://learntocodetogether.com/programming-language-memory-safety/) [comments] (https://www.reddit.com/r/programming/comments/1kfyq46/what_does_this_mean_by_memorysafe_language/)
Modern Latex
https://www.reddit.com/r/programming/comments/1kflm67/modern_latex/
submitted by /u/namanyayg (https://www.reddit.com/user/namanyayg)
[link] (https://github.com/mrkline/modern-latex) [comments] (https://www.reddit.com/r/programming/comments/1kflm67/modern_latex/)
Writing OS from scratch for Cortex-M using Zig + C + Assembly
https://www.reddit.com/r/programming/comments/1kflgq5/writing_os_from_scratch_for_cortexm_using_zig_c/
submitted by /u/PearEducational8903 (https://www.reddit.com/user/PearEducational8903)
[link] (https://youtu.be/KMgUgPFHL7Y) [comments] (https://www.reddit.com/r/programming/comments/1kflgq5/writing_os_from_scratch_for_cortexm_using_zig_c/)
Why We Should Learn Multiple Programming Languages
https://www.reddit.com/r/programming/comments/1kfgptl/why_we_should_learn_multiple_programming_languages/
submitted by /u/Adventurous-Salt8514 (https://www.reddit.com/user/Adventurous-Salt8514)
[link] (https://www.architecture-weekly.com/p/why-we-should-learn-multiple-programming) [comments] (https://www.reddit.com/r/programming/comments/1kfgptl/why_we_should_learn_multiple_programming_languages/)
I made a simple web-based task tracker - hoping it helps you stay organized!
https://www.reddit.com/r/programming/comments/1kfb1fv/i_made_a_simple_webbased_task_tracker_hoping_it/
submitted by /u/kikimora47 (https://www.reddit.com/user/kikimora47)
[link] (https://gourabdg47.github.io/assets/code/simple-task-tracker.html) [comments] (https://www.reddit.com/r/programming/comments/1kfb1fv/i_made_a_simple_webbased_task_tracker_hoping_it/)
Rate Limiting in 1 diagram and 252 words
https://www.reddit.com/r/programming/comments/1kf93kn/rate_limiting_in_1_diagram_and_252_words/
submitted by /u/stmoreau (https://www.reddit.com/user/stmoreau)
[link] (https://www.systemdesignbutsimple.com/p/rate-limiting-in-1-diagram-and-252-words) [comments] (https://www.reddit.com/r/programming/comments/1kf93kn/rate_limiting_in_1_diagram_and_252_words/)
example. At Decombine, we want to provide our users assurances of how their data will be handled during a sales process. We can take the contents of our policy for the sales process, package it into OCI, and then sign it. This is an overly simple scenario, but it illustrates the key points: our policy becomes a commitment that can be easily distributed, reproduced, and verified. Here is how we might do it with conventional tools today: Start with a simple document. # Sales Engagement Agreement ## Data Handling ### 1. Data Collection You agree to provide us with the following data to facilitate the sales engagement process: Stakeholders: - Name ... Push the document to a registry. oras push --artifact-type "application/vnd.decombine.text.v1+markdown" docker.io/decombine/texts:sales-v0.0.1 Contracts being packaged, stored, and transmitted via OCI involves services and tooling interacting with registries, but most software distributed cloud-natively already do that, so organizations should already have a base level of familiarity. The tangle benefits are clear, across the following major value proposition categories: Improved security supply chain using cryptographic digital signatures OCI artifacts can be validated and signed out of the box. Artifacts are typically verified at multiple levels and layers to ensure that what you’re getting when you retrieve one is exactly what you expected. This is relied on heavily for things like Software Bill of Materials (SBOM). Contracts can take advantage of these same principles to validate that a specific template is unchanged, comes from a specific party, and can prove all of this using the same industry standards relied on for financial services, federal government, and other regulated industries. This establishes a base level of attestation and verification that simply doesn't exist today. Organizations may independently digitally sign their documents, but that process isn't baked in. It also isn't cost-effective, simple, or easily verifiable, whereas OCI artifacts of all kinds have this potential out of the box with relatively little configuration. Smart organizations have been shifting security left for years now, including building in supply chain attestation and verification into their software development lifecycles. Adopting these practices would effectively achieve the same thing for business procedures that can be automated for use in more complex environments such as regulated industries or by automated systems such as AI agents. OCI for contracts would enable the adopting organization to effectively standardize published contracts as indisputably validated in their respective business processes / value chains. Sustainability and efficiency using protocol basics Conventional document storage and distribution is effectively the copying of thousands, millions, or even billions of independent files. Some storage systems may support highly complex deduplication techniques to reduce storage requirements, but this may not be at all possible with many types of contracts. Producing contracts programmatically using templates that are intelligently layered would drastically change the economics. OCI can be used to chunk contracts into template layers. If 90% of the end product is standardized, that means 90% of the contract could be in a single layer. Even if there are a billion independent versions of that file, as long as they share a common ancestor template, we're only concerned with storing the changes of that last 10%. The same goes for uploading, downloading, and transferring in general - we're just moving the changes. Let's put this into a practical example where we have 10 million contract file records. Each contract file is a PDF of about 6 MB. 90% of these files is exactly the same with the remaining 10% being customized. The storage benefits are clear, but this also means that the user experience around working with these documents is significantly improved. We're not
Читать полностью…
DualMix128: A Fast (~0.36 ns/call in C), Simple PRNG Passing PractRand (32TB) & BigCrush
https://www.reddit.com/r/programming/comments/1kf7fzc/dualmix128_a_fast_036_nscall_in_c_simple_prng/
<!-- SC_OFF -->Hi r/programming (https://www.reddit.com/r/programming), I wanted to share a project I've been working on: DualMix128, a new pseudo-random number generator implemented in C. The goal was to create something very fast, simple, and statistically robust for non-cryptographic applications. GitHub Repo: https://github.com/the-othernet/DualMix128 (MIT License) Key Highlights: Very Fast: On my test system (gcc 11.4, -O3 -march=native), it achieves ~0.36 ns per 64-bit generation. This was 104% faster than xoroshiro128++ (~0.74 ns) and competitive with wyrand (~0.36 ns) in the same benchmark. Excellent Statistical Quality: Passed PractRand testing from 256MB up to 32TB with zero anomalies reported. Passed the full TestU01 BigCrush suite. The lowest p-values encountered were around 0.02. Simple Core Logic: The generator uses a 128-bit state and a straightforward mixing function involving addition, rotation, and XOR. MIT Licensed: Free to use and integrate. Here's the core generation function: // Golden ratio fractional part * 2^64 const uint64_t GR = 0x9e3779b97f4a7c15ULL; // state0, state1 initialized externally (e.g., with SplitMix64) // uint64_t state0, state1; static inline uint64_t rotateLeft(const uint64_t x, int k) { return (x << k) | (x >> (64 - k)); } uint64_t dualMix128() { // Mix the current state uint64_t mix = state0 + state1; // Update state0 using addition and rotation state0 = mix + rotateLeft( state0, 26 ); // Update state1 using XOR and rotation state1 = mix ^ rotateLeft( state1, 35 ); // Apply a final multiplication mix return GR * mix; } I developed this while exploring simple state update and mixing functions that could yield good speed and statistical properties. It seems to have turned out quite well on both fronts. I'd be interested to hear any feedback, suggestions, or see if anyone finds it useful for simulations, hashing, game development, or other areas needing a fast PRNG. Thanks! <!-- SC_ON --> submitted by /u/danielcota (https://www.reddit.com/user/danielcota)
[link] (https://github.com/the-othernet/DualMix128) [comments] (https://www.reddit.com/r/programming/comments/1kf7fzc/dualmix128_a_fast_036_nscall_in_c_simple_prng/)
Incant - a frontend for Incus with a declarative way to define and manage development environments
https://www.reddit.com/r/programming/comments/1kf3oh7/incant_a_frontend_for_incus_with_a_declarative/
submitted by /u/esiy0676 (https://www.reddit.com/user/esiy0676)
[link] (https://discuss.linuxcontainers.org/t/introducing-incant-a-frontend-for-incus-with-a-declarative-way-to-define-and-manage-development-environments/23492) [comments] (https://www.reddit.com/r/programming/comments/1kf3oh7/incant_a_frontend_for_incus_with_a_declarative/)
DynamoDB Global Secondary Indexes - Internal Working and Best Practices
https://www.reddit.com/r/programming/comments/1kg7qfy/dynamodb_global_secondary_indexes_internal/
submitted by /u/Local_Ad_6109 (https://www.reddit.com/user/Local_Ad_6109)
[link] (https://engineeringatscale.substack.com/p/dynamodb-gsi-best-practices-optimization) [comments] (https://www.reddit.com/r/programming/comments/1kg7qfy/dynamodb_global_secondary_indexes_internal/)
Startup project
https://www.reddit.com/r/programming/comments/1kg6yfa/startup_project/
<!-- SC_OFF -->Im doing a startup project as a freshly graduated high schooler. The project consist of an mobile app, which will be an alarm that wakes up the user guaranteed by making the user do a task of his choice. I found my idea a really good solution for people who can't wake up easily, since i made an research using google forms and got around 50 answers.Most of the answers have at least 3 alarms ringing every morning which is insane for me personally. My question is how do i raise awareness to my project and how should i promote it? The mobile app is in development and i am still brainstorming ideas for many features in the future. I am also developing website for the app but it will probably take awhile since im the only developer of the app. I would appreciate any great tips for how should i proceed with the development stage and any prior experience of any member here! <!-- SC_ON --> submitted by /u/Muslim__Man (https://www.reddit.com/user/Muslim__Man)
[link] (https://github.com/Nooze-Alarm) [comments] (https://www.reddit.com/r/programming/comments/1kg6yfa/startup_project/)
Beyond the Cloud: The Local-First Software Revolution • Brooklyn Zelenka & Julian Wood
https://www.reddit.com/r/programming/comments/1kg32zc/beyond_the_cloud_the_localfirst_software/
submitted by /u/goto-con (https://www.reddit.com/user/goto-con)
[link] (https://youtu.be/9gZMnJ2XPkM) [comments] (https://www.reddit.com/r/programming/comments/1kg32zc/beyond_the_cloud_the_localfirst_software/)
Exploring Apache Kafka Internals and Codebase
https://www.reddit.com/r/programming/comments/1kg27y1/exploring_apache_kafka_internals_and_codebase/
submitted by /u/Active-Fuel-49 (https://www.reddit.com/user/Active-Fuel-49)
[link] (https://cefboud.com/posts/exploring-kafka-internals) [comments] (https://www.reddit.com/r/programming/comments/1kg27y1/exploring_apache_kafka_internals_and_codebase/)
Smaller, faster serialization for Ruby apps and beyond!
https://www.reddit.com/r/programming/comments/1kfzrp9/smaller_faster_serialization_for_ruby_apps_and/
submitted by /u/Kabra___kiiiiiiiid (https://www.reddit.com/user/Kabra___kiiiiiiiid)
[link] (https://oldmoe.blog/2025/05/05/smaller-faster-serialization-for-ruby-apps-and-beyond/) [comments] (https://www.reddit.com/r/programming/comments/1kfzrp9/smaller_faster_serialization_for_ruby_apps_and/)
Starting on seamless C++ interop in jank
https://www.reddit.com/r/programming/comments/1kfzgwe/starting_on_seamless_c_interop_in_jank/
submitted by /u/Xadartt (https://www.reddit.com/user/Xadartt)
[link] (https://jank-lang.org/blog/2025-05-02-starting-seamless-interop/) [comments] (https://www.reddit.com/r/programming/comments/1kfzgwe/starting_on_seamless_c_interop_in_jank/)
Typed Lisp, a Primer
https://www.reddit.com/r/programming/comments/1kflmbh/typed_lisp_a_primer/
submitted by /u/namanyayg (https://www.reddit.com/user/namanyayg)
[link] (https://alhassy.com/TypedLisp.html) [comments] (https://www.reddit.com/r/programming/comments/1kflmbh/typed_lisp_a_primer/)
Driving Compilers (2023)
https://www.reddit.com/r/programming/comments/1kfllxm/driving_compilers_2023/
submitted by /u/namanyayg (https://www.reddit.com/user/namanyayg)
[link] (https://fabiensanglard.net/dc/index.php) [comments] (https://www.reddit.com/r/programming/comments/1kfllxm/driving_compilers_2023/)
Tool for dynamically managing Cookies and URL Parameters
https://www.reddit.com/r/programming/comments/1kfkg78/tool_for_dynamically_managing_cookies_and_url/
<!-- SC_OFF -->I made this script that adds dynamic functionality to managing URL parameters and cookies in HTML and JavaScript. <!-- SC_ON --> submitted by /u/philtrondaboss (https://www.reddit.com/user/philtrondaboss)
[link] (https://github.com/MineFartS/JS-Data-Manager/) [comments] (https://www.reddit.com/r/programming/comments/1kfkg78/tool_for_dynamically_managing_cookies_and_url/)
Graceful Shutdown in Go: Practical Patterns
https://www.reddit.com/r/programming/comments/1kfbtib/graceful_shutdown_in_go_practical_patterns/
submitted by /u/iamkeyur (https://www.reddit.com/user/iamkeyur)
[link] (https://victoriametrics.com/blog/go-graceful-shutdown/index.html) [comments] (https://www.reddit.com/r/programming/comments/1kfbtib/graceful_shutdown_in_go_practical_patterns/)
No AI Mondays
https://www.reddit.com/r/programming/comments/1kf9uu5/no_ai_mondays/
submitted by /u/galher (https://www.reddit.com/user/galher)
[link] (https://fadamakis.com/no-ai-mondays-c4c341a51956) [comments] (https://www.reddit.com/r/programming/comments/1kf9uu5/no_ai_mondays/)
downloading and interacting with huge files, but only pulling little chunks as necessary. Improved model context performance Large Language Models (LLM) are being widely used to perform analysis over document sets. This can be very useful, but also incredibly expensive, energy inefficient, and not altogether reliable. Models are limited by their compute capacity on how much data they can ingest at any one time. Analyzing a document that is structurally the same doesn't inherently mean the model will be more effective or accurate in its performance the next time. The model will still need to ingest the entirety of the document into its current context to perform analysis. A contract or document leveraging OCI, however, could be indexed more time/space efficiently as part of a RAG or context fine-tuning lifecycle. The model would not need to ingest the entire document, and instead can focus on only the changes between layers, reducing the context size by that 90%. Ready for smart legal contract integration The most impactful scenario is that once the contract has been packaged as OCI; it can be shipped right alongside software. This enables scenarios at the cutting edge of innovation where software can be shaped by the contract itself, or vice versa. This can improve user experience, reduce regulatory burdens, and drastically change the quality of service that can be delivered out of the box. If these scenarios seem interesting to you, Decombine is looking for the innovators and early adopters across industries to lead their peers in delivering higher quality and reliability to their users. <!-- SC_ON --> submitted by /u/TheFilterJustLeaves (https://www.reddit.com/user/TheFilterJustLeaves)
[link] (https://decombine.com/blog/oci-for-contracts) [comments] (https://www.reddit.com/r/programming/comments/1kf8i24/shipping_business_the_same_way_we_ship_software/)
Shipping business the same way we ship software: OCI for contracts
https://www.reddit.com/r/programming/comments/1kf8i24/shipping_business_the_same_way_we_ship_software/
<!-- SC_OFF -->I wrote an article on using the Open Container Initiative (OCI) Distribution as an underlying system to create and distribute natural language contracts (that can also have workloads associated with them). I'm working on integrating this with our open-source Decombine Smart Legal Contracts specification (available at https://github.com/decombine/slc with Apache 2.0 license) and with the Linux Foundation's Accord Project (https://accordproject.org/) Agreement Protocol available at https://github.com/accordproject/apap (looks like we need to add a license to this). The text is as follows (minus some diagrams and code examples):
---------- OCI for Contracts Ship contracts like software. May 5, 2025 In this article, we will discuss a novel way of creating natural language contracts atop the Open Container Initiative (OCI) standard for artifacts. This is relevant for any business or organization that is foundationally built on software or regularly deals with high volumes of contracts. The business case is simple: the vast majority of executed contracts are templates and OCI is arguably the most pervasive set of technologies and standards in the world for handling templates. When we think contracts, we think arbitrarily verbose documents. The reality is much different, though. They’re usually copies of an existing document that has perhaps been customized. This isn't unlike existing software and how it is distributed using software containers. For those unfamiliar, software is shared in public repositories such as DockerHub and GitHub Container Registry which allows for using standardized packages to quickly start and build software, much like Legos. There exists a similar business case where software-defined contracts could centralized among relevant parties and distributed in a similar manner. Since containers and their implementation is standardized, there is a high degree of confidence in how software is built and shared. This same confidence can be applied to contracts. In the following diagram, we can see how an agentic automation system could use standardized contracts and terms to interact with a specific supplier. Assuming both parties have access to the standardized contracts via OCI, they can be assured that they're speaking the same language in terms of expectations. A well defined set of standards could enable industries to operate much more autonomously, and with less friction. This is especially true in industries that are heavily regulated, such as finance, healthcare, and government. sequenceDiagram BuyerAgent->>+Supplier: Sales Offer Supplier-->>-BuyerAgent: Delivery Terms BuyerAgent->>+Supplier: Collateral Supplier-->>-BuyerAgent: Confirmation Let's be more specific about what kinds of contracts we're talking about though. This discussion right now is mostly targeted for those who reside in the spectrum between these two: For organizations providing online services, much of their contract offerings are literally just web pages with text displayed. This is colloquially termed “click wrap”. You take it or leave it. For organizations conducting standardized offerings in more complex environments where customers have negotiating power (consulting, services, etc.) there are typically standardized documents that are customized as necessary. What is OCI? - Open Container Initiative OCI has since become synonymous with the world of shipped software. It is used regularly by every company that provides containerized software; most likely all of them. Five years ago, OCI finalized their Distribution Specification v1.0. The Distribution Specification provides a protocol to facilitate and standardize content distribution. It has since become a cornerstone of packaging software. Where Contracts and OCI Meet Let's examine a simple
Handling real-time two-way voice translation in SwiftUI using AVFoundation + Combine
https://www.reddit.com/r/programming/comments/1kf6slk/handling_realtime_twoway_voice_translation_in/
<!-- SC_OFF -->Hi all,
I’ve been working on a voice translator app in SwiftUI and wanted to share some of the implementation details that might be relevant to others working with real-time audio processing or conversational UI. Key technical aspects: Built entirely in SwiftUI with Combine managing real-time state and UI updates. AVFoundation is used for continuous speech recognition and synthesis. I integrated CoreHaptics to provide tactile feedback during mic activation — similar to how Apple’s own apps behave. Custom layout challenges: managing mirrored text and interactive zones for each user on a shared screen (like a dual-sided conversation). Optimized for iPhone and iPad with reactive layout resizing. Localization pipeline handles 40+ languages, fallback handling, and preview simulation using mock data. I’m particularly interested in how others have approached: Real-time translation pipelines Efficient Combine usage in audio-heavy apps Haptic coordination in conversational UIs Would love to hear thoughts or improvements if you’ve done similar work. No app store links here — just keen to nerd out on the architecture and share ideas. <!-- SC_ON --> submitted by /u/Intelligent_iOS (https://www.reddit.com/user/Intelligent_iOS)
[link] (https://gist.github.com/Jash-Balar/bc1d6b4d464e77af8cffe41433397040#file-swiftui-voice-translator-md) [comments] (https://www.reddit.com/r/programming/comments/1kf6slk/handling_realtime_twoway_voice_translation_in/)
Why most devs struggle with impostor syndrome
https://www.reddit.com/r/programming/comments/1kf2bu5/why_most_devs_struggle_with_impostor_syndrome/
submitted by /u/ConcentrateOk8967 (https://www.reddit.com/user/ConcentrateOk8967)
[link] (https://youtu.be/DCreNFG-72o) [comments] (https://www.reddit.com/r/programming/comments/1kf2bu5/why_most_devs_struggle_with_impostor_syndrome/)