Your First function.do: A Step-by-Step Guide to Atomic Logic

Unlock the power of agentic workflows on the .do platform by starting with the fundamental building block: the function.do. Think of function.do as the atomic units of your business logic, encapsulating a single, specific action. This guide will walk you through creating your very first function.do and understanding its role in building sophisticated agentic workflows.

What is a function.do?

At its core, a function.do is a defined piece of executable code that performs a specific task within the .do platform. It's designed to be self-contained and reusable, making it easy to compose into larger, more complex operations. Instead of writing monolithic applications, you break down your business processes into these smaller, manageable function.do units.

This "atomic" approach offers several advantages:

• Reusability: Define a piece of logic once and use it in multiple workflows.
• Maintainability: Easier to update or debug individual functions without affecting unrelated parts of your system.
• Composability: Chain and orchestrate function.do together to build powerful agentic workflows.
• Scalability: The .do platform handles the execution and scaling of your functions.

Encapsulate Business Logic with function.do

The true power of function.do lies in their ability to encapsulate business logic. Whether it's processing an order, sending a notification, retrieving customer data, or interacting with an external API, each of these actions can be defined as a function.do.

Let's look at a simple example of a function.do written in TypeScript using the .do SDK. This function encapsulates the logic for creating a new service.

export const createService = agent(async (input: { name: string, description?: string }) => {
  // Logic to create a new service
  const newService = {
    id: generateId(), // Assuming generateId is a helper function
    name: input.name,
    description: input.description || '',
    createdAt: new Date()
  };
  console.log(`Created service: ${newService.name}`);
  return newService;
});

In this example:

• export const createService defines the runnable function.do.
• agent(...) is a decorator (or similar construct depending on the SDK) from the .do platform that registers this function as an executable unit.
• The function takes an input object with name and optional description as parameters.
• It performs the core business logic: creating a new service object.
• It returns the newly created service object.

This function.do is a perfect example of an atomic unit. It does one thing: creates a service. It doesn't handle fetching external data, notifying users, or any other unrelated task. These would be handled by other function.do.

Building Agentic Workflows with function.do

Once you have defined your individual function.do, the .do platform allows you to compose them into sophisticated agentic workflows. Imagine a workflow for onboarding a new customer. This could involve a sequence of function.do:

1. createCustomer: Creates a new customer record.
2. sendWelcomeEmail: Sends a welcome email to the customer.
3. provisionAccount: Sets up their account access.
4. notifySalesTeam: Alerts the sales team about the new customer.

Each of these steps is an independent function.do, but they are orchestrated together to form the complete onboarding process. This modular approach makes your workflows flexible, resilient, and easier to manage.

Get Started with Your First function.do

Ready to build your first atomic unit of business logic on the .do platform?

1. Set up your development environment: Ensure you have the .do SDK installed and configured.
2. Define your function: Write your code using a supported language like TypeScript or JavaScript, encapsulating a single piece of business logic. Use the agent (or equivalent) construct provided by the SDK.
3. Deploy to the .do platform: The platform provides tools and commands to easily deploy your function.do.
4. Test and compose: Once deployed, you can test your function and begin composing it with other function.do to build your agentic workflows.

By starting with the fundamental concept of function.do and embracing the atomic approach, you set the stage for building powerful, scalable, and maintainable agentic applications on the .do platform.

Frequently Asked Questions

• What is a function.do?
  A function.do represents a single, atomic unit of business logic within the .do platform. It's a core building block for creating more complex agents and services.
• How do I define a function.do?
  You define function.do using standard programming languages like TypeScript or Javascript, leveraging the .do SDK to encapsulate specific business logic.
• Can function.do be combined?
  Yes, multiple function.do can be composed and chained together using the .do platform's orchestration capabilities to create comprehensive Agentic Workflows.
• Where are function.do executed?
  function.do are deployed and managed within the .do platform, making them easily discoverable, executable, and scalable.