artisin

An all-time favorite quip from Emo Philips on How God Works[1]

[1] https://youtu.be/qegPkqs6rFw

If anything, that's an understatement.

I went down the telemetry rabbit hole a while back because I couldn't find an analytics/event log that met my needs. Nothing fancy—just a basic API to log certain events with some pretty graphs to display the data. I ended up building my own solution; however, telemetry.sh seems like it could have met my needs, but information on the site is sparse. Is this an interface for DataFusion, something akin to InfluxDB? It looks like a nice project, but some additional documentation (like you've detailed here) and use case examples on the site could go a long way.

LLMs are undeniably remarkable, but their wheels start to fall off once you go beyond the basics and a few party tricks. The cynical part of me thinks this tracks pretty well with our society's tendency to favor appearance over substance. Yet, if my burger order gets messed up, I don't fault the restaurant; however, if an LLM messes up my order, the same cannot be said. As a seasoned human, I feel confident saying that we humans love blaming other humans, whether it's justified or not.

So while I initially thought customer-facing roles would be front and center in the "AI revolution." Today, I tend to think they'll be bringing up the rear, with entertainment/smut applications at the forefront along with a few unexpected applications where LLMs operate behind the scenes.

I'll throw my hat behind this horse because, honestly, if I was just learning to code, I would have probably quit by now due to the frequency of these types of comments. LLMs have certainly improved at an impressive rate, and they're fairly decent at producing 'Lego' blocks. However, when it comes to block building—the real meat and potatoes of programming—they're, at best, bad butchers. Building functional systems is hard, and it's simply something LLMs can't do now or perhaps ever. Or I just don't know how to prompt. 50/50.

Personally, my primary concern is security and, by extension, trust. My shell environment functions as the gatekeeper to my castle, and installing this binary would be akin to blindly handing over the keys, especially since the source code is not accessible. I'm unsure if it's feasible given Hacksh's requirements, but using Flatpak could largely address your distribution issue as well as my security issue.

Here's my 2c. It's unlikely that many users, here or elsewhere, would be comfortable downloading and executing this Hacksh binary from your Dropbox, regardless of its benefits.

Well, if I could bottle up my feelings about AI hype, they'd fizz over like a can of coke.

It does lend credence to an emerging landscape trend that suggests large companies, not disruptive startups, will dominate AI development due to high costs and infrastructure needs.

Indeed, navigating keyboard internationalization is a rabbit hole within a time-sink. Luckily, in most cases, you can just plop in a library, and it works, but it's probably not that simple here. All the wtf edge cases, plus the quirks of different operating systems and hardware manufacturers—it's the stuff of nightmares.

Not necessarily, and after giving it more thought, I somewhat retract my previous comment. You do make a good point; it's explained well, but not in concrete terms without assumptions. So, I'll take a stab at it: The core idea is that async functions A and B can communicate through Chan instances, with the Select class overseeing multiple Chan operations, waiting for one to be ready before proceeding. While ts-chan might seem unnecessary for just two async functions, what if you had to manage 8, 16, 32, or more? At some point, Promise.all won't cut it, and that's where ts-chan comes to the rescue. It defines a protocol for channels to better manage communication between asynchronous functions in JS, offering a structure similar to how goroutines communicate in Go.

I somewhat disagree with this take, as I felt the intro and "The microtask queue: a footgun" [1] section in the README does an adequate job of laying out the 'why' and the problems with JS's concurrency model. However, it does presume some understanding of Go's channels, so a more explicit example contrasting ts-chan with native JS concurrency could better clarify its benefits for those less familiar. Granted, there is an /example directory, but the benchmarking complexity muddles the readability. Regardless, upon a quick run-through, it looks to be an A-grade library that seems promising for practical use, plus well-referenced, composed, and quite thorough.

[1] https://github.com/joeycumines/ts-chan#the-microtask-queue-a...

Perhaps it's time I hang up this old keyboard, rally together a ratpack of seasoned elementary school teachers, and swiftly bring an end to the Global War on Terror.

I dig the core concept, particularly since I've been searching for a more efficient alternative to opening a blank DevTools window for executing various helper scripts. With that in mind, what about introducing a "Loose Mode" option of sorts, akin to a basic js interpreter? Granted, most of the tool's interactive functionalities probably wouldn't work in this simplified mode, but it would, in turn, expand the tool's overall versatility. Enabling you to use previously written scripts and/or experiment with code (such as copying an example snippet from the README) without having to first adapt it to a functional paradigm.

Definitely a much-needed area for development. However, having gone down the browser extension rabbit hole, I've largely shifted my focus to user scripts. Granted, there will always be a need for specialized browser extensions like ad blockers (uBlock[1]), keyboard shortcuts (Vimium-C[2]), and password managers (Bitwarden[3]).

