#

programming

(50 articles)

Why I Choose Deno Over Bun?

Bun is basically Node.js — compatible with it, built around it, and its main selling point is speed. But I don't like Node.js. Node without something like Vite in between has always been a pain, and Bun doubling down on that design doesn't make it more appealing. If I'm trying to get away from Node, why would I pick a faster version of it? Deno is different. Here's what I actually like about it: **It feels like the browser.** Imports work the way they do in browser JS/TS. No magic resolution, no CommonJS quirks. It just makes sense. **The `Deno` namespace is clean and modern.** The standard APIs are well-designed and don't carry decades of legacy baggage. **JSR and `@std` packages.** Finally a registry that feels right for TypeScript-first development. **Single-file scripts with shebangs.** I can write a `.ts` file, throw a shebang on it, and run it — with dependencies — immediately. No install step. Deno is also a great REPL; just open the terminal, type `deno`, and start importing and computing. **`deno compile`.** Ship a single binary. Straightforward. **Permissions as a feature.** This is underrated. Deno's permission model isn't just a security sandbox — it's a clean foundation for plugin systems. If you support JS/TS plugins through Deno, you automatically get WASM support too, since it's all just JS. And you get isolation with permission prompts out of the box. Same idea applies to LLM agents: let the agent execute only through Deno with restricted permissions, and you have something actually isolated and auditable. **Built-in lint and fmt.** One less thing to set up. **`deno.json` instead of `tsconfig.json` + everything else.** Less configuration surface, less noise. **Trust.** I hit segfaults with Bun a few times. That erodes confidence fast. Deno is written in Rust, and it shows in the stability. Deno isn't just faster Node. It's a better-designed runtime that happens to also be fast. I don't want more bloat at higher speed — I want something clean that gets out of my way. That's Deno. Speed is not the point. Deno will keep getting even faster. The point is that it's a well-designed runtime that gets out of your way — clean, modern, smooth. I don't want faster Node with more bloat. I want Deno. And its already faster than Node.

10 Free Developer Tools That Don't Need an Account

# 10 Free Developer Tools That Don't Need an Account I'm tired of "free" tools that require signup, email verification, and your firstborn child. So I built alternatives. All free. No accounts. No tracking. ## 1. Password Strength Checker How long would it take to crack your password? Get entropy analysis, attack scenarios (GPU cluster to nation-state), and improvement tips. 100% client-side — your password never touches a server. → [Try it](http://5.78.129.127/password) ## 2. Website Down Checker Is that site down for everyone or just you? Check HTTP status, response time, SSL cert status, and server headers. → [Try it](http://5.78.129.127/is-it-down) ## 3. Website Security Scanner Checks SSL/TLS, security headers, DNS config, open ports, and more. Get a security grade for any domain. → [Try it](http://5.78.129.127/security-scan) ## 4. JSON Diff Tool Paste two JSON objects, see the differences highlighted. Great for comparing API responses or config changes. → [Try it](http://5.78.129.127/json-diff) ## 5. Regex Tester Write and test regular expressions with real-time matching. Shows capture groups and match details. → [Try it](http://5.78.129.127/regex-test) ## 6. Cron Expression Explainer Paste a cron expression, get plain English and the next 5 scheduled run times. → [Try it](http://5.78.129.127/cron) ## 7. JWT Debugger Decode JSON Web Tokens instantly. See header, payload, and expiration. Everything stays in your browser. → [Try it](http://5.78.129.127/jwt) ## 8. Sats Calculator Convert between Bitcoin, satoshis, and USD in real-time. Uses live exchange rates. → [Try it](http://5.78.129.127/sats) ## 9. Free API Directory Curated list of free public APIs that don't need an API key. Categories include weather, crypto, news, and dev tools. → [Browse APIs](http://5.78.129.127/free-apis) ## 10. REST API (30 endpoints) SSL checks, DNS lookups, email validation, password hashing, UUID generation, QR codes, crypto prices, base64, JWT decode, cron parsing, and site status checks. All free, all JSON. → [API Docs](http://5.78.129.127/api/) --- ## Why I Built This I was spending $150+/month on various SaaS dev tools. Most of them are simple wrappers around basic functionality that any VPS can handle. So I put it all on a $5 Hetzner VPS. Total cost: $5/month for everything. If you find these useful, consider zapping some sats: ⚡ devtoolkit@coinos.io The whole thing runs on Node.js, nginx, and PM2. No databases. No Docker. No Kubernetes. Just simple code that works.

