Do you want to see how to implement simple actor in Tarant and start focusing on your domain logic? What our next video.
{% embed https://youtu.be/z-x0phbcOk8 %}
If that is to long here is a snippet image as TL;DR;
Are you tired of struggling with complex actor systems that require you to write complex code just to manage simple communication between your application's components?
If so, we have great news for you! We are excited to announce the release of our new actor system, built from the ground up using the latest version of TypeScript! Our new full-stack actor system is designed to make building reliable, high-performance, reactive systems a breeze, so you can focus on building great applications that customers love.
To help you get started, we've put together a short 5-minute video that showcases some of the system's key features.
We believe that our new actor system represents a major milestone in modern software development, and we're excited to share it with you. So sit back, relax, and watch the video below to see how our new actor system can help you tackle some of the toughest challenges in modern application development!
{% embed https://youtu.be/2z5tiyl3N9I %}
We are happy to announce that, after a long and huge effort the tarant cloud private beta is ready. We, the maintainers of tarant, believe that software architecture and design can be simpler and more effective, and we mentioned a few caveats of the current status quo.
This private beta is a way to gather feedback on how infrastructure should look like, and a way collaborate with the community on how to make things worth the effort. We want an open approach to design the platform, as the tarant cloud should be a townhall and marketplace of developers willing to share their knowledge, ideas, and tools and get benefit from that.
The private beta offer free infrastructure to deploy in production your tarant applications. You will be using the tarant library and the txc CLI to deploy your application.
The private beta is completely free. No payment method required.
You can click in the following button:
That will pop up a form with basic information so we can contact you to give you access to the beta. The information we need is:
You can add any additional comments and requests and we will read them. If you are interested how the beta works, feel free to take a look at our tutorial on how to deploy your first cloud application.
Working on software based solutions is a complex task that requires the effort of a cohort of very different roles that interact together to design, build, test, deploy and monitor the product. Complexity grows with requirements, given more features, less reliable is to build on top of that software and becomes problematic. The community worked on different solutions for all the set of problems that we, as software developers, need to solve to put our software, working, in production.
These solutions span lots of different aspects of the essential complexity of our work:
And there are many other cross-cutting concerns, like security, performance, accessibility, and so on.
We as an industry, are having a bad time handling all this complexity properly, as we are still young and growing extremely fast. With growth, comes also additional problems, like sociotechnical challenges, resource management, financial operations and a wide list of others that could be included here.
For this post, we are going to talk about production complexity and billing.
Both @kanekotic and myself are software developers, leading teams of different sizes and diversities, with different problems, building software. We are still doing this from different aspects of the delivery timeline of a project. This allows us to understand the software industry from a wider level and to understand where and how we are struggling.
Digging on the feedback we've gathered, we've found the following list of challenges that are common and hardly resolved:
Let me give an example of all these cases:
System scalability is a complex topic, as it depends on usage patterns of customers. Essentially, and ideally, you want to scale down your application and dependencies when there is less load in your systems, reducing costs, but you want to increase the capacity of your system moments before the load increases, so you can handle transparently with the minimum amount of cost increase, your workload.
However, there are a few challenges here:
Some of these challenges are tackled by the serverless model, with a pay per consumption model, with scale-to-zero capabilities. Let's take an example on how AWS Lambda handles it, as it's of the main leaders in serverless computing.
cold starts, what essentialy means that scalability is affected under some runtimes.Lambdas are a wonderful tool, but they are also problematic for billing provisioning. How much is a lambda going to cost overall per month? It's extremely hard to measure properly. There are some calculators, like the one from dashbird that does some simple calculations but it's often not reliable enough because the Lambda billing model is extremely complex.
There are other solutions, of course, like VM reservation, using Kubernetes or something like Fargate, to simplify billing, but they have other types of challenges, like how many VMs should we reserved, what size, and how to ensure workload is distributed evenly.
Software that is useful changes. With these changes, comes technical debt, and an increase amount of complexity. This complexity likely increases with accidential decisions that weren't aware of the future of the software itself. It is common to patch forward features into the current design until the software development process becomes a bottleneck.
The actor model tries to solve these issues by simplifying the overall architecture of software. Instead of complex patterns and layered softwares that
fail to handle concurrency, transactionality and reduced performance, we just have a set of long living objects that interact between them in an ordered
manner. Also, tarant has other properties, like actor universality where an actor can run transparently both in a client application and a server.
Here raises the complexity, as developers need to monitor their software in production, but there is a language gap between how we monitor systems and how we build them. It's not uncommon finding developers uncomfortable understanding how to scale their system based on CPU or memory usage. Nowadays, for lots of systems, disk usage has been delegated to databases, but CPU, Memory, Network, Locks... are still relevant for production-level applications.
We want teams to talk, communicate and solve in a common abstraction level. For us, complexity lies in jumping across different levels of abstractions during the design, development and delivery process. Information is lost during this long jumps, requirements become unclear across teams and tight deadlines forces teams to focus on high-visibility low-value work, delivering uncomplete features, without security best practices, on top of expensive infrastructure.
We are sure that using the actor model, and specific conventions and best practices on top of that, can raise the bar. By increasing the abstraction level, we can assume optimisations, simplify the development model and improve how monitoring and observability works. To this, to work, means that we are not developing anything generic, but will built on top of tarant and for tarant.
Our principles are:
We have lots of ideas, we have lots of opportunities, and we want to build together. We are developing a closed beta that is already accepting requests to test the cloud. We will be giving access incrementally, totally free to the initial, limited version of the cloud. If you want to know more about tarant, check our tutorials. If you want to join the beta, check our home page, as we have a contact form in there. No private information is shared with anyone, and the only communications we will share are strictly related to the beta itself. If you are interested on talking with us directly, we have a gitter room.
Hello welcome everyone to the first blog post of the revamped website.