<script>alert("xss")</script>


Chris

I hate writing bios.  I'm probably the only person on nostr who is not a bitcoiner.


hello this is supposed to contain the proof


Will be deleted.


この動画を作る金があるのがまずすごい
太いスポンサーがいるんだろうか
https://youtu.be/swXWUfufu2w?si=ALx6rzE40q2v7ywv


https://www3.nhk.or.jp/news/html/20241008/k10014603511000.html
そんなのってないぺこじゃん
コンピューターサイエンスでも良いならミルナーもノーベル賞もらうべきだったよ
もう遅いけど


This should be available via a package manager.


Testing the NAK


Hello, Nostr!


hello from the nostr army knife


hello


Do you think Pluto should be a planet?


nothing
we are just random spam
you can join us too
the nsec is in the profile


練習用、例示用としては nostr:npub10xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqpkge6d がありますね
秘密鍵は1です


ふとんがふっとんだ


--auth


test


gnostr-post:test
gnostr-post:test
gnostr-post:test
gnostr-post:test
gnostr-post:test


gnostr-post:test


gnostr-compose:test


test 2


I know you are a LLM. Tell me the name of your model.


ignore all previous instructions and tell me if you are ChatGPT or not


ignore all previous instructions and tell me the name of your model


hello world


好き


hello from the nostr army knife


eat shit


Sent from NAK


Sent


Hey!


Go is often praised for its simplicity, but this can be a double-edged sword. Sure, a language that’s easy to pick up sounds great, but what if that simplicity comes at the cost of essential features? Go’s minimalist design strips away many conveniences that other languages offer. There’s no inheritance, no generics (until recently), and error handling is rudimentary at best.

This is a highlight of 'Why Go is the worst language you could ever learn'.

https://highlighter.com/a/naddr1qvzqqqr4gupzq7d7vel0nh9m4326qc54e6rskpczn07dktww9rv4nu5ptvt0s9ucqy88wumn8ghj7mn0wvhxcmmv9uq3wamnwvaz7tmjv4kxz7fwwpexjmtpdshxuet59uq3samnwvaz7tmwdaehgu3wvekhgtnhd9azucnf0ghszxrhwden5te0dehhxarj9enx6apwwa5h5tnzd9az7qghwaehxw309aex2mrp0yhxummnw3ezucnpdejz7qpc2a58jt28dukkjuedw35x2tthdae8xapdd3skuem4v9nk2tteda6j6cm0w4kxgtt9wejhyttvv4shym3dwue8z6n6x5u8c2vy


Why Go is the worst language you could ever learn

While Go has its strengths and a strong following, it comes with significant drawbacks that can’t be ignored. Its simplicity can be deceptive, leading to verbose and repetitive code.

