Download - Groovy Architectural Flexibility

Architectural Flexibility

using Groovy

David Dawson

CEO, Principal Consultant

[email protected]

@davidthecoder

What kind

of

Code is Best?

Object Oriented

or

Functional?

Strongly Typed

or

Weakly Typed?

To Meta

or

Not to Meta?

Data

or

Type

●Non functional requirements

[tx/ sec, latency, deployment etc]



●Developer Comprehension




●Coding Style




●Coding Style

●Data Model(s)




●Coding Style

●Data Model(s)

●Others … [bias...?]

Forces on Code

What kind

of

Code is Best?

WrongQuestion

Core Domain

Application PoliciesBusiness Rules

Core Domain


REST

Core Domain


REST

Events

Core Domain


RESTProvided API

Events

Core Domain


RESTProvided API

UserDSL

Events

Context

Core Domain


RESTProvided API

UserDSL

Events

Core Domain


Core Domain


Core Domain

Core Domain


Core Domain

Forces

Core Domain


Core Domain

Forces● Express Type

Core Domain


Core Domain


● Understand Identity

Core Domain


Core Domain



● Use Ubiquitous Language

Core Domain


Core Domain




● Relatively high code churn

OrderMenu

Recipe

OrderMenu

Recipe

orderId

recipeId

menuId

class OrderService {

}

def process( def order ) { if (valid(order)) { dispatch(order) persist(order) return OrderResult.SENT } OrderResult.INVALID //or similar}


}

process( Order order ) { if (valid(order)) { dispatch(order) persist(order) return OrderResult.SENT } OrderResult.INVALID //or similar}

OrderResult


}

process( Order order ) { if (valid(order)) { dispatch(order) persist(order) return OrderResult.SENT } OrderResult.INVALID //or similar}

OrderResultvalidateAndDispatch

Core Domain


REST

Events

Provided API

UserDSL

Events

EventsEvent Processor


Subscription

Subscription

Subscription


Subscription

Subscription

Subscription

Event


Subscription

Subscription

Subscription

Events

Forces

Event Processor


Forces● Performance



● Technically focused, technical language




● No interest in type or identity





● Interest in functionality





● Interest in functionality

● Data/ algorithm oriented

class EventProcessor {

List<Subscription> subscriptions

}

void process(Message message) { subscriptions.findAll { it.canHandle(message) }.each { it.dispatch(message) }}



}

void process(Message message) { subscriptions.findAll { it.canHandle(message) }.each { it.dispatch(message) }}

200k messages : 450ms



}

void process(Message message) { for(Subscription sub in subscriptions) { if(it.canHandle(message)) {

it.dispatch(message) } }}

80ms200k messages : 450ms



}

@CompileStaticvoid process(Message message) { for(Subscription sub in subscriptions) { if(it.canHandle(message)) {

it.dispatch(message) } }}

30ms200k messages : 450ms 80ms

Core Domain


REST

Events

Provided API

UserDSL

Core Domain


REST

Core Domain


RESTDomain Transformer

Core Domain



Forces

Core Domain



Forces● Interested only in integration

Core Domain




● Designed to remove type

Core Domain





● Affinity with Data & Values

Core Domain





● Affinity with Data & Values

● Data Transformation

class OrderTransformer {

}

def send(Message message) { RestMessage msg = New RestMessage()

msg.txt = message.text target.doProcessing(msg)}

msg.txt = message.text target.doProcessing(msg)

def msg=[txt:message.text] target.doProcessing(msg)

def transformer = { target, message ->

def msg=[text:message.text] target.doProcessing(msg) }

def transformer = { message, target ->

def msg=[txt:message.text] target.doProcessing(msg) }

transformer = transformer.curry(aTarget)transformer(text:”Hello GGX!”)

Core Domain


REST

Events

Provided API

UserDSL

UserDSL

UserDSL

Domain SpecificLanguage

UserDSL


Forces

UserDSL


Forces● User Comprehension

UserDSL



● Expressiveness

UserDSL



● Expressiveness

● Ease of Use versus Intuitive

def orders = Order.findAllByUserName(“someone”)

def orders = Order.findAllByUserNameAndOrderTax\BetweenOrOrderValueLessThanAndAddress1Like( “someone”, 5, 6, 15.20, “%Some Street%”)

def orders = Order.findAllByUserNameAndOrderTax\BetweenOrOrderValueLessThanAndAddress1Like( “someone”, 5, 6, 15.20, “%Some Street%”)

def orders = Order.findAll { username == “someone” orderValue in [5 .. 6] address1 =~ “%Some Street%”}

Core Domain


Core Domain




● Relatively high code churn

List<Order> findAuthorisedRecords(User user) {

List<Order> orders = Orders.list()

List<Order> selectedOrders = new ArrayList<>();

for(Order order: orders) { if(order.user == user) { SelectedOrders << order }}

return Collections.sort(selectedOrders)

}


List<Order> orders = Orders.list()

List<Order> selectedOrders = new ArrayList<>();

for(Order order: orders) { if(order.user == user) { selectedOrders << order }}


}


def orders = Orders.list()

def selectedOrders = []

for(def order: orders) { if(order.user == user) { selectedOrders << order }}


}



def selectedOrders = orders.findAll { order.user == user}


}



return orders.findAll { order.user == user}.sort { order.id}

}

List<OrderDetails> findAuthorisedRecords(User user) {


return orders.findAll { it.user == user}.sort { it.id}.collect { it as OrderDetails}

}

Understand Context

Understand Context

Identify Forces

Understand Context

Identify Forces

Drive Code

Reject Dogma

Questions

@davidthecoder

Thank you!

@davidthecoder

Download - Groovy Architectural Flexibility

Top Related