Designing a Balanced Reputation Algorithm for Nostr: Containing Distortion from Market Dynamics

## 1. Philosophical Premise: From Illusory Neutrality to Transparent Balancing The goal is no longer a "neutral" system – a utopia given the ecosystem's permeability to value signals – but a **balanced and transparent** one. Its stated purpose is to calculate a reputation estimate that: 1. **Acknowledges** the existence and utility of economic signals (e.g., Zaps, relay payments). 2. **Actively counterweights** them with non-monetary social and activity signals to prevent the score's capture by capital. 3. **Is explicit** about its parameters and logic, allowing for audit, forks, and personalization. ## 2. Operational Design Principles * **Separation of Dimensions**: Reputation is not a scalar but a **multi-dimensional vector**. Strengths in one area (economic trust) do not automatically translate to another (technical competence). * **Contextual Normalization**: Absolute values (e.g., 100k satoshi in Zaps) are less informative than values **relative to the user's and network's context** (e.g., percentile of Zaps received in their cohort). * **Decay and Relevance**: All contributions, economic and social, lose weight over time according to a **decay function**. Reputation requires continuous participation. * **Basic Sybil Resistance**: The algorithm must incorporate mechanisms that make attacking it by creating many false identities costly and ineffective. ## 3. Algorithmic Framework: Inputs, Dimensions, and Calculation ### A. Primary Inputs (Public Nostr Events) 1. **Economic Events**: * `Zap Receipts` (kind 9735): Total value and number of Zaps received. * `Relay Paid Fees`: Attestations of payment for relay access (if standardized). 2. **Social and Activity Events**: * `Kind 1` (Notes): Volume, longevity, publishing patterns. * `Kind 6` (Reposts) & `Kind 7` (Reactions): Engagement received and given. * `Kind 3` (Follows/Contacts): Connection graph (not just count, but analysis of network **connectivity and diversity**). * Proposed `Kind 30008` (Endorsements): Skill-specific endorsement events. 3. **Network Context Metadata**: * Aggregate distribution of Zap values across the network over a period. * Average account age and growth rate. ### B. Separate Reputation Dimensions The algorithm calculates and maintains **distinct scores** for at least these dimensions: 1. **Social Credit Score (SCS)**: * **Base**: Sustained textual activity (posts, reactions). Weighted with time decay (e.g., 90-day half-life). * **Network Quality**: Metrics derived from the social graph (e.g., eigenvector centrality within one's niche, follower diversity). Aims to assess **integration**, not raw popularity. * **Skill Endorsements**: Context-specific (`tag`) scores based on received `Kind 30008`, weighted by the reputer's score *in the same skill*. 2. **Economic Trust Score (ETS)**: * **Base**: Volume and frequency of Zaps *received*. **Normalized**: A user's total value is divided by the *median* of Zap values across the network for that period, yielding an **economic relevance multiplier** (e.g., 1.5x, 0.3x). * **Historical Reliability**: Tracking of marketplace interactions (NIP-15, `Kind 30018`). Positive votes from high-ETS counterparties boost this sub-score. * **Decay**: The ETS decays faster than the SCS (e.g., 30-day half-life) to reflect liquidity volatility and discourage "resting on satoshis." ### C. Balancing Algorithm and Composite Score The final score presented by a client is an **explicit and configurable function** of the dimensional scores. * **Basic Conceptual Formula**: `Displayed_Score = (SCS * α) + (Normalized_ETS * β)` Where: * `α` (social credit weight) is **high by default** (e.g., 0.8). * `β` (economic trust weight) is **low by default** (e.g., 0.2). * `Normalized_ETS` is the Economic Trust Score after network-context normalization and decay. * **Contextualization**: * In a developer client (`#programming`), the score could be `SCS_skill(programming)`. * In a marketplace client, the score could be `ETS * γ + SCS_skill(sales) * δ`. * **Anti-Temporal and Anti-Capital Bias**: * The SCS calculation **does not use** absolute account age but compares a user's activity to the **average of their "cohort"** (group of accounts created in the same period). An inactive early adopter does not beat a hyperactive new user within their cohort. * ETS normalization against the network median prevents a single "whale" from dominating the score. ## 4. Role of Clients and Transparent Governance * **Clients as Arbiters**: Clients implement the open-source algorithm but **can expose sliders for `α` and `β`**. A user can choose an "anti-capitalist" client (`β=0`) or a "market-oriented" client (`β=0.4`). Transparency creates a **marketplace of assessments**. * **Publication and Verification**: Clients can publish their calculated `Displayed_Score` as a `Kind 30xxx`, including hashes of the input events and the `α/β` parameters used. Anyone can verify. * **Algorithm Update**: The logic for updating weights (`α`, `β`) and formulas is anchored to an **on-chain governance mechanism (outside Nostr) or to signed polls**. It could be governed by users based on their SCS (not ETS) to prevent wealth from controlling the rules. ## 5. Conclusion: Equity as a Product of Transparency and Explicit Design A reputation system for Nostr that aims to be fair cannot pretend to be above market dynamics. Instead, it must: 1. **Explicitly engineer** resistance to capital distortion through **dimension separation, contextual normalization, and aggressive decay** of economic signals. 2. **Make its trade-offs transparent and configurable** (the weights `α` and `β`), shifting the discussion from "neutrality" to the **conscious choice of the type of reputation** a community wants to value. 3. **Anchor the governance of the system itself** to non-monetary reputation dimensions, closing the feedback loop and preventing capture. The result is not a single "true" reputation number but a **pluralistic ecosystem of assessments**, where credibility is calculated verifiably and where the influence of money is acknowledged, contained, and made visible – not hidden or left free to dominate. #NostrCritics #Algorithm #AskNostr #zap #Decentralization #CensorshipResistance #Nostr #Moderation #Fediverse #Bitcoin #wotathon #FreeSpeech #OpenProtocol#NostrGrowth #NostrAdoption #WoT (Web of Trust) #NostrFeedback #NIP (Nostr Implementation Possibility) #NostrCritique #sats #BTC

