Building Dynamic AWS Lambda Applications with BoxLang

Dynamic AWS
Lambda with
LED BY
Luis F. Majano

LUIS F. MAJANO
• CEO Ortus Solutions
• Computer Engineer
• Born in El Salvador => Raised in the USA
• 2023 Leading EU Expansion team (Malaga, Spain 🇪🇸)
• Creator & Maintainer:
ColdBox MVC, TestBox BDD/TDD, CommandBox CLI, ContentBox CMS, etc.
• Creator / Chief Language Engineer BoxLang Programming Language
@lmajano @ortussolutions
WHAT DO YOU CALL AN ANXIOUS DINOSAUR?

• Serverless
• What? Why? When?
• Providers
• Use Cases
• Real Life Case
• Best Practices
Agenda
• BoxLang
• What is it
• Why
• Key Features
• Lambda Runtime
• Lambda Template
Part 1 Part 2

AWS Lambda - Serverless Computing
FaaS

AWS Lambda is a serverless computing service that runs
code in response to events without managing servers,
automatically scaling and charging only for execution time.
What is serverless?

Serverless Computing Evolution
Physical Machines
Virtual Machines
Containers
Lambdas
Focus on Business Logic
Abstraction

Execution Patterns
• API Driven Patterns
• Event Driven Patterns
• Data Streaming Patterns
• Scheduling Patterns

Key Points about Serverless
• Me
• Focus on code abstractions
• Provider
• Auto Scaling
• Fault tolerance
• High Availability
• Metrics and Logging
• No OS updates
• Pay per use ONLY

Fine-Grained Pricing: Never pay for idle
• FREE Tier
• Buy in 100ms increments
• No minimums
• No per-device fees
• No idle fees

How Functions Work
Upload Function
(CI, Manually)
De
fi
ne Function Triggers
(API Calls, Events, Schedules)
Function Execution
(Stateless, Cold Start, Timeouts)

Di
ff
erent Language Implementations
PHP
Node.js
Python
Go
Ruby
.Net

Core Concept of Serverless is ….
Function = Unit of Work

Common Use Cases
REST Data Processing
Chat Bots
Amazon Alexa IoT
Scheduled Tasks Code Execution AI

REST (Direct Function URL or API Gateway)

Scheduling with AWS EventBridge

Ortus Use Case : BoxLang Code Playground : try.boxlang.io

Wanna play?
64MB RAM
600 KB
8 MB
<Your
Code>

Wanna play?
• try.boxlang.io
• Internet playground for BoxLang
• First production BoxLang applications
• Powered by our MiniServer and AWS
Lambda Runtimes

Cool Stats
• Average executions per day: 28,000+
• Average execution time: 38ms
• Monthly Bill ????
$0.0000000000

AWS Lambda Best Practices
• Code is stateless
• Leverage external services: S3, ElastiCache, RDS, etc.
• Ephemeral Disk Capacity
• 512MB by default -> 10GB if needed (But you pay)
• Max Timeout = 15 Minutes, lower it to your convenience, or pay
for it :)
• Concurrent Executions: 1000
• Beware the ColdStart
• Use static constructs to avoid re-creations per request
• Payload Size (Careful Here)
• Request: 6MB Synchronous, 256KB asynchronous
• Response: 6MB

Logging & Metrics
• USE IT! It’s already included
• Enable X-Ray + Lambda Service Traces
• Enable Enhanced Monitoring
• A wealth of debugging data is available!

Deployment Limits
• 50 MB zip or jar
fi
le
• 250MB unzipped
• Up to 5 Layers (Dependency Jars)
• Recommendations:
• Create a Fat/Shaded Jar
• Use Container Images -> 10GB
• Use our BoxLang Template!
• But, remember, focused work units is what you want.

Power Levels
• Had no idea at
fi
rst!
• You don’t choose CPU, you choose the memory
• More Memory => More CPU you get
• From 128bm => 10GB in 1GB increments
• Want to save money?
Choose ARM and not x86, way cheaper!
• Geek way to save money?
AWS Lambda Power Tuning: https://github.com/alexcasalboni/aws-lambda-power-tuning

