Affordances in Programming Languages

3/20/2014 Affordances
http://localhost:9090/onepage 1/67
Affordances in
Programming Languages
Randy Coulman
Principal Software Engineer
http://randycoulman.com
@randycoulman
randycoulman

Satu Kyröläinen http://www.satukyrolainen.com/affordances/

Affordance
A quality of an object or environment that allows someone to
perform an action.

Nicolas Nova http://www.flickr.com/photos/nnova/2252222949/

William Lindeke http://tcsidewalks.blogspot.com/2009/06/signsoftimes14.html

Yoni Alter http://www.yoniishappy.com/Tubeescalators

Affordances and Software

Amir Rajan (@amirrajan)
Coding Out Loud REST APIs series
http://vimeo.com/channels/659338

Example
Points
Smalltalk > Ruby

class Point
def initialize(x, y)
@x = x
@y = y
end
end
Point.new(3, 4)

http://images.cryhavok.org/d/255622/Polar+and+Cartesian+Bears.jpg

θ
r sinθ
r cosθ
r
x
y
http://upload.wikimedia.org/wikipedia/commons/7/78/Polar_to_cartesian.svg

class Point
def initialize(x, y)
@x = x
@y = y
end
end
Point.new(3, 4)

Point class>>x: anX y: aY
^self new initializeX: anX y: aY
Point>>initializeX: anX y: aY
x := anX.
y := aY
Point x: 3 y: 4

Point class>>
r: radius theta: angleInRadians
^self x: radius * angleInRadians cos
y: radius * angleInRadians sin
Point r: 5 theta: 0.927295

Affordance
Named Constructors

class Point
def self.xy(x, y)
new(x, y)
end
def self.polar(r, theta)
xy(r * Math.cos(theta),
r * Math.sin(theta))
end
private_class_method :new
# ... rest same as before
end
Point.xy(3, 4)
Point.polar(5, 0.927295)

Example
Find/Detect
Smalltalk > Ruby

#(2 4 6 8)
detect: [:each | each odd]
"Unhandled exception: Element Not Found"

[2, 4, 6, 8].find { |n| n.odd? }
# => nil

#(2 4 6 8)
detect: [:each | each odd]
ifNone: [#none]
"#none"

Affordance
Multiple Blocks

[2, 4, 6, 8].find(-> {:none}) { |n|
n.odd?
} # => :none

Linguistic Relativity
a.k.a. The SapirWhorf Hypothesis
"[T]he structure of a language affects the ways in which its
respective speakers conceptualize their world ... or otherwise
influences their cognitive processes."
http://en.wikipedia.org/wiki/Linguistic_relativity

When Code Cries
Cory Foy at SCNA 2012
http://vimeo.com/53986875
What does a language allow you to say?
What does a language force you to say?

The Power and Philsophy of Ruby
Matz at OSCON 2003
http://www.rubyist.net/~matz/slides/oscon2003/mgp00001.html
"Languages are not only tools to communicate, but also tools
to think."

Example
Cleaning Up After Yourself
C++ > Ruby

if ((err = SSLFreeBuffer(&hashCtx)) != 0)
goto fail;
if ((err = ReadyHash(&SSLHashSHA1, &hashCtx)) != 0)
goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &clientRandom)) !=
goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) !=
goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) !=
goto fail;
goto fail;
if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
goto fail;
//...
fail:
SSLFreeBuffer(&signedHashes);
SSLFreeBuffer(&hashCtx);
return err;

#include "support.h"
#include <iostream>
void foo()
{
Resource* resource =
acquireResource();
bar(resource);
if (baz(resource) != 42) return;
std::cout << "Completed successfully!"
<< std::endl;
releaseResource(resource);
}

$ ./broken
Acquiring resource
Caught exception: oops!

#include <iostream>
void foo()
{
Resource* resource = acquireResource();
try
{
bar(resource);
if (baz(resource) == 42)
{
<< std::endl;
}
}
catch(std::exception& e)
{
throw;
}
}

$ ./wordy
Acquiring resource
Releasing resource