That said, I find user scripts superior for most tasks, despite some lacking UI niceties. They are easier to share, use, and crucially, audit—be it in terms of scope, permissions, or code updates. Plus if Manifest V3 is any indicator, the future for browser extensions looks bleak. While I don't agree with this direction, it's probably for the best for the majority of users, like my mom.

Your effort is commendable; however, should you find yourself looking for a viable pivot in the future, I believe the user script space is primed for innovation and could offer a good alternative.

[1] https://github.com/gorhill/uBlock [2] https://github.com/gdh1995/vimium-c [3] https://addons.mozilla.org/en-US/firefox/addon/bitwarden-pas...

Similar story, getting ArchiveBox setup and running was a breeze, but everything after that was kinda rough. For one, ArchiveBox doesn't have a proper API, so I had to rig one up with Puppeteer. And then there's YaCY. On paper, it seemed like the dream tool for indexing and making a searchable bookmark collection. But in reality, it was a whole lot of work followed by a whole lot of disappointment.

Similarly, there's SuperImage [0] on F-Droid, which uses Real-ESRGAN.

[0] https://github.com/Lucchetto/SuperImage

Unfortunately, no. At the same time, you don't need their "cloud" to use or run an instance of netdata. From what I gather, it's more or less intended to help monitor multiple instances of netdata on different machines. When I first installed netdata, I initially thought it required the use of their cloud to store historical metrics, but this is not the case. You just need to configure the dbengine, as I mentioned in my post, and you'll be good to go without their cloud.

The respectable thing to do would be to call it quits, just as they explicitly stated four days ago. The only reason their overly smug tone works in that blog post is predicated on the fact that they've made peace with this possibility. Seriously, did they really expect YouTube's legal team wouldn't seize this opportunity presented on a silver platter? Meh, this comment isn't really intended as a response. I just wanted to get rid of this bad taste in my mouth.

I went down the Grafana rabbit hole, and without a doubt, it's a fantastic tool. It can handle just about any kind of data you throw at it, and when it comes to visualizing time series data, it's second to none. That said, it's a slog to set up and configure, but once finished, I had a beautiful dashboard for my home media server, and life was good. Unfortunately, a few months later, I was forced to upgrade and lacked the time to reconfigure Grafana. So, as a stopgap, I installed Netdata... fast-forward two years, and today I still haven't reconfigured Grafana, nor do I plan to.

For my use case, a home media server, Netdata turned out to be way simpler to set up, and, most importantly, way less of a hassle/dink-around. It's a basic plug-and-play operation with auto-discovery. While the dashboard isn't nearly as beautiful or configurable, it gets the job done and provides everything I pretty much need or want. It offers a quick overview, historical metrics (over a year of data) to analyze trends or spot potential issues, and push/email notifications if something goes awry.

If you decide to go down this route, there are two major items:

1. You'll need to configure the dbengine[1] database to save and store historical metric data. However, I found the dbengine configuration documentation to be a bit confusing, so I'll spare you the trouble - just use this Jupyter Notebook[2]. If needed, adjust the input, run it, scroll down, and you'll see a summary of the number of days, the maximum dbengine size, and the yaml config, which you can copy, paste, and voila.

2. If you're hoarding data, you'll probably want to set up smartmontools/smartd[3] in a separate Docker container for better disk monitoring metrics. However, I think you can enable hddtemp[4] with Netdata through the config if you don't want or need the extra hassle. You can have Netdata to query this smartd container, but with a handful of disks, it ends up timing out frequently, so I found it's best to simply set up smartd/smartd.conf to log out the smartd data independently. Then all you need to do is tell Netdata where to find the smartd_log[5], and Netdata handles the rest.

Boom, home media server metrics with historical data, done. It still takes a bit of time to set up, but way less than Grafana. Anywho, hopefully, this saves you from wasting as much time as I did. And if you're looking for a smartd reference, shoot me a reply, and I'll tidy up and share my Docker config/scripts and notes.

[1] https://learn.netdata.cloud/docs/typical-netdata-agent-confi... [2] https://colab.research.google.com/github/andrewm4894/netdata... [3] https://www.smartmontools.org/wiki [4] https://github.com/vitlav/hddtemp [5] https://learn.netdata.cloud/docs/data-collection/storage,-mo...

I would also like to query why? I even looked through the code to check for any malicious code and came up empty handed.

I'm a big fan of "one-liners". Granted they're not always the best solution but they're hard to beat. Something like printing the disk space across filesystems:

  df -m | awk '{p+=$3}; END {print p}'

I bought a book titled "Awk One-Liners Explained" on a whim a while back. And to this day, I consider it to be umong the most "useful" $6 I've ever spent in terms of productivity.