Many crypto-anarchists have used the New Testament as a reference because anarchy needs a solid moral foundation; without that solid moral foundation, it is impossible to build a free society.

There is no moral foundation in history as solid as the teachings of Jesus.

I just learnt about polymarket recently, it's banned in Australia, and I'm not a fan of gambling in general, but P2P gambling based on predictions on real world events seems interesting.

People say the same thing about Linus, but the core people have guided Bitcoin to this point just as Linus has remained the benevolent dictator of Linux. “Social consensus” is basically you saying that code decisions should be made based on the number of people on subreddits you can get agreeing with you. This is not how sane development processes work. I’ve heard this kind of rhetoric before from Bcashers. They relentlessly said this shit for years to demand Core people implement suicidal policies that would have destroyed the decentralized nature of #Bitcoin. Bcashers also attempted to hijack control of the Bitcoin network by convincing people that they could “vote” by controlling more nodes (wrong, Bitcoin is defined by what chain has done the most proof of work). So the way #knots is operating is both rhetorically *and* operationally familiar.

#core developers, much like Linus, dealt enough with people offering “helpful suggestions”, absolutely moronic or intentionally malicious and subversive code submissions, and the armies of commenters thinking they know better than the people who have been around since the beginning. Back in the days of Bcash, they for a long time showed endless patience carefully explaining hunderds of times their decision making process. Eventually they tired of it and adopted the current and correct attitude towards people who think they know better.

As a fellow engineer, is this how you operate as a CTO? You cannot accept that your well founded engineering decision may be wrong?

Just curious, is there any dissenting opinion around you, or is it silenced, or simply ignored?

How are you legally protected from receiving the same data you're trying to filter, in blocks?

I like dangling my son upside down by the ankles. He usually quite enjoys it.

"If core 30 is released then someone will put CSAM on it and bitcoin will cease to exist."

Completely retarded.

yeah, i get it the points about how some things are irritating.

and i run into problems now and then, fairly often, with resource leaks.

a lot of people overuse interfaces, i agree about that. interfaces should be an after thought that makes extension simpler. until there is two viable implementations you should not make an interface out of it. it's just a waste of space and if you never need any more than one implementation of a method set then it's crazy to throw all that overhead into accessing the methods (resolving the indirection).

i sorta do sometimes wish there was an explicit keyword that manually designates a variable to be unused - nilling variables and using sync.Pool to mitigate this doesn't really quite work, and having no control over freeing the memory for especially tight, iterative stuff, can sometimes be quite an obstacle to getting it to not blow up the heap. but aside from that one little thing, which could even be a second reuse of the delete keyword (where it doesn't expect a key) and its function would be to explicitly discard the variable.

running into these invisible, opaque memory allocation behaviours most of the time you don't even have to think about it but when the heap piles up with junk and it isn't seen until the next mark/sweep it can make a situation where your baseline memory requirements are reasonable but frequently it uses 2-3x as much memory for short periods - yeah, if that baseline was 500mb and you try to run it on a 1gb VPS it will often OOM die and restart the service.