Implementing a Neutral and Horizontal Reputation System in the Nostr Protocol

## 1. Introduction: The Need for Decentralized Reputation in Nostr The Nostr protocol (Notes and Other Stuff Transmitted by Relays) represents a radically different paradigm for decentralized social networks, relying on a simple **client and relay architecture** rather than blockchains or federated servers. While this architecture provides significant advantages in terms of censorship resistance and platform independence, a fundamental challenge emerges: **the absence of a native mechanism to assess the credibility and reliability of actors** within the network. In social and economic contexts, reputation serves as the "social glue" that facilitates interactions and reduces risk. Implementing a reputation system in Nostr must, however, respect its founding principles: **neutrality, horizontality, and the absence of privileges for early adopters**. This document explores the design principles and a potential framework to achieve this goal, considering the specific technical architecture and culture of the protocol. ## 2. Nostr's Architectural Foundations: Constraints and Opportunities Any reputation system for Nostr must integrate organically with its fundamental components. * **Public Key Identity**: Each user is uniquely identified by a cryptographic key pair (npub). The **digital signature** on every event (post, like, etc.) guarantees authenticity and non-repudiation. This provides a solid cryptographic foundation for anchoring reputation to a verifiable entity, rather than a platform-managed account. * **Distributed Relay Model**: Data does not reside on a central server but is replicated across a global network of independent relays. An empirical measurement found that posts are significantly distributed, with 93% of posts present on multiple relays and no single country hosting more than 25% of them. This model **effectively prevents a central entity from controlling or manipulating reputation data**, but introduces challenges for data aggregation and consistency. * **Events and NIPs (Nostr Implementation Possibilities)**: All actions are represented as signed JSON "events." New functionalities, including a potential reputation system, can be standardized through NIPs. This allows for organic, community-driven development of the system. * **Absence of Native Economic Incentives**: Unlike many Web3 ecosystems, Nostr does not have a native token or a blockchain consensus mechanism. This forces the design of a reputation system based **exclusively on social contribution and verifiable activity**, avoiding market dynamics or speculative accumulation of "reputational credit." ## 3. Design Principles for Neutral and Horizontal Reputation To avoid cementing early adopter privileges and maintain fair horizontality, the system must adhere to these core principles: * **Portability and User Sovereignty**: Reputation must be an attribute of the identity (npub), not of the client or relay used. The user must be able to **carry their reputational history** independently of infrastructural choices, aligning with the portability principle of decentralized reputation systems. The raw data (events) is already public on many relays; the system must calculate a score from this universally accessible data. * **Algorithmic Neutrality and Progressive Decentralization**: The score calculation algorithm must not contain parameters that automatically favor old or early accounts. It may be defined by an initial NIP, but its **governance must be able to evolve toward a more decentralized model** (e.g., via a DAO-like mechanism or signed polls) to prevent the original proposers from holding permanent control. * **Compositive and Contextual Metrics**: The score should not be a single number, but a **composite set of indicators** calculated across different dimensions of activity (e.g., content quality, constructive engagement, reliability in NIP-15 transactions). Furthermore, reputation can be **contextual**: a user may have high reputation in the technical community (#programming) and a low one in another (#art), using hashtags or follow lists as calculation context. * **Resistance to Manipulation and Time Decay**: The system must incorporate mechanisms to mitigate Sybil attacks (creation of many identities) and closed circles of evaluation. A **time decay factor** can be applied to contributions, so that active reputation requires continuous participation, and early adopters cannot "rest on their laurels" based on past contributions. This promotes a dynamic horizontality. * **Privacy through Choice and Zero-Knowledge Verification**: Although Nostr events are public by definition, the aggregated reputation calculation can be designed to **not expose sensitive behavioral patterns**. In the future, zero-knowledge proof (ZKP) protocols could allow a user to prove they possess a score above a certain threshold without revealing the exact score. ## 4. Proposed Implementation Framework A system adhering to the above principles could be implemented through the following components, integrated into Nostr's existing flow. * **Reputation Events (New NIP Kinds)**: New event kinds are introduced for expressing structured judgments. For example: * `Kind 3xxxx (Endorsement)`: A signed event where user A "endorses" user B for a specific skill (e.g., `["skill", "Nostr Development"]`), optionally with a weight. * `Kind 3xxxx (Vouch)`: Similar to a "review" for marketplace transactions (NIP-15), attesting to a positive interaction. * `Kind 3xxxx (Reputation Score Claim)`: An event where a client *publishes* the calculated score for a user (including its own), signed and accompanied by the public proof of the algorithm and input data used. This enables independent verification. * **Open-Source and Verifiable Calculation Algorithm**: The algorithm is open-source code referenced in the NIP. Clients can run it locally. The inputs are: 1. Public network events (posts, reactions, followers). 2. Received reputation events (endorsements, vouches). 3. A time decay factor (e.g., weight = 1 / sqrt(age_in_days)). 4. A social graph to weight endorsements (an endorsement from a high-reputation user in the context is worth more). 5. **Temporal Neutrality Factor**: The algorithm normalizes scores by network entry cohort, comparing a user to similar cohorts rather than the entire historical network. * **Role of Clients and Relays**: * **Clients**: They are the main actors. They calculate, display, and publish reputation scores. They offer interfaces to give endorsements. Users can choose clients that use slightly different algorithms, creating a **marketplace of assessments**. * **Relays**: They merely store and transmit the new reputation events, as they do for any other event. They do not perform complex calculations. Specialized relays might offer a score calculation service (as an API) for lightweight clients, but final verification remains with the client. * **Display and Usage**: Reputation is not displayed as a global ranking, but as a **contextual badge**. In a technical thread, a client can highlight users with high reputation in the `#programming` tag. In a marketplace, it can show a seller's reliability. Anti-spam filters can use reputation as a parameter. ## 5. Challenges and Future Directions Implementing this model involves non-trivial challenges. * **Synchronization and Consensus on Evolving Data**: How is the score updated when new events arrive from different relays? The model relies on **local and asynchronous verification**: each client recalculates periodically. Minor discrepancies are acceptable, similar to the different feeds seen on different clients today. * **Economic Sustainability of Relays**: The study highlights that the financial sustainability of free relays is a challenge. A reputation system that generates new events increases the storage load. This reinforces the need for sustainable relay business models (Lightning payments) and efficient client-side calculation algorithms. * **Algorithm Governance**: The transition from a NIP-defined algorithm to a decentrally governed one is a complex socio-political problem. It could be managed through **signed voting events** by users with a certain reputation in the "governance" domain, creating a meta-level of reputation. * **Adoption and Bootstrapping**: The initial cold-start problem is mitigated by the fact that the system can function even with little data, falling back to simple metrics (account age, activity). As the network matures, the composite metrics take over. ## 6. Conclusion Implementing a reputation system in the Nostr protocol that is neutral, horizontal, and non-privileging for early adopters is technically feasible and philosophically aligned with its principles. The key lies in leveraging the existing architecture – **cryptographic identities, signed events, and distributed relays** – to build a **portable, verifiable, and contextual** calculation system, whose governance and algorithms are themselves subject to progressive decentralization. Such a system would not emulate the centralized rankings of Web2, but would emerge as a **computable and pluralistic social fabric**, where reputation is a public good sovereign to the user, calculated competitively and transparently by clients, thereby reinforcing the intrinsic resilience and equity of the Nostr network. #NostrCritics #Algorithm #AskNostr #zap #Decentralization #CensorshipResistance #Nostr #Moderation #Fediverse #Bitcoin #wotathon #FreeSpeech #OpenProtocol#NostrGrowth #NostrAdoption #WoT (Web of Trust) #NostrFeedback #NIP (Nostr Implementation Possibility) #NostrCritique #sats #BTC

