cloudkj

Heh, I just wrote something very similar - bash, curl, and jq scripts that wrap local Ollama calls to produce a REPL/agent: https://github.com/cloudkj/llayer

Seems like the core idea is the same, but I took it farther down the Unix philosophy line of thinking and tried to make the individual components small and composable.

Feel free to check it out and compare!

This is great, I was just hoping to find a tool like this and specifically scoped to "Show HN" posts? Is there a way to do that?

Some of my recent projects in case anyone finds them useful and/or interesting:

Automatic differentiation library in Clojure (https://github.com/cloudkj/lambda-autodiff) - inspired by Karpathy's `micrograd` from a few years ago; dusted it off recently, fixed a few issues, and was able to use it to implement a version of `microgpt` - https://cloudkj.github.io/lambda-autodiff/doc/examples/gpt/

PG&E "Share My Data" self-access library (https://github.com/cloudkj/pgesmd_self_access) - been tinkering with various home automation and monitoring ideas, and was able to get an end-to-end prototype for ingesting and visualizing PG&E meter data using a combination of the (forked) aforementioned library, an old circa 2015 Raspberry Pi, and a handful of dollars spent on AWS services (certificate manager, load balancer) to get the full mTLS PG&E integration working. Probably deserves a blog post to document all the gory details.

Geo data mashups (https://github.com/cloudkj/snowpack) - small frontend utilities to overlay custom data on top of each other; was able to satisfy two recent personal use cases: (1) visualize snow depth across California ski destinations and (2) heat map of national park traffic by entrance. Previously posted at https://news.ycombinator.com/item?id=46649103

REST interface for Gymnasium reinforcement learning (fka OpenAI Gym) (https://github.com/cloudkj/gymnasium-http-api) - simple wrapper around the forked version of OpenAI Gym to allow for language-agnostic development of RL algorithms.

Just curious - how long have you been running the site and how sustainable of a model you feel it is? Sustainable in the sense that the affiliate or ad revenue it brings in is consistent enough to justify continued maintenance, improvement, etc.

I'm also interested in starting up something similar for a particular niche, and would like to hear first hand accounts of the return on investment for aggregators such as these.

+1 my thoughts as well. He's been a stellar QA, stress testing various facets of government, politics, and media.

I worked on a project with similar motivations; in my case, I had a list of criteria in mind, one of which was the number of syllables in a name. I couldn't find a good source for name syllabification, so built an n-gram language model trained on the CMUdict corpus.

https://github.com/cloudkj/ngram-syllables

Just saw some of the references to RTL-SDR in the thread comments and started down the rabbit hole, and it looks like a fascinating area for hobbyists.

Can you provide some links to temperature sensors you've tried that work well with an RTL-SDR receiver? I'm also interested in setting something up with a Raspberry Pi.

I'm at https://www.kelvinjiang.com/

Mostly a small collection of posts about programming and personal finance. Also been running for around fifteen years.

Most popular post is about currency arbitrage, which seems to have had a small resurgence in interest as of late from various crypto folks: https://www.kelvinjiang.com/2010/10/currency-arbitrage-in-99...

Side note: not sure if it's just a funny coincidence, but it seems like a good number of folks here have been running their sites for around fifteen years. Perhaps the timing just happens to match the typical career arc of software professionals, or maybe it was due to the popularity of blogging fifteen years ago.

Indeed. Fishing knot strength is always a hot topic of debate, particularly during the slower, off-season winter months when everyone's hunkering down and doing tackle maintenance. Here's a pretty good breakdown of the line breaking strength of various fishing knots across monofilament, fluorocarbon, and braided line: https://www.knotsforfishing.com/knot-strength-chart/

I personally prefer the Palomar Knot as it is probably the strongest knot that is also easy to tie. The Improved Clinch Knot and its brethren are also handy to know since there are so many variants that have high breaking strength; I typically teach the Improved Clinch Knot to folks new to fishing.

Coincidentally, I just wrote a simple JSON parser the other day as a toy exercise. A simplified snippet of parsing code (handling only arrays) relevant to the discussion here would be something like:

  def parse(text):
      stack = []
      index = 0
      result = None
      while index < len(text):
          char = text[index]
          val = None
          if char == '[':
              stack.append([])
          elif char == ']':
              val = stack.pop()
          index += 1
          if val is not None:
              if stack:
                  stack[-1].append(val)
              else:
                  result = val
      return result

Using the test utilities in the repo indicate that the parsing logic can handle arbitrarily nested arrays (e.g. up to the 5,000,000 max in the test script), bound by the limits of the heap.

It seems like the main criticism here is against recursive implementations. Or am I missing something?

Wow, that is a fun coincidence! Indeed, I was going for a catchy four-letter acronym in the same vein as popular stacks like LAMP or MEAN. Perhaps the fact that we both landed on the same components and permutation of components means that there's something there :)

I also started off in the same manner of implementation - bash scripts wrapping AWS CLI calls - then stumbled upon the more straightforward, template based approach.

I was actually wondering that myself: Is there interest in a hosted service? It'd be quite similar to (as many comments have suggested) Netlify and the one you linked to.

I was mostly going for a DIY solution since I wanted to "own" the bits being deployed while remaining as close to the infrastructure as possible. Providing a hosted service somewhat moves away from the DIY spirit; I suppose additional tools/UIs could be offered to simplify setup and deployment and still run everything directly on AWS, but at that point one might be inclined to just move to one of the other hosted solutions for the simplicity.

The AWS CloudFormation console has a "Designer" tool that allows drag-and-drop creation of template files, and also visualizes existing JSON or YAML template files with these diagrams.

That should indeed be the default behavior out of the box with the way the S3 buckets are configured. I have a couple Jekyll sites deployed this way, and a request to the parent directory does get served by the contents in `index.html`. Are you not seeing that behavior?

I'd definitely like to add more variants of the default stack. At the minimum, I'm sure there are folks that prefer `www` redirects to the apex domain, or removing the `www` subdomain altogether.

I think the complexity for this setup is about the same. Once the different AWS services are provisioned during the initial setup, subsequent deploys are quite straightforward. For example, I have a three-line Makefile target for Jekyll sites that looks something like this (using Docker with a local `aws-cli` image wrapping the CLI):

    docker run --rm -e "JEKYLL_ENV=production" -v $(PWD)/src:/srv/jekyll -it jekyll/jekyll:3.8.5 jekyll build
    docker run --rm -itv $(HOME)/.aws:/root/.aws aws-cli aws s3 sync src/_site s3://www.<mydomain>
    docker run --rm -itv $(HOME)/.aws:/root/.aws aws-cli aws cloudfront create-invalidation --distribution-id <mydistribution> --paths "/*"

It costs at least $0.50/month but probably not much more than that for most small to medium sites.

The $0.50 is the monthly cost of the Route 53 hosted zone; the CloudFront and S3 costs typically amount to pennies, but of course it depends on traffic.

Author here; thanks for the feedback. The path to Scheme was a bit haphazard - I got into Clojure a few years ago after exposure to some nice Clojure-based tools at work, and then worked on implementing several classical machine learning techniques in Clojure for fun.

When I came up with the idea of chaining and piping neural network layers on the command line, I also came across CHICKEN Scheme which promised to be portable and well-suited for translating the Clojure-based implementation I had previously done. As you can probably imagine, the porting process was a lot more involved than I expected, but nevertheless I had a BLASt (pun intended) hacking on it.

That sounds like a fun and useful follow up. My initial thoughts would be to do some unsupervised topic modeling with LDA. Happy to consider other suggestions.

Thanks for the suggestion. I added a link for 2019, and the style for the active year is now bolded. I didn't want to deviate too much from the default color scheme of the theme I'm using, but that may change in the future.

Thanks for the suggestion. I went ahead and made the change to link the score to the original discussion. It will take a few moments for the CDNs to propagate the changes.

One caveat is that some stories have multiple submissions; I just linked to the one with the highest score for now, but will need to iterate a bit to better handle multiple submissions.

I think that defeats the purpose of learning from reading. I just finished the Learning How to Learn class on Coursera and it emphasizes the active learning by doing that needs to take place for one to internalize ideas. By watching summary videos to just get the gist of each book, I think you end up with a not so useful illusion of understanding.

It recently popped up in a place I didn't expect. In checking out some of the deep learning work around neural style transfer, I found that many of the examples make reference the L-BFGS optimizer. Peeling a layer back, it appears that a commonly used implementation of L-BFGS is in scipy, which is a wrapper around a Fortran implementation.

Having multiple "HQs" spread across three timezones would be interesting from an operations point of view, since Amazon uses the "follow the sun" model for on call on some teams.

Inheritance indeed can be pinpointed as the one major problem in problematic OO code. A lot of the comments here talk about abuse and I think that hits it on the head. It’s not really a matter of knowing when to use or not use inheritance, but rather that the developers that do use it end up using it everywhere and a bad pattern proliferates into even more problematic areas, such as using inheritance for mock objects in unit tests.

After our last trip to Taiwan we decided to make a mobile game about the garbage trucks, just for fun. You run through a quintessential Taiwanese night market past street food stands, motorcycles, and 7-11's while dodging debris like durian and bubble tea in order to catch the garbage truck.

Here's a quick trailer if anyone wants to check it out: https://www.youtube.com/watch?v=_SXWybqiLjQ

Every time I see a headline like this it makes me think that I should work on some personal DIY projects related to solar to really appreciate the advances. Does anyone have experience or suggestions for cool projects to try?

For me, I've never been able to get over the internal conflict of wanting to build a useful tool like a map of fishing spots and releasing it openly, with the downside of good fishing spots getting overrun should the tool become popular. I also started working on a similar idea as yours a couple years ago, but for Instagram instead. It turned out the GPS tagging on Instagram was fairly inaccurate, and sometimes intentionally misleading, especially amongst anglers who tag incorrect locations since the number one no-no is spot burning.

I've been fishing for a few years and learned mostly on my own by scouring forums plus lots of trial and error. I've always likened the draw to be similar to the problem solving nature of programming and engineering in general, and have always wondered if there are other engineers that enjoy fishing. From some of the comments here it looks like there are some, but not many.

I've actually created several pieces of fishing software, for personal use, such as a journal/logging app for recording outings (locations, conditions, results, etc.), a crawler/scraper that extracts EXIF location info for good fishing spots, a notifications app for ideal fishing conditions, etc.

What are the economic implications of a possible/eventual/inevitable reunification scenario that just become a bit more realistic? South Korea is already an economic powerhouse in its own right. I'm wondering more from the point of view of an investor - the public markets don't appear to be particularly swayed by the prospects, probably because the scenario is still farfetched and decades away, if possible.

To me it seems very similar to credit reporting agencies, so I would imagine much of it falls under the same buckets, legal or otherwise.