kenOfYugen

TL;DR The Unhook browser extentions makes YouTube usable.

Searching for something on YouTube does not work as expected at all. At some point they started deleting older videos with not that many views, and I remember at one time that I tried to access a video through a bookmark because it would not appear in the search results, that I was asked to state if this video should be removed or kept.

It didn't get deleted thankfully, however I could not find it easily again via the search results because of all the crap recommendations.

What I have found that makes the search work again is the Unhook extension [1,2]. By applying a few tweaks, YouTube has become usable again, as it removes most of the unrelated recommendations.

As mentioned in other comments, uBlock Origin and SponsorBlock are a requirement if one values their time. There are more efficient ways to support creators instead of watching random annoying ads and sponsor segments.

1. https://addons.mozilla.org/en-US/firefox/addon/youtube-recom... 2. https://chrome.google.com/webstore/detail/unhook-remove-yout...

I rarely see this mentioned, but you don't have to compress hydrogen that much for transportation/storage. Ongoing research on metal hydrides is promising [1].

1. https://en.wikipedia.org/wiki/Hydrogen_storage#Metal_hydride...

I ended up writing a small wrapper on top of SQLite based on this: https://dgl.cx/2020/06/sqlite-json-support

With proper concurrency control, it can work very well even for multi process applications.

According to dosdude1's thread on macrumors.com[1], more devices will eventually become compatible and wifi will get patched.

1. https://forums.macrumors.com/threads/macos-11-big-sur-on-uns...

> I am incredibly happy with every update from Apple.

I am incredibly disappointed with every update from Apple.

I bought my MacBook Pro in 2011. The most basic 13.3" machine that was available for sale. 320GB 5400RPM HDD, i5, 4GB RAM, Intel graphics.

I like backups. The optical drive had to go, I put it in an external USB enclosure. It was replaced by the HDD and in its place I put a Samsung SSD. The HDD contains my data archives and a macOS installation image.

Whenever macOS would become cluttered, I would wipe the SSD and enjoy a fresh macOS installation. Whenever a new macOS version would be released, I would update the installation image.

This enabled me to work on the go with no fear of data loss and no network dependencies.

SSDs are basically long lasting consumables. I had to painlessly replace the drive twice, however each time I got a faster and more robust unit with enhanced capacity. Sure I can carry an external drive with me. I have no desire at all to do that.

I like the mini jack, so that I can plug my favorite headphones. The audio-out port also doubles as an optical-out. Sure I can carry a couple of dongles with me. I have no desire at all to do that.

Sure I could have bought the top of the line 8GB RAM model back in 2011. I had no desire at all to do that. I could just buy 16GB of RAM and perform an upgrade Apple claims is not supported.

The battery lasts long enough. While coding, I get drained before the battery does. I can let the battery age with no fear of it bulging because it's contained in a shell. Replacement is easy.

I totally get where you are coming from, and agree with you that "a tiny fraction of users" want access to the hardware. However 100% would want access to the hardware when their 16" MacBook Pro SSD goes.

Don't professionals require machines that cater for their needs? If the current Apple offered choices like the ones I mentioned above, would you not pay a premium to have them?

I certainly would. And for that reason I still rely the same 2011 MacBook Pro and not the latest MacBook GoodEnough.

Mean Piston Speed [1] is a good indicator of engine longevity.

~16 m/s for automobile engines

~25 m/s for Formula one engines

~26.5 m/s for Koenigsegg’s 2.0-Liter

[1] https://en.wikipedia.org/wiki/Mean_piston_speed

I can't say I fully comprehend the SSR vs SPA war. Both concepts are definitely being misused/overused, one is "dated" and the other "modern", but surely the middle ground where best usage of both can be attained is prefered. I don't know of any terms that mediate the opposition other than perhaps "hydration"?

I am using an even more minimal subset of CoffeeScript 2, basically classless, and love it. I can't find a sane reason to hand-write ESxx.

I complement it with Rust as needed, which is the only language that justifies having a verbose syntax.

Those two couldn't be farther apart, but their combination covers an extremely wide spectrum of programming tasks. From prototyping, to incrementally improving the robustness and performance as needed.

jashkenas did a great job, and CS2 is a very elegant and ongoing effort.

What do you mean by 'first class support' of WASM in C/C++? Is it somehow possible to produce wasm binaries without utilizing emscripten?

I like this approach a lot, especially as implemented in [1].

Perhaps a tutorial, or some examples can be documented in that style. Hyperapp + hyperscript-helpers[2] is my favorite combo at the moment.

1. http://dave.kinkead.com.au/modelling-the-boundary-problem/

2. https://github.com/ohanhi/hyperscript-helpers

They had to, since changes cannot break backwards compatibility with the legacy web.

> The javascript language has advanced considerably. Not only has it adopted many of the syntax sugar features such as classes and fat arrow function, it has gone beyond coffeescript with features such as async/await and object spread properties.

Just like CoffeeScript's good parts got into JavaScript, JavaScript's new features are being merged into CoffeeScript. 'async/await' becomes just an elegant 'await' in CS and pure generators are just functions that yield, without special annotations (i.e function*()).

CoffeeScript is nearing its 2.0 release [1]. So the language is not "dead", and there is still room for "innovation" repeating the cycle anew.

