fangpenlin

no profile record

Submissions

Software Engineering in the Agentic Era

4 pointsby fangpenlin5 miesięcy temu0 comments

Manufacturing as Code Is the Future, and the Future Is Now

blog.makerrepo.com

1 pointsby fangpenlin5 miesięcy temu0 comments

Origami on Another Level with 3D Printing

2 pointsby fangpenlin7 miesięcy temu0 comments

Nix flakes explained: what they solve, why they matter, and the future

determinate.systems

3 pointsby fangpenlin7 miesięcy temu0 comments

Open-source LLM powered plaintext based spreadsheet appp

3 pointsby fangpenlin12 miesięcy temu0 comments

I built an AI-gen video detection model and browser extension in a month

2 pointsby fangpenlinw zeszłym roku0 comments

HTTP Feeds – Asynchronous Interfaces Without Kafka or RabbitMQ

2 pointsby fangpenlinw zeszłym roku0 comments

Show HN: Open-source LLM-powered invoices/receipts email data extraction tool

2 pointsby fangpenlinw zeszłym roku0 comments

Nvidia on NixOS WSL – Ollama up 24/7 on your gaming PC

yomaq.github.io

95 pointsby fangpenlinw zeszłym roku49 comments

Setting Up Nix on macOS

4 pointsby fangpenlinw zeszłym roku0 comments

Machine Learning Glossary

ml-cheatsheet.readthedocs.io

1 pointsby fangpenlinw zeszłym roku0 comments

Product-Market Fit

2 pointsby fangpenlinw zeszłym roku0 comments

Nvidia GPU on bare metal NixOS Kubernetes cluster explained

41 pointsby fangpenlinw zeszłym roku15 comments

Understanding Kubernetes Container Runtime: CRI, Containerd and Runc Explained

1 pointsby fangpenlinw zeszłym roku0 comments

Nix-playground – CLI for patching nixpkgs package source code easily

2 pointsby fangpenlinw zeszłym roku1 comments

Noogλe – Search Nix Functions

2 pointsby fangpenlinw zeszłym roku0 comments

[untitled]

2 pointsby fangpenlinw zeszłym roku0 comments

LLM Basics: Embedding Spaces – Transformer Token Vectors Are Not Points in Space

2 pointsby fangpenlinw zeszłym roku0 comments

Zhang – a plain text double-accounting tool which is compatible with beancount

2 pointsby fangpenlinw zeszłym roku0 comments

Rust async framework for embedded systems

1 pointsby fangpenlinw zeszłym roku0 comments

comments

5 miesięcy temudiscuss

There's an obvious theme with lawmakers in California—they pass laws to regulate things they have zero clue about, add them to their achievement page, cheer for themselves, and declare, "There! I've made the world a better place." There are just too many examples. For instance:

- Microstamping requirements for guns—printing a unique barcode on every bullet casing (Glock gen3 cannot be retired, thus, the auto-mode switch bug cannot be patched...)

- 3D printers should have a magical algorithm to recognize all gun parts in their tiny embedded systems

- Now, you need to verify your age... on your microwave?

At this rate, California should just go back to the Stone Age. Modern technology is simply not compatible with clueless politicians who are more eager to virtue-signal than to solve any actual problems or even borther to study the subject about the law they are going to pass. There will be more and more technology restrictions (or outright bans on use) in California because it's becoming impossible to operate anything here without getting sued or running afoul of some overreaching regulation.

w zeszłym rokudiscuss

I heard that Nvidia's graph cards are the best in the class in terms of power consumption vs TFLOP ration. I wonder what's the number of AMD vs Nvidia? I would like to see the number because power consumption is going to take a big portion of AI training. In comparsion, hardware might not be that expensive in the long run.

w zeszłym rokudiscuss

For a usecase like this, a local running model would be ideal. I won't like to share my personal accounting books with LLM either.

w zeszłym rokudiscuss

Some people, myself included, prefer text-based files as a user interface. Like, some Vim users won't leave their Vim session forever and would like to do everything in it. While SQLite is immortal software and will probably be there forever, using it means changing the UI/UX from text files to SQL queries or other CLI/UI operations. I think it's a preference for UI/UX style instead of a technical decision. For that preference of UI/UX, we can push on the technical end to solve some challenges.

w zeszłym rokudiscuss

If there's anything like immortal software, SQLite is definitely on the list

w zeszłym rokudiscuss

Hi, the author here.

If you are okay with Plaid[1], many of their bank connections are now using OAuth-style authentication instead of password sharing. I actually added a new feature called Direct Connect[2] a while back to allow any plaintext accounting book users to pull CSV directly via Plaid API through BeanHub. We don't train AI models with our customers' transactions, and if we want to, we will ask for explicit consent (not just ToS) and anonymize customers' data.