SAM - Your new Best Friend
• Template-Driven resource management model
• Fancy words for Infrastructure as Code
• Supports anything AWS
• Included CLI
• Great for testing locally
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html

DYNAMIC : MODULAR : PRODUCTIVE
Part 2

BoxLang is a modular dynamic language for the JVM, aiming
to make your development more productive, expressive,
functional, and available everywhere.
DYNAMIC : MODULAR : PRODUCTIVE
Part 2

• Dynamically Typed with an optional/inferred/coercion type
system
• Language supports Classes, Scripting, and Templating
• Modern Java interop (invokeDynamic)
• Highly functional: context-aware closures, pure lambdas, and more
• Built-in Framework with many concerns
• Small, lightweight, and modular (8mb)
• Open Beta Summer 2024 (27 releases)
• RC.1 February -> Final 1.x May 2025 at www.intothebox.org
What is it?
https://www.ortussolutions.com/blog/why-boxlang-when-you-have-kotlin-groovy-scala-and-more
RUNTIME
Application
Service
Async
Service
Cache
Service
Component
Service
Datasource
Service
Function
Service
Interceptor
Service
Module
Service
Scheduler
Service

Multi-Runtime Architecture
Any OS
Docker MiniServer CommandBox Servlet Lambda Azure Android WebAssembly
In Dev Soon Soon
8 MB
9 MB 8 MB
15 MB
15 MB
160 MB

Multi-Parsers
• A way to split with the old and bring in the new
• JIT Transpiler or CLI Transpiler
• Supported Languages
• ColdFusion/CFML (Completed)
• COBOL (In Progress)
• Groovy (In Planning)
• Incorporate legacy applications + modernize them.
.cfc, .cfm
.bx, bxs, bxm

Scopes
// scripting + templates
name = “boxlang”
// Functions have a local + arguments + surrounding scopes
function save( name ){
var transactional = true
// pass scopes around
saveData( arguments )
}
// Treat scopes like maps
function getMemento(){
return variables
.filter( key, value -> !isCustomFunction( value ) )
}
// Classes have three encapsulation scopes
Class{
this.publicVar = “public”
variables.privateVar = “private”
static.field = 123
}
• All variables are inside of scopes
• Scopes backed by concurrent maps
• Each execution context can have di
ff
erent scopes
• Scripts
• Variables
• Functions
• Arguments, local, + surrounding scopes
• Classes
• This (public), variables (private), static
• Global Scopes + Life-Span
• Application, request, server, session, etc
• Custom Scopes

Enhanced Types with Member functions
fruits = [ "apple", "bananas", "pears" ]
println( fruits.len() )
data = fruits
.append( "orange" )
.filter( item -> item.findNoCase( "an" ) )
.each( item -> println( item ) )
.toJSON()
"apple,bananas,pears"
.listToArray()
.filter( item -> item.findNoCase( "an" ) )
.each( item -> println( item ) )
person = { fname: "box", lname: "lang", age: 1 }
person.fullName = () => person.fname & person.lname
println( person.fullName() )
• All Java types plus:
• Arrays
• Structs (ordered, unordered, weak, soft, etc)
• Queries (Typed Columns)
• DateTime (java.time)
• Numeric (
fl
oat, short, int, double, bigdecimal)
• XML (Enhanced Maps)
• All auto-castable, dynamic and functional
• Fluent and Functional via member functions

Functions
// Java
public int sum( int a, int b){
return a + b;
}
// BoxLang no types
function sum( a, b ){
return a + b
}
// Optional Generic types
Numeric function sum( numeric a, numeric b ){
return a + b
}
// Optional Specific types
int function sum( int a, int b ){
return a + b
}
• All functions `public` by default
• All return types `any` by default
• All argument types `any` by default
• What is any????
• 2 types of type inference
• Compile-Time
• Runtime
• Auto-casting
• Type Promotions
• Type Coercion

