goncalo-r

What's the baseline here - in a world where every person is betting randomly X times a month, what would the distribution look like? There'd still be a small percentage that wins most of it, right?

News gives you a heads up on what could be coming before laws were passed, or overall sentiment of the population or the politicians. Sometimes it's not about new laws, but about new interpretations, enforcements, court rulings etc.

For a lot of office jobs, knowing the context is almost the same as knowing the solution to the problem at hand.

Imagine if AI could update my Jira ticket status.. I would pay big money for that.

But this is obviously not scalable/sustainable. If everyone wanted to eat grassfed beef that lives in free range fields multiple times a week, we'd very quickly run out of space and other resources. Not to mention you're still contributing heavily to climate change, unless "bio-regenerative" also means restoring the atmosphere for a zero carbon impact.

At the end of the day, we all need to eat less meat.

This is what Multy (https://github.com/multycloud/multy) aims to do

I do think multi-cloud is the future and really enjoyed the tutorial. Have you seen people run into any problems with Cilium? I tried it before but couldn't configure it correctly.

My assumption is that they are trying to "solve" the hallucination problem by only giving you answers when it's more certain about itself and telling you to search for answers online.

Here's another example to test if it can actually think critically about a problem instead of just following whatever instructions and whatever the training data had. A human with basic level math could do it.

> can you replace the first letter of "banana" with the next letter of the alphabet?

Yes, I can do that! However, I should note that after several iterations, the resulting word may no longer be considered a recognizable word in the English language. Here are the next 10 iterations:

"canana" becomes "danana" "danana" becomes "eanana" "eanana" becomes "fanana" "fanana" becomes "ganana" "ganana" becomes "hanana" "hanana" becomes "ianana" "ianana" becomes "janana" "janana" becomes "kanana" "kanana" becomes "lanana" "lanana" becomes "manana" And so on for a total of 173 iterations

> I want the final answer

Sure, after 173 iterations of replacing the first letter of "banana" with the next letter of the alphabet, the final word would be:

"zcyzcj"

As noted earlier, after several iterations, the resulting word may no longer be considered a recognizable word in the English language.

It's just an example. An human could solve this with an arbitrary number of substitutions, but I'm sure GPT4 breaks at some point. I don't think it's fair to compare it with a human with no paper and pencil... It's like asking asking the AI to not use any RAM. Humans are very bad at keeping stuff in RAM so paper and pencil is all we've got.

It's not good at reasoning. I asked the following (the term substitutions are there to avoid parroting):

  Let's define the following terms:
  col means "and", pel means "or" and erf is equivalent to "col" if the first argument evaluates to "true", otherwise it's equivalent to "pel"

  can you evaluate the following statement?
  col(true, pel(false, true), erf(col(true, false), true))

And it said this:

  ...
  Next, we look at the expression "erf(col(true, false), true)". Since the first argument is true, erf is equivalent to col, which means we evaluate the entire expression as:

  col(true, false) = false

  Therefore,

  erf(col(true, false), true) = col(true, true) = true

which is obviously wrong because the first arg is false. The final answer happens to be the same. So I then asked

  what about col(true, pel(false, true), erf(col(true, false), false))

and this is its full answer:

  Sure, let's evaluate the expression "col(true, pel(false, true), erf(col(true, false), false))" step by step:

  First, we look at the expression "pel(false, true)". This is an "or" operation, so we evaluate it as follows:

  pel(false, true) = true

  Next, we look at the expression "erf(col(true, false), false)". Since the first argument is true, erf is equivalent to col, which means we evaluate the entire expression as:

  col(true, false) = false

  Therefore,

  erf(col(true, false), false) = pel(false, false) = false

  Finally, we look at the expression "col(true, pel(false, true), erf(col(true, false), false))". Using the results from steps 1 and 2, we can evaluate this as:

  col(true, true, false) = true

  Therefore, the overall value of the statement "col(true, pel(false, true), erf(col(true, false), false))" is true.

You can see it's mostly random nonsense masked as "reasoning". It's not even consistent across sentences. I assume if you do a bigger model, it might do better, but as soon as you increase the example size I suspect it will get it wrong again.

Looks like a really useful tool. A lot of codebases I worked in waste a lot of effort adding tests that just try to capture some golden expected values. As these aren't necessarily tied to product requirements, they often change and require devs to change the tests to match any new output. I can see a tool like this greatly reducing the time spent on these tests while providing better coverage and detecting more regressions.

Really cool project!

Are there any downsides - for example performance or operational overhead - of using Constellation over vanilla K8s?

I would just find another job, let them crash and burn on their own

Quick work has a very real long-term hidden cost. Not only it creates tech debt - meaning the work has to probably be redone at a later stage, but also racks up wasted hours of bug fixing over time. Most importantly, if a codebase is entirely composed of "quick work", it creates a legacy codebase - which means it will be harder to hire engineers that want to maintain it. Or again, you'll have to redo it.

So, it depends. If there's a high change whatever you're working on is there to stay, it's better to do it well.

If you're still experimenting, or unsure if the feature is there to stay, then the tech debt incurred might not matter.

I mean, I don't think that's a good argument - it costs you cents per user. Either way, I think you should charge however much value users can take from the product, completely unrelated to the cost.

At the moment though, being notified whenever my github repo is trending is a nice to have that gives me nearly 0 value as there's no actions I can take from that (other than share with my team :)). So I would try to find some other way to monetize it or to bring value to the users. Sorry for the harsh feedback.

This is a great product - congratulations on the launch!

I struggle to see a notification being worth paying 5.99/month though

I don't believe the goal of Serverless Framework is necessarily to tackle vendor lock in, it's more about simplifying and somehow unifying the deployment process. Similarly to Terraform, it ends up being cloud specific in a lot of the details.

I agree that managed services provided by the cloud providers allow you to save money and make life easier. Our main goal is to enable people to use those that are common across clouds without locking themselves in. Of course some features are only available in some clouds, and you'll still have to deal with data fees if you want to move, but having your configuration cloud agnostic saves you a lot of time if you either want to move or want to go multi-cloud.

The cloud environment right now offer so many things that you'd be wasting your time recreating everything in plain linux instances.

At the end of the day using cloud native managed resources offer real advantages from time to market to pricing that we believe people should leverage as much as they can. Unfortunately it's also how you end up being locked in, so we are trying to tackle that.

Terraform is quite generic in its nature. At the end of the day it's just a state management tool. We decided to start there as it's the de facto IaC tool, but we are planning on launching a web portal soon and offer other ways to interact with Multy in the future such as an SDK and a CLI tool.

I really like the way GoLang handles concurrency. Sometimes it might be a bit verbose to create wait groups and whatnot but I think it makes it pretty readable.

Is there any reason people prefer the async/await primitives?

Aren't microservices nice because they allow you to have different teams own different parts of the code and minimize the communication overhead?

Looks really cool! Would you a consider a free tier if you have a low follower count?