Your Business. Your Language. Your Code - dpc13

Your business. Your language.
Your code.
Stephan Hochdörfer, bitExpert AG

Your business. Your language. Your code.
About me
 Stephan Hochdörfer
 Head of IT at bitExpert AG, Germany
 enjoying PHP since 1999
 S.Hochdoerfer@bitExpert.de
 @shochdoerfer

Focus on core business values!

Get rid of the "framework speak"!

Trust the framework...

...but understand the underlying technology!

Build your own toolset...

...but focus on communication first!

Work as a team! (Customer included!)

What the customer really wanted?

A common language

A common language
A domain-specific language (DSL)
is a programming language designed
to be useful for a specific task.

A common language: Key characteristic
Identifiable domain

A common language: Key characteristic
„Small language“

A common language
"[…] I do think that the greatest
potential benefit of DSLs comes when
business people participate [...]"
(Martin Fowler)

Domain-specific language: Examples
How does a domain-specific
language look like?

SELECT * from slides WHERE presentationId = 4711 ORDER BY
pageNo;
Domain-specific language: SQL

Feature: Serve coffee
In order to earn money
Customers should be able to
buy coffee at all times
Scenario: Buy last coffee
Given there are 1 coffees left in the machine
And I have deposited 1 dollar
When I press the coffee button
Then I should be served a coffee
Domain-specific language: Gherkin

package { 'screen' :
ensure => present,
}
include apache
apache::vhost { 'myapp.loc' :
docroot => '/srv/myapp.loc/webroot/'
}
host { 'myapp.loc':
ip => '127.0.1.1'
}
Domain-specific language: Puppet

{
"require": {
"silex/silex": "v1.0.0",
"zendframework/zend-mail": "2.1.5",
"monolog/monolog": "1.5.0"
},
"require-dev": {
"phpunit/phpunit": "3.7.19",
"phing/phing": "2.5.0"
}
}
Domain-specific language: Composer

Domain-specific language: Doctrine
/** @Entity **/
class Slides
{
/**
* @OneToOne(targetEntity="Presentation")
* @JoinColumn(name="presentation_id",
* referencedColumnName="id")
**/
private $presentation;
// ...
}
/** @Entity **/
class Presentation
{
// ...
}

<?php
echo "I am a DSL, too!";
Domain-specific language: PHP

Why using a DSL?

Why using a DSL?
Increase your own productivity

Why using a DSL?
Increase in code quality

Why using a DSL?
Ignore the implementation details,
focus on the domain aspects

$file = '/path/to/a/file.csv';
$mimepart1 = new MimePart();
$mimepart1->setContent(file_get_contents($file));
$mimepart1->setFilename(basename($file));
$mimepart2 = new MimePart();
$mimepart2->setText('Sample mail body.');
$multipart = new MimeMultipart();
$multipart->addPart($mimepart1);
$multipart->addPart($mimepart2);
$message = new MimeMessage();
$message->setFrom('foo@bar.org');
$message->addTo('bar@foo.org');
$message->setSubject('Hello');
$message->setContent($multipart);
$transport = new MailTransport();
$transport->send($mail);
Why using a DSL? Non-DSL example

DSL types: You have to decide

DSL types: You have to decide
Internal DSL
vs.
External DSL

DSL types: Internal DSL

DSL types: Internal DSL
Fluent API, Expression Builder,
Functions, Closures, Annotations

Internal DSL: The Fluent API

A fluent interface is an implementation
of an object oriented API that aims to
provide for more readable code.

$msg = new MailMessage();
$msg->from('foo@bar.org')
->to('bar@foo.org')
->subject('Hello')
->body('Sample mail body.')
->attachFile($file)
->sendWith(new SmtpTransport());

class MailMessage {
protected $from;
protected $to;
public function from($from) {
$this->from = $from;
return $this;
}
public function to($to) {
$this->to = $to;
return $this;
}
// [...]
}

Internal DSL: Expression Builder

Provides a fluent interface
on top of an existing API.

class MimeMessage {
public function setFrom($from) {
}
public function addTo($to) {
}
public function setSubject($subject) {
}
public function setContent(MimeMultipart $content) {
}
}

class MailBuilder {
protected $msg;
protected $multipart;
public function __construct() {
$this->msg = new MimeMessage();
$this->multipart = new MimeMultipart();
}
$this->msg->setFrom($from);
return $this;
}
public function attachFile($file) {
$part = new MimePart();
$part->setContent(file_get_contents($file));
$part->setFilename(basename($file));
$this->multipart->addPart($part);
return $this;
}
// [...]
}