If you're okay with the above, the key to achieving a high automation level is the ability to pull CSV transaction files directly from the bank in a standard format. Maybe you can give it a try. We have 30 days free trial period.

I am not so familiar with the CMMC requirements, as you mentioned, but for us to access transactions from some banks, such as Chase, Plaid requires us to pass an auditing process about our security measurements. Is the CMMC compliance your company needs to meet to take a third-party software vendor into considerations?

[1]: https://plaid.com

[2]: https://beanhub.io/blog/2025/01/16/direct-connect-repository...

w zeszłym rokudiscuss

Hi, the author here.

I get where you're coming from. My books are also growing big right now, and indeed, they have become slower to process. Some projects in the community, such as Beanpost [1], are actually trying to solve the problem, as you said, by using an RMDB instead of plaintext.

But I still like text file format more for many reasons. The first would be the hot topic, which is about LLM friendliness. While I am still thinking about using AI to make the process even easier, with text-based accounting books, it's much easier to let AI process them and generate data for you.

Another reason is accessibility. Text-based accounting only requires an editor plus the CLI command line. Surely, you can build a friendly UI for SQLite-based books, but then so can text-based accounting books.

Yet another reason is, as you said, Git or VCS (Version control system) friendliness. With text-based, you can easily track all the changes from commit to commit for free and see what's changed. So, if I make a mistake in the book and I want to know when I made the mistake and how many years I need to go back and revise my reports, I can easily do that with Git.

Performance is a solvable technical challenge. We can break down the textbooks into smaller files and have a smart cache system to avoid parsing the same file repeatedly. Currently, I don't have the bandwidth to dig this rabbit hole, but I already have many ideas about how to improve performance when the file grows really big.

[1]: https://github.com/gerdemb/beanpost

w zeszłym rokudiscuss

Hi, the author here.

Many customers have asked me about AI offerings, and I am considering them. While this is doable with modern LLM technologies, I need to consider many issues.

The first is that nobody, myself included, likes their data being part of someone else's machine-learning training pipeline. That's why I promised my users that I wouldn't use their data for machine learning training without asking for explicit consent (and, of course, anonymization will be needed).

While I know everything involved in AI sounds cool, do we really need LLM for a task like this? Maybe a rule-based import engine could kill 95% of the repeating transactions? And that's why I built beanhub-import[1] in the first place. Then, here comes another question: Should I make LLM generate the rule for you or generate the final transactions directly?

Yet another question is, everybody/every company's book is different from one to another. Even if you can train a big model to deal with the most common approaches, the outcome may not be what you really need. So, I am thinking about possibly using your own Git history as a source of training data to teach machine learning models to generate transactions like you would do. That would be yet another interesting blog post, I guess if I actually built a prototype or really made it a feature for BeanHub. But for now, it's still an idea.

[1]: https://beanhub-import-docs.beanhub.io/

w zeszłym rokudiscuss

Hey! Thanks for pointing out. I have already corrected it in my article :)

w zeszłym rokudiscuss

Hi, the author here.

So BeanHub is built on top of Beancount and uses double-entry accounting. It's one of the benefits of double-entry accounting. Many accounting software are not good at dealing with multi-currencies or custom currency. With Beancount, you can define any commodity you want, create transactions, and convert them with different currencies easily. For example, you can define a commodity TSM and create transactions[1] like this:

2025-01-01 commodity TSM

2025-03-05 * "Purchase TSMC"

  Assets:US:Bank:WellsFargo:Checking                        -2,000 USD @ 100 TSM
  
  Assets:US:Bank:Robinhood                                      20 TSM

I think many people trade crypto, and traditional accounting software may not be that friendly to them. That's why I emphasized a bit to the crypto target audience. But you're right; I should make it clearer that it's not just for crypto.

[1]: https://beancount.github.io/docs/beancount_language_syntax.h...

w zeszłym rokudiscuss

By the way, one of the problems I encountered but didn't mention in the article was that the libnvidia-container has problem with the pathes for reading nvidia drivers and libraries under NixOS with its non-POSIX pathes. I had to create a patch for modifying the path files. I just created a Gist here with the patch content:

https://gist.github.com/fangpenlin/1cc6e80b4a03f07b79412366b...

But later on, since I am taking the CDI route, it appears that the libnvidia-container (nvidia-container-cli) is not really used. If you are going with just container runtime approach instead of CDI, you may need a patch like this for the libnvidia-container package.

w zeszłym rokudiscuss

There's a bug in k8s-device-plugin that stops the plugin from even launching, as I mentioned in the article:

https://github.com/NVIDIA/k8s-device-plugin/issues/1182

And I opened a PR for fixing that here:

https://github.com/NVIDIA/k8s-device-plugin/pull/1183

I am unsure if this bug is only for the NixOS environment because its library paths and other quicks differ from those of major Linux distros.

Another major problem was that the "default_runtime_name" in the Containerd config didn't work as expected. I had to create a RuntimeClass and assign it to the pod to make it pick up the Nvidia runtime.

Other than that, I haven't tried K3S, the one I am running is a full-blown K8S cluster. I guess they should be similar.

While there's no guarantee, if you find any hints showing why your Nvidia plugin won't work here, I might be able to help, as I skip some minor issues I encountered in the articles. If it happens to be the ones I faced, I can share how I solved them.

w zeszłym rokudiscuss

For training, yes, you will need to share the parameters (i.e., weights and bias); the number is huge. But for inference, you don't need that much high bandwidth to run it in a distributed manner.

According to the author of Exo https://blog.exolabs.net/day-1/:

> When Shard A finishes processing its layers, it produces an activation that gets passed to Shard B over whatever network connection is available. In general these activations are actually quite small - for Llama 3.2 3B they are less than 4KB. They scale approximately linearly with the size of the layers. Therefore the bottleneck here is generally the latency between devices, not the bandwidth (a common misconception).

I think that makes sense because the activations are the numbers coming out of the whole neuron network (or part of it). Compared to the number of parameters, it's not at the same magnitude.

w zeszłym rokudiscuss

Broken links should be fixed right now. Sorry about that.

w zeszłym rokudiscuss

You can check Exo out:

https://github.com/exo-explore/exo

It's a project designed to run a large model in a distributed manner. My need for GPU is to run my own machine learning research pet project (mostly evolutionary neuron network models for now), and it's a bit different from inferencing needs. Training is yet another different story.

But yeah, I agreed. I think machine learning should be distributed more in the future.

w zeszłym rokudiscuss

Hi, I'm the author. Usually, I provide links to the new terms mentioned in the article so that interested people can click and learn more. I have changed the link color from blue to dark gray. Would it help? Or are there just too many links in general?

w zeszłym rokudiscuss

So, it turns out "Spreadsheet Is All You Need"

2 lata temudiscuss

Hatchet looks pretty awesome. I was thinking about using it to replace my Celery worker. However, the problem is that I can only use the gRPC client to create a task (correct me if I am wrong). What I want is to be able to commit a bunch of database rows altogether with the background task itself directly. The benefit of doing so with a PostgreSQL database is that all the rows will be in the same transaction. With traditional background worker solutions, you will run into two problems:

1. Commit changes in the db first: if you fail to enqueue the task, there will be data rows hanging in the db but no task to process them

2. Push the task first: the task may kick start too early, and the DB transaction is not committed yet, it cannot find the rows still in transaction. You will need to retry failure

We also looked at Celery and hope it can provide a similar offer, but the issue seems open for years:

https://github.com/celery/celery/issues/5149

With the needs, I build a simple Python library on top of SQLAlchemy:

https://github.com/LaunchPlatform/bq

It would be super cool if Hatchet also supports native SQL inserts with ORM frameworks. Without the ability to commit tasks with all other data rows, I think it's missing out a bit of the benefit of using a database as the worker queue backend.

2 lata temudiscuss

SEEKING WORK | Remote OR on-site | SF Bay area | part-time

I am a one-person-army software engineer with 23 years of intensive experience in different fields. I am currently running a small software startup, Launch Platform (https://launchplatform.com/). I spent time on the side taking contracting jobs. Recently, I have extra contracting bandwidth available, and I am currently looking for a new client.

I provide a special kind of software development service: a one-stop, high-quality, rapid software development service to my clients. I can build products from end to end, be it frontend, backend, mobile, data, security, or DevOps, with a team or by myself, with a proven track record. A good example would be I built three SaaS products listed on my company's website by myself. I usually only recommend that my client hire me if the project is high-impact and involves many ends (backend, frontend, mobile, etc.). It will be way more expensive and slower if you hire and manage each role.

You can also check my GitHub profile:

https://github.com/fangpenlin/

My resume is available upon request, but please briefly describe what project you are trying to build in the email. My email is hello [_at_] [my company domain name]

2 lata temudiscuss

Thanks for the feedbacks. The author here. Personally I found it more "fun" (well, I guess for everybody it's different) to have some meme in between of the articles, some people hate to read too much text all in once, but yeah, I get your point. So I was thinking maybe I should add a switch like "meme off" to hide all of those at the top of article so that people don't like it can feel better while reading it.