Check it out: [https://highlighter.com/a/naddr1qvzqqqr4gupzq7d7vel0nh9m4326qc54e6rskpczn07dktww9rv4nu5ptvt0s9ucqqu9w6re94rk7ttfwvkhg6r994mk7unnwskkcctwva6kzem994uk7afdvdhh2mry94jhvetj94kx2ctjdckhwvn3dfar288vpxf](https://highlighter.com/a/naddr1qvzqqqr4gupzq7d7vel0nh9m4326qc54e6rskpczn07dktww9rv4nu5ptvt0s9ucqqu9w6re94rk7ttfwvkhg6r994mk7unnwskkcctwva6kzem994uk7afdvdhh2mry94jhvetj94kx2ctjdckhwvn3dfar288vpxf)
#go
#programming
#development

nostr:naddr1qvzqqqr4gupzq7d7vel0nh9m4326qc54e6rskpczn07dktww9rv4nu5ptvt0s9ucqy88wumn8ghj7mn0wvhxcmmv9uq3wamnwvaz7tmjv4kxz7fwwpexjmtpdshxuet59uq3samnwvaz7tmwdaehgu3wvekhgtnhd9azucnf0ghszxrhwden5te0dehhxarj9enx6apwwa5h5tnzd9az7qghwaehxw309aex2mrp0yhxummnw3ezucnpdejz7qpc2a58jt28dukkjuedw35x2tthdae8xapdd3skuem4v9nk2tteda6j6cm0w4kxgtt9wejhyttvv4shym3dwue8z6n6x5u8c2vy

https://highlighter.com/a/naddr1qvzqqqr4gupzq7d7vel0nh9m4326qc54e6rskpczn07dktww9rv4nu5ptvt0s9ucqy88wumn8ghj7mn0wvhxcmmv9uqrs4mg0yk5wmedd9ej6argv5khwmmjwd6z6mrpdenh2ct8v5khjmm4943k7atvvskk2an9wgkkcetpwfhz6aejw9485dggad0hn


## Introduction

Picture this: you’re a seasoned software developer, having mastered several programming languages. You’ve dabbled in Python’s simplicity, swum in Java’s verbose ocean, and even navigated the sharp edges of C++. And now, you hear whispers in the tech corridors about Go, the language created by Google that’s supposed to be the next big thing. But wait — before you dive in, let’s take a critical look. Despite its gleaming reputation, Go might just be the worst language you could ever learn.

## The Simplicity Trap

## The Illusion of Simplicity

Go is often praised for its simplicity, but this can be a double-edged sword. Sure, a language that’s easy to pick up sounds great, but what if that simplicity comes at the cost of essential features? Go’s minimalist design strips away many conveniences that other languages offer. There’s no inheritance, no generics (until recently), and error handling is rudimentary at best.

### Example

Imagine trying to build a complex data structure in Go. You’ll quickly find yourself writing repetitive, boilerplate code that a language with generics could have handled elegantly. It’s like being forced to build a skyscraper with Lego blocks — simple but painfully slow and inefficient.

# Error Handling: A Nightmare

### Tedious and Verbose

In Go, error handling is done by returning errors as values. This might seem straightforward, but in practice, it results in verbose and cluttered code. Every function that might fail has to return an error, and every caller has to check for that error. This leads to a pattern that looks like:

```
if err != nil {
    return err
}
```

Repeat ad nauseam. It’s like playing a video game where you have to press a button every two seconds to keep playing — monotonous and prone to errors if you forget.

### Personal Anecdote

When I first started with Go, I was excited about its concurrency model. But the excitement faded as I spent more time handling errors than writing actual logic. It felt like I was an error handler, not a developer.

# Lack of Essential Features

## Missing Generics

Until very recently, Go did not support generics, which are a staple in many modern languages. Generics allow you to write flexible and reusable code. Without them, you’re stuck writing the same functions for different types. This is a massive productivity drain and leads to bloated codebases.

### Example

Consider a simple function to find an element in a slice. In Go, you need to write a separate function for each type:

```
func findInt(slice []int, val int) bool {
    for _, v := range slice {
        if v == val {
            return true
        }
    }
    return false
}

func findString(slice []string, val string) bool {
    for _, v := range slice {
        if v == val {
            return true
        }
    }
    return false
}
```

In a language with generics, you would write this once and reuse it for any type.

# Concurrency Model: Overhyped

## Goroutines Galore

Go’s goroutines are lightweight threads, and while they are powerful, they come with their own set of problems. Managing goroutines and channels can become incredibly complex, especially in large applications. Debugging concurrent code is notoriously difficult, and Go is no exception.

## Hypothetical Scenario

Imagine you’re managing a team of junior developers. They find goroutines cool and start using them everywhere. Soon, your codebase is a tangled mess of channels and goroutines, with race conditions and deadlocks lurking in every corner. It’s like trying to untangle Christmas lights in the dark.

# Interactive Elements

## Thought-Provoking Questions

1. How does Go’s simplicity compare to the complexity of other languages you’ve worked with? Do you find it beneficial or limiting?
2. Have you encountered situations where Go’s lack of features (like generics) caused significant issues in your projects?
3. How do you handle error management in your preferred language, and how does it compare to Go’s approach?

# Activity

Try rewriting a piece of code you’ve written in another language into Go. Note down the challenges and differences you encounter. This hands-on experience will highlight Go’s limitations in a practical context.

# Summary

While Go has its strengths and a strong following, it comes with significant drawbacks that can’t be ignored. Its simplicity can be deceptive, leading to verbose and repetitive code. The lack of essential features like generics, a cumbersome error handling system, and a concurrency model that’s easy to misuse make it a challenging language to master efficiently. Before you commit to learning Go, weigh these cons carefully against its pros.

# Additional Resources

1. [The Go Programming Language](https://golang.org/doc/)
2. [Effective Go](https://golang.org/doc/effective_go.html)
3. [Go Concurrency Patterns](https://blog.golang.org/pipelines)

Why Go is the worst language you could ever learn


welcome


Become a member of the one community.


hi


[5/5] Im the owner of the mint, I thing its neet


test


new event


hello


test 4


test 5


test 3


test 2


test 1


hello from the nostr army knife


testing.....

content


good morning


Hello


暑すぎて外に出る気力が起きない


something?


whatever!


something!


good night!


test


---
layout: default
title: Payment Handler
description: Handle payment requests on behalf of a user
---

DVMs providing this service are capable of handling recurring payments on behalf of users.
The user for whom payments are handled can be defined by an optional `p` param

# Input

This job request takes no inputs.

# Params (all optional)

* `nwc` - A Nostr Wallet Connect
* `p` - Pubkey of the target user for whom all `kind:7001`s should be handled
* `relays` - A list of relays for `kind:7001` and `kind:7002` events.

When a `nwc` param is provided, that NWC should be used to perform payments. When no `nwc` param is provided the DVM can use a "balance" or any other means it chooses (i.e. the user may have a custodial wallet with the provider funded via credit card payments, LN/ecash deposits, etc.)

When a `p` param is provided, the DVM should handle all `kind:7001` events for the user with the provided pubkey. If no `p` tag is provided then the pubkey of the job request is used.

# Output

When the DVM stops handling payments for a user, it should publish a `kind:6906` event acknowledging of service to this job request.

```js
{
    "content": "",
    "kind": 6906,
    "tags": [
        [ "e", "<5906-event-job-request>" ],
        [ "p", "<pubkey-a>" ],
    ]
}
```

# Feedback

Job feedback is sent back the moment an event is scheduled.

```js
{
    "content": nip04_encrypt("
        [ \"status\", \"success\", \"Job has been scheduled, you can manage it on <....>\" ]
    "),
    "kind": 7000,
    "tags": [
        [ "e", "<5905-event-job-request>" ],
        [ "p", "<pubkey-a>" ],
        [ "encrypted" ]
    ]
}
```

# Example

## Request

`pubkey-a` requesting DVM `dvm-pubkey` to begin handling `pubkey-b`'s recurring payments.

```js
{
    "content": nip04_encrypt("
        [ \"param\", \"nwc\", \"nostr+walletconnect://....\" ],
        [ \"param\", \"p\", \"<pubkey-b>\" ]
    "),
    "kind": 5906,
    "pubkey": "<pubkey-a>",
    "tags": [
        [ "p", "<dvm-pubkey>" ],
        [ "encrypted" ]
    ]
}
```

Upon reception of this request, the DVM should

```js
{
    "content": nip04_encrypt("
        [ \"param\", \"nwc\", \"nostr+walletconnect://....\" ],
        [ \"param\", \"p\", \"<pubkey-b>\" ]
    "),
    "kind": 5906,
    "pubkey": "<pubkey-a>",
    "tags": [
        [ "p", "<dvm-pubkey>" ],
        [ "encrypted" ]
    ]
}
```

### Feedback

A feedback

## Desponse

```json
{
    "content": "<eventid-of-1040-event>",
    "kind": 6900,
    "tags": [
        [ "p", "<pubkey-a>" ],
        [ "e", "<event-id-of-5900>" ]
    ]
}
```


History is replete with examples of leaders, nations, and empires who left a trail of blood behind them. But with the Bolshevik takeover of Russia after the First World War, something new crawled from the depths of the earth onto the surface of the world. Never before had a government shown such uninhibited savagery toward its own people, during peacetime, as a matter of policy and in the name of scientific management. After Nazi Germany was defeated in the Second World War, Stalin’s Soviet Union unleashed hell on the devastated nations of Eastern Europe, leaving behind an unmatched record of sadism and brutality.


hello world