or maybe better would just be an explicit "free" operator. probably could cobble something together with a specific package that does all that unsafe and reflecty stuff, and alias the import to the package (i use this with logging so it doesn't have a cumbersome, long path to access the logger, just creates local variables referring to the main variables).

i don't really mind the for syntax of Go. making quick and dirty ascending count with `for range ` is often very handy, and it's generally idiomatic most DB transaction interfaces provide the initializer, test and iterate clauses of the for loop in trad C style syntax. also i think it's quite handy being able to use for by itself to create a single channel select statement, effectively.

anyway, as regards to the channels and goroutines, the absence of keywords and meaningful symbols to make usage compact and clear, instead of wrapping it all in methods... i like my <- -> stuff

also, as regards to using goroutines, i generally just try to stick to a 1 client 1 thread pattern. i've seen code that needlessly makes everything in a database query method concurrent, but a) it can't guarantee ordered delivery (this is implicit in the query contract of the REQ method of the API, though most clients just sort it again anyway, khatru and the eventsore based KV store databases that fiatjaf made... spawn like 5-10 concurrent threads for no reason to interact with a bottlenecked back end that can't do more than actually one read or write at a time anyway (the LSM logs). IMO, part of the edge of performance that #orly has over khatru is precisely that the database queries have zero goroutine overhead. goroutines are cheap but people are so easily seduced into peppering their code with `go` just because woo cool concurrency when it doesn't fit the purpose...

the other thing about concurrency, is that it really should be avoided as much as possible. go's work stealing scheduler is better now but there is not a 1:1 correspondence between the behaviour of a coroutine and a kernel thread, as regards to parallelism. threads are parallel. coroutines are not quite parallel. 6 years ago the difference was about 20%, it's probably more like 10% now with the many improvements since go 1.20.

anyhow, i'm not getting off the Go train without someone actually not focusing on the things i don't care about. i don't care about memory mutability, much more important is the ability to control the memory for such as storage of secrets. i don't care so much about not being able to explicitly free memory, but it's unquestionable for high performance servers there's almost always a glitch where the GC is either blowing up the heap or pushing latency up at the wrong time.

in order of motivations, these are why I am a golang maxi:

- fast compilation

- (because) no fucking inheritance

- simple language, consistent pretty printing format

- first class coroutines and channels

- package/module build system and modules caches make builds even faster after the first time, it's mere seconds most of the time to restart, almost makes hot-reload not so beneficial (most web apps are 5-15 seconds before they are fully started), when i can just restart my server with ctrl-c, up arrow, enter. 4 keypresses and one mouse move and click.

- last but not least, hipsters hate it, which means they won't waste their time trying to contribute to my projects (the Linus Torvalds Reason For C) - people who like C/C++, Rust and Java who think all that manual memory management is worth the cost for the pissy 5% boost in performance - i don't want to work with them, and being stubborn about sticking with Go most of the time keeps me out of such situations.

in order of irritation, the things that i don't like about Go:

- very poor support for GUI app dev

- lack of a manual memory free operator

- the broken semantics of slice/map types mutating themselves (and all the stars and ampersands and brackets) - imo they should BEHAVE like pointers for this case, and in general there is a bit of a nebulous cloud about which version of such reference types, which are essentially pointers but get value treatment. if it just kept the nice implicit dereference semantics but made mutations to the receiver happen outside of the scope of a method. meh. i just use struct tho

After spending 10 years thinking about Money & Bitcoin, here's the simplest explanation I can come up with:

Money is a technology to move Value across Space, Time, and Scale.

Value is the utility humans derive from Goods & Services.

Value is highly subjective, and it changes across Time and Space.

Unbeknownst to them, Economists have defined these functions as:

- Store of Value (Time)

- Medium of Exchange (Space)

- Unit of Account (Scale)

Throughout History, no monetary system has managed to satisfy all 3 functions of Money at once. This is where the idea of Backing Money and the necessity of separating Money and Currency come from.

This trade-off can be described as a Money Trilemma: you can optimize for 2, but not all 3.

Gold is great at Time & Scale, but not Space.

Fiat is great at Space & Scale, but not Time.

Until the invention of Bitcoin.

Bitcoin is the first form of Money that successfully excels at all 3 functions simultaneously.

It achieves that by perfecting all the properties of hashtag#Money, with no extra room for improvement:

#Bitcoin is:

- Infinitely Divisible

- Instantly Portable

- Forever Durable

- Mathematically Finite (what is mistakenly called Scarcity)

- Perfectly Fungible

Bitcoin is the final Evolution of Money.

The World just hasn’t figured it out yet.

all i know is that to be able to read Go, i don't need to know as many things to read almost every other language (stuff like BASIC and assembler are simpler).

there's no way this doesn't impact the precision of the LLM at finding the right answer in any given equal case easier if the language grammar is less complex and has less reserved words and operators.

the reason why i like Go is because it doesn't pile a ton of opinionated shit on top of the language like most languages do, and keep piling more opinionated shit on top before you know it it's a 10-30 minute build on an average sized project. Go manages this from scratch, with a totally clean environment in 45 seconds including pulling all the stuff, there's no way the LLM has to work as hard.

it's just about context. the language grammer costs context in the LLM processing. more context = more memory that has to be traversed. similarly, the more places you have to look to find different things, the longer it takes for the LLM to find the target to implement on. i'd be willing to bet the energy cost of translating simpler human languages versus more complex one applies exactly the same. German, russian, and most of central/northern slavic languages have complex grammar compared to, for example, bulgarian. bulgarian removes cases, more or less completely, and shifts the complexity over to verb tenses. for similar reasons, languages that make better use of modifier suffixes and eliminate ambiguity of persons of verbs (which is characteristic of eastern european languages) can be literally more verbose but with a more naive and less complex interpretation required because it has mulitple markers on almost everything, persons, tense and so forth. english, for example, like bulgarian, extensively uses prepositions a lot where cases might express the same context - same result, the verbosity is slightly increased, but the ambiguity of any phrase of the sentence is lower, meaning less context must be searched to find the relevant grammar tree.

out of different language groups, there are also more and less complex variants - danish is one of the simplest to learn nordic languages.

the unseen economic cost of clumsy and complex languages is one of my personal obsessions. people just don't realise how much less capacity to reason they have left after considering the context required to parse the language. more rules = more context.

precisely the same reason why Go compiles so much faster, is why the LLM is more stable at producing effective results, because it can encompass more non-central context of the data. every text comes with a burden of complexity, and the more complex the core of the language, the less space you can use to deal with specifics.

i have so far found that typescript/react projects are the slowest to progress, Go is definitely the fastest, and for UI, svelte is definitely simpler to reason about too.

LLM credits are not cheap, damn.

languages with lower complexity, like #golang have an edge over complex languages like #rust #c #c++ #javascript #typescript even when you are vibe coding because the LLM doesn't have to work as hard to interpret the code correctly. you end up using a lot more LLM credits to do things that the design and architecture of the language also makes more complex.

complexity is the devil in engineering. all else being equal, the simplest implementation is more likely to not just be simpler to build, but also more reliable and performant.

LLM coding agents concretely demonstrate this by how much work they have to do to parse the language. shitty complex language = expensive LLM bill.

Can someone explain why everyone is posting pics saying this is my politics?

If developers and users have a values conflict, one or the other will change or be replaced. Long-term this is the equilibrium we will head towards.

She didn't say anything bad. The idea is that ALL transactions can be subjectively judged, and there will always be txns people don't like. We have NO WAY to know how people are using txns, or even how they value those txns. All txns are "NFTs" and none are explicitly more "money" than the others.

This orients the conversation correctly, away from policy discussion, toward protocol discussion, forcing opponents to properly propose REAL solutions for data on Bitcoin, instead of handwaving policy drama that fixes nothing.

Currently, this is mostly a culture war over default settings in an app.

the thing that bugs me about the various sects of vegan/vegetarianism is they are all based on this assumption that all human action harms all life.

this is such a self destructive foundation for a personality.

it's like the absolute zero of human ambition, you can't get much more self loathing than to believe that by dint of what you are, makes you evil.

all brainwashing systems work by sabotaging the sense of self. the constant bombardment of guilt tripping on people about their trash and how much energy they use is all about inculcating them to an ongoing reduction of reasonable standards until they are full slave status.

when people don't philosophically analyze what they believe, they don't have any way of correcting for when their head gets full of nonsense from some psyop and off they go and kill people and shit.

ultimately you are only responsible for yourself. don't allow a constant dripping nag of self deprecation wear out your inner divinity.

One reason they don't want you to use cash, Bitcoin, silver, or gold is because then they don't get to control it, the banks or the government.

Even just having cash on hand makes you safer in the event a bank shutdown, hack or anything happened, because to take it they have to physically take it.

Hate is one of the most toxic emotions - it consumes more of the hater than the hated.

Living with hate poisons the mind, distorts perception and traps a person in cycles of anger and bitterness.

The more you hold onto it, the more it drains your peace and your health, leaving little space for joy, love or growth. #nostr #psychology #coffeechain

Bitcoin is either censorship resistant or not. Can’t know until there is a good reason to attempt censorship. Apparently the CSAM that has been in the chain since forever isn’t enough of a test, I guess.

if most nodes upgrade to core 30, and csam penetrates the blockchain, then csam will be preserved on knots. am i right?

You should try my #LightningKoffee ⚡️☕️ one day.

Free shipping in the USA🇺🇸🤠

💯% Colombian Specialty Coffee 🇨🇴