synthc

Most go codebases I have seen would benefit from using a framework TBH.

Sure, not using a framework is nice for a small and simple service.

When you have multiple devs working on a large codebase over the timespan of years, a 'heavy' framework is highly prefereable over everyone reinventing the wheel.

I gave it a weird and convoluted code snippet, and asked an LLM to step through the execution and trace the value of the variables at each step.

It was completely correct and I realized LLM are capable of generalizing beyond their training sets

`uv agent` and `bun agent` in 3....2.....1....

Very hit or miss.

Stack: go, python Team size: 8 Experience, mixed.

I'm using a code review agent which sometimes catches a critical big humans miss, so that is very useful.

Using it to get to know a code base is also very useful. A question like 'which functions touch this table' or 'describe the flow of this API endpoint' are usually answered correctly. This is a huge time saver when I need to work on a code base i'm less familiar with.

For coding, agents are fine for simple straightforward tasks, but I find the tools are very myopic: they prefer very local changes (adding new helper functions all over the place, even when such helpers already exist)

For harder problems I find agents get stuck in loops, and coming up with the right prompts and guardrails can be slower than just writing the code.

I also hates how slow and unpredictable the agents can be. At times it feels like gambling. Will the agents actually fix my tests, or fuck up the code base? Who knows, let's check in 5 minutes.

IMO the worst thing is that juniors can now come up with large change sets, that seem good at a glance but then turn out to be fundamentally flawed, and it takes tons of time to review

They made their home a concentration camp, no need for railroad cars this time...

I'm thinking of using it to replace an analytics pipeline at my job, which now uses expensive batch jobs. If the tech is solid, we would have instant and incremental updates, instead of recomputing everything every X hours. This would simplify things a lot.

I think Materialize offers a similar product, but last I checked it was only available as a SaaS solution.

I hope to do a proof of concept soon, to compare both solutions

Does anyone have experience with RisingWave in production? It seems like an interesting product but I can't find any experience reports.

User name almost checks out

Classic Dutch: “We need this talent… but financially, it is impossible to support them,”

you get runtime errors with a long JVM stacktrace

Immutability removes so much accidental complexity, it makes whole classes of mistakes dissapear. I'd also take immutability over types.

Clojure sort of guides you to simplicity, building everything out of functions and simple datastructures has big advantages when testing and reasoning about code.

I do find that in larger code bases, Clojure lack of types causes friction (spec is just a bandaid, not a fix).

There are languages with immutability and types (like Haskell), but these don't have the get-shit-done factor I seek.

For me it just speeds up learning the language, so I think i'd become fluent faster.

I do thoroughly review of the the LLM answers, and hardly every directly copy paste answer, so I feel this way I still learn the language.

about as much as I trust StackOverflow answers

Seems like a bunch of go programmers really wanted to use go, no matter how impractical.

Interesting! I did an internship where I tried to use transducers for fast information extraction. In theory, you can use FST's for fast approximate parsing. I didn't really work out, but I had lots of fun implementing a libary to compose FST's and explore cool algorithms to compose them. Not much business value was delivered, but I learned a lot.

This year I switched to a new job, using programming languages that I was less familiar with.

Asking a LLM to translate between languages works really well most of the time. It's also a great way to learn which libraries are the standard solution for a language. It really accelerated my learning process.

Sure, there is the occasional too literal translation or hallucination, but I found this useful enough.

Interesting deep dive on the internals of Caffeine, a widely used JVM caching library.

This just proves to me Meta can't build a product users actually want to use, they can only acquire other products, or lobby.

'Serverless' has it's uses, but not for everything

- Serverless can get very expensive - DevEx is less than stellar, can't run a debugger - Vendor lock-in - You might be forced to update when they stop supporting older runtime versions

My first job (around 2010) was to extract events from financial news and police reports.

We built this huge system with tons of regexes, custom parsers, word lists, ontologies etc. It was a huge effort to get somewhat acceptable accuracy.

It is humbling to see that these days a 100 line Python script can do the same thing but better: AI has basically taken over my first job.

The difference is in how easy it is to detect the cause of problems. Mistakes like wrong function names are mostly easy to find and fix. Mistakes when using core.async can be very hard to track down.

I wouldn't recommend it but I'd figure the hackernews crowd likes deep dives on wierd diets.

GCP has the superior UI, api and design. I prefer it over the other clouds: Azure plain sucks and AWS has too much bloat and does IAM/accounts worse.

In my experience GCP's core services are very stable: I had a site running on free tier App Engine for over 10 years without any supervision.

However it is clear that many GCP products are run by skeleton crews and will not improve. Documentation is also lacking sometimes.

Dataform for example is conceptually a great tool, but hampered by really basic UI bugs.

I found Datastream (change data capture tool) impossible to use. You would think that shoveling data between 2 GCP products (Postgres and BigQuery) would be easy, but I spend a week fiddling with obscure network settings before giving up.

this, I like Fastmail, but their app being online-only is a shame

People discovered that using messaging can add tons of overhead, and async messaging architectures are harder to manage and monitor.

Serialization and going over the network are an order of magnitude slower and error prone than good ol' function calls.

I've seen too many systems that spent more time on marshalling from and to json and passing messages around than actual processing.

This is so shortshighted, it's not about 'respect', its about market value. By bringing an offer your employees are proving their market value, and you don't want to match it, so they will leave.

Caddy is great! Absolutely beats Nginx and apache for hosting simple stuff.

For me, Clojure with Clojurescript and Datomic.

For webapps Fulcro is a great framework, though it has a steeplearning curve.

Seem like the design decision to only allow a single thread to handle writes paid off. Datomic is a marvel of good design, I wish I could use it again....

I think the language has indeed reached a stable point and found its niche, which is small, but there are certainly domains where Clojure is the best fit.

The ideas behind Clojure (functional, immutable datastructures, homoiconic syntax, focus on simplicity, JVM interop) still stand strong IMO.

There are still some exciting projects done in Clojure: Electric Clojure and Rama come to mind.