sam-goodwin

absl-py==2.1.0
aicsimageio==4.11.0
aioboto3==12.1.0
aiobotocore==2.8.0
aiofiles==23.2.1
aiohttp==3.9.3
aioitertools==0.11.0
aiosignal==1.3.1
alembic==1.13.1
aniso8601==9.0.1

sam-goodwin

from typing import Any, Optional, get_args, get_origin

import numpy as np
import pandas as pd
import pandera.typing as pdt
import pyarrow as pa
from pandera import DataFrameModel, Index, MultiIndex, dtypes
from pandera.engines import numpy_engine, pandas_engine
from pandera.engines.engine import _is_namedtuple, _is_typeddict
from pandera.typing.common import SeriesBase

sam-goodwin

Decorators on functions would be useful for frameworks that do basic reflection to infer configuration and bundle applications such as APIs, cloud functions, etc.

Examples

I think a good place to look at for examples is the Python ecosystem:

1. Chalice uses decorators for wiring up function handlers to AWS resources
2. Modal uses decorators to provision infrastructure and model the boundaries compute (different hosted functions)

Example 1: an @function() annotation marks a function as a hosted FaaS Function

sam-goodwin

Description

Instead of writing Velocity Templates or Amazon States Language, just write TypeScript functions and the Functionless compiler will automatically convert them to AppSync Resolver Pipelines and Step Function definitions. Enjoy the type-safety and expressiveness of TypeScript without Lambda Functions!

Describe your talk in as much detail as you desire

Functionless (https://github.com/sam-goodwin/functionless) is a Typescript Plugin that allows developers to write all of their infrastructure in native TypeScript, generating all the various configuration language like Amazon States Language, Velocity Templates, Event Bridge patterns (and more) without leaving TypeScript and without complicated DSLs.

The name, Functionless, comes from the concept of service-to-service integrations (colloquially referred to as "functionless") that are higher level than "serverless" integrations such as AWS Lambda Functions. The two examples I'll be discussing are AWS AppSync Resolvers and AWS Step Function's Ama

sam-goodwin

{
  StartAt: "State1",
  States: {
    State1: {
      Catch: [
        {
          ErrorEquals: ["States.All"],
          Next: "Throw",
        },
      ],

sam-goodwin

topic.stream().forEach(stack, 'ForEachNotification', {
  handle: async (notification) => {
    console.log(`sam's new blog is available!', notification); 
  }
});

sam-goodwin

new Construct(scope, 'myConstruct');

// is a lot like:
function scope() {
  const myConstruct = new Construct();
}

sam-goodwin

// manually create the AWS client, look up environment variables etc.
const AWS = require('aws-sdk');

const sns = new AWS.SNS();

const topicArn = process.env.TOPIC_ARN;
if (!topicArn) {
  throw new Error('TOPIC_ARN must be defined');
}

sam-goodwin

import cdk = require('@aws-cdk/core');
import { Function, Topic, string, integer, timestamp } from 'punchcard';

const app = new cdk.App();
export default app;
const stack = new cdk.Stack(app, 'my-stack');

// create a type-safe SNS Topic
const topic = new Topic(stack, 'Topic', {
  type: struct({

sam-goodwin

import cdk = require('@aws-cdk/core');
import lambda = require('@aws-cdk/aws-lambda');
import sns = require('@aws-cdk/aws-sns');

import path = require('path');

const app = new cdk.App();
const stack = new cdk.Stack(app, 'my-stack');

const topic = new sns.Topic(stack, 'MyTopic');