#include <iostream>
void foo()
{
Resource* resource = acquireResource();
try
{
bar(resource);
if (baz(resource) == 42)
{
<< std::endl;
}
}
catch(std::exception& e)
{
throw;
}
}

RAII
Resource Acquisition Is Initialization
Acquire resources in the constructor
Release them in the destructor

#include "SafeResource.h"
SafeResource::SafeResource() :
resource(acquireResource())
{
}
SafeResource::~SafeResource()
{
}
Resource* SafeResource::get()
{
return resource;
}

#include "SafeResource.h"
#include <iostream>
void foo()
{
SafeResource resource;
bar(resource.get());
if (baz(resource.get()) != 42) return
<< std::endl;
}

$ ./raii
Acquiring resource
Releasing resource

Affordance
Deterministic Destructors

Ruby doesn't have deterministic destructors.
So what can we do instead?

Blocks!

class SafeResource
def self.acquire
resource = self.new
yield resource
ensure
resource.release
end
def initialize
puts "Acquiring resource"
@resource = Object.new
end
def release
puts "Releasing resource"
@resource = nil
end

require_relative "support"
require_relative "safe_resource"
def foo
SafeResource.acquire do |resource|
bar(resource)
return unless baz(resource) == 42
puts "Completed successfully!"
end
end

$ ruby driver.rb
Acquiring resource
Releasing resource

Example
ImageReader
Smalltalk > Ruby

ImageReader class>>fromFile: aFilename
| readerClass imageStream reader |
imageStream := aFilename readStream binary.
[readerClass := self readerClassFor: imageStream.
readerClass ifNil:
[^self error: 'Unknown image type: ',
aFilename asString].
reader := readerClass on: imageStream]
ensure: [imageStream close].
^reader

ImageReader class>>readerClassFor: imageStream
^self subclasses
detect: [:eachClass |
imageStream reset.
[eachClass canRead: imageStream]
ensure: [imageStream reset]]
ifNone: [nil]

Affordance
Subclass Iteration

class ImageReader
def self.read(filename)
File.open(filename, "rb") do |io|
reader_class = find_reader_class(io)
raise "Unknown image type: #{filename}" unless reader_class
reader_class.new(io)
end
end
#...
end

class ImageReader
#...
def self.find_reader_class(io)
subclasses.find { |reader|
begin
io.rewind
reader.can_read?(io)
ensure
io.rewind
end
}
end
#...
end

class ImageReader
#...
def self.inherited(subclass)
subclasses << subclass
end
def self.subclasses
@subclasses ||= []
end
#...
end

class BMPImageReader < ImageReader
def self.can_read?(io)
io.read(2) == "BM"
end
def read_image
puts "Reading BMP"
end
end

class JPGImageReader < ImageReader
io.read(2) == "xFFxD8".b
end
def read_image
puts "Reading JPG"
end
end

class PNGImageReader < ImageReader
io.read(8) == "x89PNGrnx1An".b
end
def read_image
puts "Reading PNG"
end
end

require_relative "image_readers"
%w{bmp jpg png}.each do |ext|
ImageReader.read("example.#{ext}")
end

$ ruby subclasses.rb
Reading BMP
Reading JPG
Reading PNG

Takeaways

Languages afford certain designs
and inhibit others

Languages influence thought

Learning new languages will
increase your "solution space"

Don't go too far

Want More?
http://randycoulman.com/blog/categories/affordances/

Acknowledgements
Key Technology (http://www.key.net/)
Rogue.rb (@roguerb)
Jen Myers (@antiheroine)

References
The Design of Every Day Things Donald Norman
Coding Out Loud Amir Rajan
Linguistic Relativity Wikipedia article
When Code Cries Cory Foy at SCNA 2012
The Power and Philosophy of Ruby Matz at OSCON 2003

Questions?

Randy Coulman
http://speakerrate.com/randycoulman
http://www.slideshare.net/randycoulman
http://randycoulman.com
@randycoulman
randycoulman

Affordances in Programming Languages

Recommandé

Recommandé

Contenu connexe

Similaire à Affordances in Programming Languages

Similaire à Affordances in Programming Languages (20)

Dernier

Dernier (20)

Affordances in Programming Languages