$msg = new MailBuilder();
$msg->from('foo@bar.org')
->to('bar@foo.org')
->subject('Hello')
->attachFile($file)

Internal DSL: Expression Builder (Improved)
class MailBuilder {
protected $msg;
protected $parts;
$this->msg = new MimeMessage();
$this->parts = array();
}
$this->msg->setFrom($from);
return $this;
}
public function attachFile($file) {
$builder = new PartBuilder($this);
$this->parts[] = $builder;
return $builder;
}
// [...]
}

class PartBuilder {
protected $part;
$this->part = new MimePart();
}
public function content($content) {
$this->part->setContent($content);
return $this;
}
public function filename($filename) {
$this->part->setFilename($filename);
return $this;
}
// [...]
}
Internal DSL: Expression Builder (Improved)

Internal DSL: Functions

Using a combination of function calls
as a sequence of statements.

message();
from('foo@bar.org');
to('bar@foo.org');
subject('Hello');
body('Sample mail body.');
attachFile($file);
sendWith(new SmtpTransport());

Internal DSL: Nested Functions

Using nested function calls to reflect
the hirarchic nature of the language.

message(
header(
from('foo@bar.org'),
to('bar@foo.org'),
subject('Hello')
),
body('Sample mail body.'),
attachments(
file($file)
),
sendWith(new SmtpTransport())
);

$file2 = '/path/to/a/file2.csv';
message(
header(
[
from('foo@bar.org'),
to('bar@foo.org'),
subject('Hello')
]
),
body('Sample mail body.'),
attachments(
[
file($file),
file($file2)
]
),
sendWith(new SmtpTransport())
);
Internal DSL: Nested Functions (Improved)

Internal DSL: Closure

A function or reference to a function
together with a referencing environment.

$fname = '/path/to/a/file.csv';
$fname2 = '/path/to/a/file2.csv';
$msg = new MailMessageBuilder();
$msg->header(function($header){
$header->from('foo@bar.org')
->to('bar@foo.org')
->subject('Hello');
})
->attach(function($file){
$file->setContent(file_get_contents($fname)
->setFilename(basename($fname);
})
->attach(function($file){
$file->setContent(file_get_contents($fname2)
->setFilename(basename($fname2);
})

Internal DSL: Annotations

"An annotation is metadata
attached to your code."
(Rafael Dohms)

/** @Entity **/
class Slides
{
/**
* @OneToOne(targetEntity="Presentation")
* @JoinColumn(name="presentation_id",
* referencedColumnName="id")
**/
private $presentation;
// ...
}
/** @Entity **/
class Presentation
{
// ...
}

class MyCustomController {
// [...]
public function adminAction() {
$user = $this->authService->getLoggedInUser();
if(!$user->hasRole('ROLE_ADMIN')) {
throw new AccessDeniedException();
}
// proceed with main logic...
}
}

class MyCustomController {
// [...]
/**
* @Allow(roles="ROLE_ADMIN")
*/
public function adminAction() {
// proceed with main logic...
}
}

External DSL

External DSL
External DSLs provide a
greater syntactic freedom

External DSL: Language development

Code generation

Code generation
From DSL to „code“ ;)

Code generation
Template Generation
vs.
Transformer Generation

Code generation: Template Generation
<?php
class [className] {
protected $service;
public function __construct([serviceType] $service) {
$this->service = $service;
}
}

Code generation: Transformer Generation
<?php
renderPageHeader();
renderMenubar();
renderProducts();
renderFooter();
Output driven approach:

Code generation: Transformer Generation
<?php
foreach($products as $product) {
renderName($product);
renderImage($product);
renderPrice($product);
}
Input driven approach:

Internal DSL vs. External DSL
What to choose?

Problems with DSLs

Problems with DSLs
Yet-Another-Language-To-Learn
syndrome

Problems with DSLs
Depending on the DSL complexity
creating a language can be cost intense

Famous final words ;)
"Any fool can write code that a
computer can understand. Good
programmers write code that
humans can understand."
(Martin Fowler)

Recommended books

Credits
http://robonthemoon.wordpress.com/2009/11/24/what-the-customer-really-wanted-–-happ
y-thanksgiving/

Your Business. Your Language. Your Code - dpc13

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à Your Business. Your Language. Your Code - dpc13

Similaire à Your Business. Your Language. Your Code - dpc13 (20)

Plus de Stephan Hochdörfer

Plus de Stephan Hochdörfer (20)

Dernier

Dernier (20)

Your Business. Your Language. Your Code - dpc13