klotho

This insightful article by Adam Ruka covers: - What's IaC. - First gen. tools: Declarative, Host Provisioning (Chef, Puppet, Ansible). - Second gen. tools: Declarative, Cloud (CloudFormation, Terraform, Azure Resource Manager). - Third gen. tools: Imperative, Cloud (AWS CDK, Pulumi, SST). - The future: Infrastructure from Code (Wing, Eventual, Ampt, Klotho). Why it interests me? I'm one of the creators of Winglang (https://github.com/winglang/wing) that is featured there as one of the future 4th gen. tool, along with Eventual (https://github.com/functionless/eventual), Ampt (https://github.com/getampt) and Klotho (https://github.com/klothoplatform/klotho).

We use OpenAI/GPT for NLP only - parsing intent - oversimplifying but normalizing things like "I want a serverless function that connects to RDS" is translated to a JSON schema that says serverless <-> RDS. That's then passed to the InfraCopilot engine which then unpacks what that means into a larger architectural representation (we have an Architecture-as-Code blog post coming soon). This is open source to a large degree, it's powered by the Klotho engine ( https://github.com/KlothoPlatform/klotho )

One of the key challenges we observe is that if you're small enough, a Heroku like experience works well - and most of your needs would be covered by virtually any combination of techstacks. It gets significantly more challenging when you grow, either in feature complexity or scale complexity - and then very few services can offer what AWS/GCP/Azure offer - albeit at the increased engineering/monetary cost of using them. We're building a different kind of approach[0] that aims to absorb the mechanical cost of using public cloud capabilities (that are proven to scale) without hiding it altogether. [0] https://github.com/KlothoPlatform/klotho

disclaimer: I'm one of the founders We're building klotho[0] for many of the reasons mentioned here. (happy to answer questions). We transform plain code to cloud native code. The majority of the complexity is moved into the Klotho compiler, and what devs handle is the simplest bundle that's easy to deploy and operate on public clouds using standard tools. [0] https://github.com/KlothoPlatform/klotho

Glad it helps! There are 4 key steps that I took: - Upscaling (using Upscayl[0]) - OCR (using tesseract[1]) - Indexing (using Algolia[2]) - Scaling the processing and running on AWS (Klotho[3] - our startup) I wrote a more in-depth blog post about it[4] [0] https://github.com/upscayl/upscayl [1] https://github.com/tesseract-ocr/tesseract [2] https://www.algolia.com/ [3] https://github.com/KlothoPlatform/klotho [4] https://www.alashiban.com/search-the-deck/

You might enjoy the blog post[0] (150GB of images, tesseract OCR, 2GB of data, Algolia for search). There's a github repo too[1] [0]: https://www.alashiban.com/search-the-deck/ [1]: https://github.com/klothoplatform/klotho

Hi everyone, Ala here. I'm the co-founder of Klotho (https://klo.dev). We built a tool that allows you to write cloud applications without the complexities that exist with today's approaches. Infrastructure-as-Code is the current state of the art, but the level of work needed to implement a cloud system with it is extremely high, to the point where teams and companies staff an entire organization to support the rest of the company in building features. Klotho solves that by inferring the application architecture from the application source, with a bit of help from simple annotations that developers add. Then, it generates the IaC that the architecture implies. For example, if you have a Node.js app with an fs/promises object, you can turn that into S3 persistence as simple as: // @klotho::persist { id="imagestore" } import fs = require("f