Functions Arguments
// Java
Public void repeat( String str, int count, String separator ){}
repeat( “hello”, 2, “;” )
// BoxLang
repeat( required str, count:5, separator:“;” ){}
// Call with defaults
repeat( “hello” )
// Call with argument binding
myMap = { str : “test”, separator : “,” }
repeat( argumentCollection:myMap )
• Required arguments
• Default values
• Argument binding
• Structs (Maps)
• Arrays

Null Coalescence Operator + Safe Navigation
// Java
Int getLength( String myString ){
if( myString != null ){
return myString.length()
}
return 0;
}
function getLength( myString ){
return myString.length() ?: 0
}
Name = event.headers?.name // null
Email = user.?getEmail() ?: “nada”
• Elvis Operator
• Any falsey expression can be used
• Entire left hand expression detection
• Safe Navigation
• Any dererferencable object
• Arrays, structs, objects, etc.

String Interpolation
function toString(){
return “Song{id=“#id#”, title=“#title#”, author=“#author#”}
}
function buildTemplate(){
return “{
Id : “#id#”,
Title : “#title#”,
Author : “#getAuthor(id)#”
}“
}
myMap = { id: createUUID(), title: “title”, author: “Luis” }
buildTemplate( argumentCollection : myMap )
• Tired of string concatenation
• Not anymore!
• Anything between #expression#
• “ For big strings with / without line breaks
• Combine with scopes to do bindings!

Closures & Lambdas & UDFs
function toString(){
return “Song{id=“#id#”, title=“#title#”, author=“#author#”}
}
variables.toString = variables.getString
function delayFunction(){
return () => dowork()
}
runAsync( () -> startWork() )
.then( result => computeMoreWork( result ) )
.then( result => sendOrder( result ) )
• Context-aware closures
• Pure functions: lambdas
• UDFs
• Automatic coercion to Java Lambdas
• Any signature

Classes
class {
Property firstName;
Property lastName;
Property numeric age setter=false;
}
Person = new Person( “Luis”, “Majano”, “45” )
println( person.getFirstName() )
person.toJSON()
• Automatic constructor
• Automatic toString(), equals() and hashCode()
• Automatic getters and setters
• JSON / YAML / Custom First-Class
• toJson()

$bx - MetaProgramming
Person = new Person()
writedump( person.$bx.meta )
callJavaClass( person.$bx.$class )
Class{
Property importantData;
Variables
.$bx
.registerChangeListener(
“importantData”,
(Key, newValue, oldValue) => clearCache()
)
}
myMap = { name : “Luis”, born : now() }
myMap
.$bx
.registerChangeListener( (key, newValue, oldValue) => doSomething() )
• Available on ANY object
• Includes
• Metadata
• Class Representation
• Meta Methods
• Change listeners
• Inject properties
• Remove properties
• Inject methods
• Remove Method

Templating Language
• Best of JSP, Blade, GSP, and CFML
• Create your own `<bx:MyTag>` easily
• Import collections of tags
• Use BIFs
• Nesting
• Data Encapsulation
• Much More

<
d
i
v
c
l
a
s
s
=
"
b
x
-
d
u
m
p
"
>
<
t
a
b
l
e
c
l
a
s
s
=
"
b
x
-
t
a
b
l
e
S
t
"
t
i
t
l
e
=
"
#
p
o
s
I
n
C
o
d
e
#
"
>
<
c
a
p
t
i
o
n
c
l
a
s
s
=
"
b
x
-
d
h
S
t
"
r
o
l
e
=
"
b
u
t
t
o
n
"
t
a
b
i
n
d
e
x
=
"
0
"
o
p
e
n
>
<
s
t
r
o
n
g
>
Q
u
e
r
y
:
#
v
a
r
.
r
e
c
o
r
d
c
o
u
n
t
#
r
o
w
s
<
/
s
t
r
o
n
g
>
<
/
c
a
p
t
i
o
n
>
<
t
h
e
a
d
>
<
t
r
>

<
t
h
>
#
e
n
c
o
d
e
F
o
r
H
T
M
L
(
c
o
l
u
m
n
)
#
<
/
t
h
>

<
/
t
r
>
<
/
t
h
e
a
d
>
<
t
b
o
d
y
>

<
t
r
>

<
t
d
>
#
e
n
c
o
d
e
F
o
r
H
T
M
L
(
v
a
r
[
c
o
l
u
m
n
]
)
#
<
/
t
d
>

<
/
t
r
>

<
/
t
b
o
d
y
>
<
/
t
a
b
l
e
>
<
/
d
i
v
>

BoxLang Framework
RUNTIME
Application
Service
Async
Service
Cache
Service
Component
Service
Datasource
Service
Function
Service
Interceptor
Service
Module
Service
Scheduler
Service

BoxLang Modules
• Inspired by our HMVC Framework: ColdBox
• Not OSGI
• Core Runtime with lightest possible footprint
• Hierarchical Class Loaders
• Taps into the language life-cycle via events
• Write them in Java or BoxLang or Both!
• Executable as CLI packages
• Integrates with Maven/Gradle

BoxLang Modules
FTP/SFTP
Email
Sending
ESAPI UI Forms
Password
Encryption
JDBC
Image
Manipulation
PDF Tooling CSV /
Spreadsheet
INI OSHI YAML

Web Application Framework
• Inspired by Java contexts
• Create in
fi
nite segregated applications in a single deployment by using one
fi
le
• Application.bx
• Life Cycle methods:
• applicationStart(), applicationEnd(), sessionStart(), sessionEnd(),
requestStart(), request(), requestEnd(), onError(), etc.
• Data Sources, class loading, application scopes, security, settings, etc.
• Sub applications
• Highly con
fi
gurable and Highly portable

Event-Driven Language
• Interceptors for the language, application, and request
• The best way to scale the language
• Listen to the entire or speci
fi
c language life-cycles
• Modules can listen/collaborate events
• boxAnnounce(), boxAnnounceAsync() : CompletableFuture
Event Channels
Event Producers
Event
Event
Event
Event Consumers
Event
Event
Event

BoxLang Lambda Runtime
• Leverages the Java SDK
• BoxLang implements the AWS Runtime Handler
• ortus.boxlang.runtime.aws.LambdaRunner::handleRequest
• Bootstraps the runtime (Con
fi
gurations + Modules + Dependencies)
• Tuned for fast startups
• Acts as a Front Controller
• Inspects incoming Request
• Automatic logging/tracing
• Automatic error handling
• Delegates to the appropriate Class + Function
• Automatic response handling

• Implement Handlers as BoxLang Classes
• Class by Convention: Lambda.bx
• 1 method by convention: run( event, context, response )
• 1 Optional Application.bx for life-cycles or activating framework features
• Expose more BoxLang functions via AWS Headers
• x-bx-function : {functionName}
• Expose more BoxLang classes as AWS URL Endpoints
• /{route} : {route}.bx
BoxLang Lambda Runtime

• Run() function by convention
• Event = Map of the request
• Context = AWS Context Object
• Response = Map of response data (optional)
• Return:
• Nothing
• Simple Value
• Complex Values
BoxLang Lambda

BoxLang Lambda Template
• Turnkey Template for Lambda Development
• Unit + Integration Testing
• JUnit/TestBox + SAM
• Gradle
• Java Dependencies + Packaging + Testing
• CommandBox
• BoxLang Dependencies
• Github Actions CI
• Testing -> Packaging -> Deployment
https://github.com/ortus-boxlang/bx-aws-lambda-template

Building Dynamic AWS Lambda Applications with BoxLang

Recommended

More Related Content

Similar to Building Dynamic AWS Lambda Applications with BoxLang (20)

More from Ortus Solutions, Corp (20)

Recently uploaded (20)

Building Dynamic AWS Lambda Applications with BoxLang