Rusty Russell

Linux developer Rusty Russell wrote a helpful article about designing C libraries to be easily configured and reused: "On C Library Implementation": http://rusty.ozlabs.org/?p=140 For such an important subject, there is little practical discussion or good examples of library design. Compare the number of books about C++ object-oriented design versus the design and packaging of C/C++ libraries. The best reference I know is John Lakos's excellent (but ancient: 1996!) book on the subject: "Large-Scale C++ Design." Here are some excerpts from the book. http://blog.codeimproved.net/2009/03/the-large-scale-c-software-design… http://www.cs.unc.edu/~stotts/COMP204/lakos/

Rusty Russell summarized this nicely a few years ago: http://rusty.ozlabs.org/?p=236 (careful, sarcasm follows). The merge does involve some loss of flexibility (for instance, "traditionally", you could use the programs in /bin to recover a failing system), but there are fewer and fewer users relying on it. It also involves departing from the FHS, but Debian already does that (e.g. they use /lib/<GNU triplet> rather than /lib{32,64}). I haven't heard any super convincing arguments from either side; normally, I'd go by the "not broken -- nothing to fix" route, but it's also hard to poke holes in the "this additional complexity isn't needed anymore" line of reasoning. Plus, like most arguments that involve tradition, it's pretty hard to tell robustness from cruft. Whether this change can be done cleanly and without breaking users' systems is an entirely different story and past experience has shown that moderation is a far better friend than optimism. It's particularly difficult to migrate existing installation to this scheme (e.g. Arch failed quite badly, as I remember from those particular two afternoons, thanks a lot Arch!, and it didn't go more smoothly for others, either), but Debian can benefit from the lessons learned by more up-to-da^H^H^H^H fast-moving distributions and do things better.

(2013) Though I responded in 2012, so it may be older (the log on the site says 2013 though). FWIW, my response, as FHS editor: https://rusty.ozlabs.org/?p=236

Out of curiosity, can you point me to the prior research that you mention? Aside from a couple of blogs, notably [1], I haven't seen much formal research, much less anything showing bounds on supportability. [1] https://rusty.ozlabs.org

Basically, the current block size limit of 1MB isn't sufficient for the current volume of transactions. Some transactions aren't making it into blocks in real-time and have to sit waiting in a queue to be processed. This leads to delays in processing commercial payments, which in turn threatens Bitcoin's viability as a mainstream currency. Some people argue the issue could be easily fixed by simply raising the block size limit, but others disagree and believe that would become too costly in bandwidth and processing capacity for miners, so AFAIK there's still no consensus on a resolution. A couple other good explanations: http://rusty.ozlabs.org/?p=535 https://medium.com/@octskyward/the-resolution-of-the-bitcoin-experimen…

Probably this guy, because he curates ccan: http://rusty.ozlabs.org

Since it's under the AGPL it will mostly be built by people that have been vetted. By switching to this people are one step closer to having a machine that boots without assholes. http://rusty.ozlabs.org/?p=196

Two articles benchmarking Judy arrays compared to hash tables: http://rusty.ozlabs.org/?p=153 http://www.nothings.org/computer/judy/

Rusty Russell had a slightly tongue-in-cheek rant about such things recently, http://rusty.ozlabs.org/?p=140 There's a bunch more recent articles on his blog covering similar topics

Perhaps you didn't read all of it? Anyway, the person mentioned in this subthread did reply in a comment on the original post. (http://rusty.ozlabs.org/?p=196#comment-721)

http://feedblog.org/2008/10/12/google-bigtable-compression-zippy-and-b… There's also an interesting discussion at: http://rusty.ozlabs.org/?p=81 You can get better compression by organizing your data such that similar data falls within the compression window, or if you can't reorganize data you can build a custom compressor that specifically looks at older versions of a page for matches (I guess that's like git).

On the contrary, the network worked as expected. A somewhat costly stress test resulting in a backlog of transactions that were prioritized by fee, just as predicted. The backlog has since been drastically reduced and high priority fees are back in the 50,000 satoshi per kb range [0]... the average Bitcoin transaction is about 250 bytes, so 12,000 satoshi per transaction, or roughly 3 cents. Low priority transactions of < 1 cent are still somewhat easily confirmed [1]. Even during the stress test I saw high priority fees hovering around the 85,000 satoshi/byte range, and never in the 1,000,000+ satoshi/byte range that you're talking about. What's impressive is that the price [2] of Bitcoin was completely unaffected by a bit of weather [3] on the network and in fact gained in value during the entire ordeal. Public data storage like the ledger maintained by the Bitcoin blockchain has a definite cost and it makes sense that prices would rise as demand increased. The blockchain is a scarce resource. It might make sense for transactions fees to end up around the price of a postage stamp at some point. It's hard to predict how this economic system will continue to evolve. What's most important is that the ledger continues to be maintained, eventually consistent, secured by lots of hashing power, 100% verifiable and has an open and equal access to read and write as it ever did. Not every transaction between two parties needs to be recorded on the blockchain. The blockchain is…

Citing kernel code is not a good argument without actually understanding why they're using linked lists, when they are used and how many of them are used at a time, etc, etc. Most of those linked lists are not really relevant. Because (1) they are far too few of them (2) they do not occur in areas where performance is significantly impacted. Besides which.. the kernel is a single instance program. Its not like there are 1,000 different kernels running simultaneously. So.. if you want to write a web server/service that can serve tens of thousands of requests - Write it both ways and see for yourself. Its obvious that linked lists are a performance drag. Although they have much in common with other forced indirection penalties (virtual functions, etc) Edit: ah, found a nice post that has analyzed just this. http://rusty.ozlabs.org/?p=168 Look at the performance profile here. Using linked lists is the right choice because of the way they are used...

The OP should try with -march=native so the compiler can use vector instructions. Slightly off-topic but I like this way to test if memory is all zeroes: https://rusty.ozlabs.org/2015/10/20/ccanmems-memeqzero-iteration.html (see "epiphany #2" at the bottom of the page) I really wish there was a standard libc function for it.

Let's balance the discussion out a bit: Greg Maxwell's thoughts (small blocks): http://sourceforge.net/p/bitcoin/mailman/message/34090559/ About internet bandwidth growth (~neutral): http://rusty.ozlabs.org/?p=493 An attempt at a well-rounded overview (~neutral): http://rusty.ozlabs.org/?p=535 some thoughts by bittorrent creator Bram Cohen (small blocks): https://medium.com/@bramcohen/bitcoin-s-ironic-crisis-32226a85e39f Some thoughts by gavin andresen (large blocks): http://gavinandresen.ninja/