1. https://github.com/coffeescript6/discuss/issues/71

Haven't tested it yet, but OpenWebRTC [1] has been on my radar for some time now.

1. https://github.com/EricssonResearch/openwebrtc

What modifications are required to be made to the linux kernel/tcp stack to take advantage of 48+ cores, in order to achieve a more linear scalability?

Are there any real-life experiences? Would a different TCP stack such as mTCP[1] suffice?

1. http://shader.kaist.edu/mtcp/

Same here. New battery, new secondary SSD, reconditioning of the MagSafe power supply and maxed out RAM are underway. Performance-wise it should be about the same as the latest Macbook, which doesn't feel like an upgrade for software development.

Slow hardware helps one write good software after-all..

I can relate. Since I setup a Linux desktop PC running Arch & bspwm, I feel less productive in macOS. The only other desktop UX tool I use is dmenu.

It feels like when I first moved from Windows to OS X. Makes sense, since back then OS X felt minimal compared to Windows, and a bare tiling manager over Linux is the ultimate minimalism.

I believe something along the lines of runtime.js [1] is implied.

The timeline suggests a reference to Gary Bernhardt's talk, "The Birth & Death of JavaScript" [2].

1. http://runtimejs.org/

2. https://www.destroyallsoftware.com/talks/the-birth-and-death...

I like to have a simple personal 'benchmark' when learning new languages. One of the first programs I try to implement whenever a new language comes along is a filesystem walker.

It combines enough concepts that allow me to quickly evaluate the syntax and some core principles of a language. I rarely end up writing the same thing, which is rather impressive and sometimes even enlightening.

Mozilla should just adopt the adorable libuv unirex[1][2] along with the project.

I have been following their identity redesign story from the beginning, and to be honest, all their designs are very generic and vague. Too complex to be called minimal, too dull to be called interesting. When polling they should just include an option like "I would like to see a different design".

1. http://docs.libuv.org/en/v1.x/_static/logo.png 2. http://libuv.org/images/libuv-bg.png

Seems like a good enough prototyping kit for open source hardware. I wonder why the 'no-price-scaling' per unit for bulk orders is considered a feature though.

What about Vuvuzela? Haven't thoroughly examined it, but it focuses on metadata-privary and -relative- scalability.

web: https://vuvuzela.io/

repo: https://github.com/davidlazar/vuvuzela

paper: https://davidlazar.org/papers/vuvuzela.pdf

slides: https://davidlazar.org/slides/vuvuzela-sosp2015.pdf

Does any method of converting the store image to a bootable disk, like the previous versions, exist? Anybody tried it?

I prefer testing major upgrades as clean installs.

EDIT: createinstallmedia method is reported to be working. Haven't tried it yet myself.

An inspirational side-project.

> I want to get a DNS fuzzer running against it to really pound on it, and then get some benchmark and comparison tests against other servers.

Even if the benchmarks turn out to be not in favor of Trust-DNS, the added safety overhead (if any) should be worth it.

> (I’ll try to post more regularly on progress)

Please do. I thoroughly enjoyed the content as well as the writing style!

crate-type = ["cdylib"] sounds really interesting!

"With this PR a "hello world" cdylib is 7.2K while the same dylib is 2.4MB, which is some nice size savings!" [1]

1. https://github.com/rust-lang/rust/pull/33553#issue-154141126

I really like how the parser is implemented [1]. Very straightforward and readable even to a Rust amateur like I am.

Are there any more open source languages of similar nature, using Rust?

1. https://github.com/Marwes/gluon/tree/master/parser/src

I am a fan of the literate programming style for personal projects.

For a very well executed and interactive example check out

http://dave.kinkead.com.au/modelling-the-boundary-problem/

Presentation at EnterpriseJS Austin:

Spacesuits and Node.js - How open source will change NASA

https://vimeo.com/168064722

James Long is currently playing with call/cc in JavaScript [1].

He mentioned a paper titled "Exceptional Continuations in JavaScript" [2], that describes the method he used in his implementation.

Maybe you should get in touch?

[1] https://twitter.com/jlongster/status/726259468405751808

[2] http://www.schemeworkshop.org/2007/procPaper4.pdf

> Generators are JavaScript's programmable semicolons. Lets not take away that power by taking away the programmability. Lets drop async/await and write our own interpreters.

One of "our own interpreters" (i.e not standard in JS), that I am very fond of, is js-csp [1]. It's a replica of Clojure(Script)'s core.async, or Go's channels/goroutines. It uses ES6 generator functions underneath.

James Long has written an excellent post about it [2]. I find it to be the less taxing on the mind solution for coordinating complex asynchronous processes in JS, especially when paired with transducers [3]. Furthermore, powerful Go/Clojure patterns can easily be re-used in JS.

In conjunction with CoffeeScript, the code becomes elegant and straightforward since there is no 'function*' ugliness required.

That's the least complex solution I have found to like the most. Performance and memory usage suffer a bit, but it's very straightforward to optimize if/when needed.

[1] https://github.com/ubolonton/js-csp

[2] http://jlongster.com/Taming-the-Asynchronous-Beast-with-CSP-...

[3] http://jlongster.com/Transducers.js--A-JavaScript-Library-fo...

Because the link I posted provides some less formal intro and commentary, no other reason.