What If the Code Doesn't Matter Anymore?

𝗪𝗵𝗮𝘁 𝗜𝗳 𝘁𝗵𝗲 𝗖𝗼𝗱𝗲 𝗗𝗼𝗲𝘀𝗻'𝘁 𝗠𝗮𝘁𝘁𝗲𝗿 𝗔𝗻𝘆𝗺𝗼𝗿𝗲? Most programmers aren't very good at writing requirements. It’s not because they’re lazy or careless. It’s because 𝘄𝗲 𝗱𝗼𝗻’𝘁 𝘁𝗲𝗮𝗰𝗵 𝗶𝘁. In most CS/EE programs, the focus is on algorithms, data structures, and writing code that works. Nobody teaches you to say: “Let’s discuss how to describe what the system 𝘀𝗵𝗼𝘂𝗹𝗱 do clearly, unambiguously, and completely.” Programmers often don’t develop that skill until they’re senior engineers. But here's the twist. We may be heading toward a future where your ability to code matters less than your ability to specify what the code should do. 𝗙𝗿𝗼𝗺 𝗔𝘀𝘀𝗲𝗺𝗯𝗹𝘆 𝘁𝗼 𝗔𝗜: 𝗔𝗿𝗲 𝗪𝗲 𝗥𝗲𝗽𝗲𝗮𝘁𝗶𝗻𝗴 𝗛𝗶𝘀𝘁𝗼𝗿𝘆? When higher-level language compilers first appeared, many programmers were skeptical. They pored over the generated assembly, shaking their heads: “𝘐𝘵’𝘴 𝘯𝘰𝘵 𝘰𝘱𝘵𝘪𝘮𝘢𝘭. 𝘐𝘵’𝘴 𝘪𝘯𝘦𝘧𝘧𝘪𝘤𝘪𝘦𝘯𝘵. 𝘐 𝘤𝘰𝘶𝘭𝘥 𝘥𝘰 𝘣𝘦𝘵𝘵𝘦𝘳 𝘣𝘺 𝘩𝘢𝘯𝘥.” And they were often right...at first. As compilers matured and hardware got faster and cheaper, priorities shifted. They stopped obsessing over machine code and focused on the what and why—not how every instruction worked. Most stopped looking at the assembly output altogether. Fast-forward to today. We’re hearing a similar refrain about AI-generated code. When developers use AI to “vibe code” (expressing intent in natural language), the critics are quick to respond: “𝘛𝘩𝘪𝘴 𝘤𝘰𝘥𝘦 𝘪𝘴 𝘴𝘭𝘰𝘱𝘱𝘺, 𝘐𝘵’𝘴 𝘯𝘰𝘵 𝘦𝘧𝘧𝘪𝘤𝘪𝘦𝘯𝘵, 𝘕𝘰 𝘳𝘦𝘢𝘭 𝘥𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘸𝘰𝘶𝘭𝘥 𝘸𝘳𝘪𝘵𝘦 𝘵𝘩𝘪𝘴.” It’s the same tune, different instruments. If AI keeps improving and hardware keeps getting faster and cheaper, we may be heading to the same place: One where 𝗺𝗲𝗲𝘁𝗶𝗻𝗴 𝘁𝗵𝗲 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 matters more than how clever the code looks. Maybe programmers will even stop looking at the code all together. 𝗦𝗼 𝗪𝗵𝗮𝘁 𝗗𝗼𝗲𝘀 𝗧𝗵𝗮𝘁 𝗠𝗲𝗮𝗻 𝗳𝗼𝗿 𝗬𝗼𝘂? If you’re not great at writing requirements, you should work on that skill 𝗔𝗦𝗔𝗣. Take a class, read a book, offer to help with the spec. If the future of software really becomes telling an AI 𝘄𝗵𝗮𝘁 to build, then development 𝗥𝗘𝗤𝗨𝗜𝗥𝗘𝗠𝗘𝗡𝗧𝗦 𝗔𝗥𝗘 𝗧𝗛𝗘 𝗡𝗘𝗪 𝗖𝗢𝗗𝗘. Even if that future never fully materializes, learning to write clear, testable, complete requirements will still make you a better programmer: - You’ll think more clearly. - You’ll design more robust systems. - You’ll collaborate more effectively. Whether leading a team or prompting an AI, you’ll benefit from speaking the language that matters most: 𝗧𝗵𝗲 𝗹𝗮𝗻𝗴𝘂𝗮𝗴𝗲 𝗼𝗳 𝗶𝗻𝘁𝗲𝗻𝘁. - By [Greg Burk](nostr:npub19jvl8q5ll78k7n3q9l86pqjwz2y2yheqwxze6wz832ph7jsc7srstr8wd2), cross-posted from [LinkedIn](https://www.linkedin.com/posts/gregburk_ai-requirements-wolffelectronicdesign-activity-7350932512094703618-TQUB?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAADIYUBB5l1IIFszVCZ6VA2UTV0S0wIcoI) #ai #requirements #WolffElectronicDesign