7. “ Greek columns and their entablatures were at
first entirely of timber, with terra-cotta
decorations in the upper trabeation, but were
converted into stone quite early in the
[Hellenic] period, about 600 BC. The translation
was quite direct, timber forms being imitated in
stonework with remarkable exactness. For this
reason, Greek architecture sometimes has been
called a ‘carpentry in marble’…
Banister Fletcher
A History of Architecture
14. Skeuomorph
A skeuomorph is a design feature found on an
imitation, pastiche or homage that was necessary
only to the original. Often used for the sake of
familiarity, they are details that have moved from
function to form.
Tom Petty
hipstercheerleaders.com
15. Metaphor
In cognitive linguistics, conceptual metaphor, or
cognitive metaphor, refers to the understanding
of one idea, or conceptual domain, in terms of
another, for example, understanding quantity in
terms of directionality (e.g. "prices are rising").
Wikipedia.org
Conceptual Metaphors
16. “ The concepts that govern our thought are not just
matters of the intellect. They also govern our everyday
functioning, down to the most mundane details. Our
concepts structure what we perceive, how we get
around in the world, and how we relate to other
people. Our conceptual system thus plays a central role
in defining our everyday realities. If we are right in
suggesting that our conceptual system is largely
metaphorical, then the way we thinks what we
experience, and what we do every day is very much a
matter of metaphor.
George Lakoff and Mark Johnson
Metaphors We Live By
51. application
What makes the app feel fast to the user?
52. application
Time to first render
Time to first interaction
Time between interactions
53. application
Three mutually reinforcing techniques:
Code profiling for performance optimization
Threading/concurrency for user interactions
Client-side caching for everything else
54. application
Use the profiler to see where you’re slow
Write faster code where you see big gains
Run long operations in parallel
Keep local copies of everything you need
63. application
What should you be caching locally?
Security credentials or tokens
Last user session data
MRU (Most recently used)
MFU (Most frequently used)
LFC (Least frequently changed)
API write operations
Graceful fallbacks for failed API calls
64. application
Issues do remain
Can’t hit local cache on first use of app
Receiving the right shape of data
66. network
The radio network is a
high-latency,
limited-resource environment.
67.
68. network
Speed and battery usage
are both important dimensions of
mobile performance
69.
70. network
Intermittent usage of the radio for
pingbacks
keep-alives
analytics
screen rotations
will slow you down and burn battery.
71.
72. network
A better approach:
Bundling, piggybacking, and pipelining
73. network
Connection Tail
setup time
2 sec n sec 15 sec
Data
Idle transfer
Battery cost of a series of small API requests
90 sec of radio use and battery burn
Bundling a set of API requests
19 sec
74. network
Intermittent analytics and keep-alives
90 sec of radio use and battery burn
Piggybacking on a set of user API requests
19 sec
75. network
API calls in series
200 ms 200 ms 200 ms 200 ms 200 ms
1000 ms
API pipelining
78. database
What were our old
database optimization tricks
that we can apply to Internet data?
79. database
Stored Procedures
Queueing
Denormalization
Result Sets
80. database
What is a Stored Procedure in this world?
Server-side code that executes complex operations
Ones that should happen right next to the data
Where you need high compute and low latency
Could be written in node.js, ruby, java, python, c#
81. database
Where does a Stored Procedure run in this world?
82. database
Where does a Stored Procedure run in this world?
Probably in a cloud
83. database
Once you’ve built this architectural layer
you gain a lot of control
84. database
You can deal with queueing, denormalization,
and manage result sets properly.
85. database
Queueing enables you to break the
request/response pair into separate pieces
You may even be able to tell the client when to call
you back for the result
Making your requests to this queueing layer also lets
you serve from a cloud-side cache if you have one
86. database
Denormalization refers to writing multiple indexes
in order to optimize query performance
Where your app relies on your own data, don’t
make it wait for slow queries
Remember, in the cloud, storage is cheap and easy
to obtain – write data as often as needed to improve
query speeds.
87. database
Managing result sets to save bandwidth and
response time means limiting cursor size by default
This can be complementary to the caches you keep
around, since a massive API result is cheap to
manage in the cloud
and can be trickled back to the app in bite-size
chunks.
88. database
Managing result sets to save processor time for the
client is an option as well.
What would happen if you could focus on
app-shaped data?
89. XML in Javascript
var parseXml;
if (typeof window.DOMParser != "undefined")
{
parseXml = function(xmlStr) {
return (new window.DOMParser()).parseFromString(xmlStr,"text/xml");
};
}
else if (typeof window.ActiveXObject != "undefined" &&
new window.ActiveXObject("Microsoft.XMLDOM"))
{
parseXml = function(xmlStr) {
var xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async = "false";
xmlDoc.loadXML(xmlStr);
return xmlDoc;
};
}
else { throw new Error("No XML parser found"); }
var xml = parseXml("<result>true</result><count>1</count>");
alert(xml.documentElement.nodeName);
90. JSON in Javascript
var json = '{"result":true,"count":1}',
obj = JSON.parse(json);
alert(obj.count);
So now we make them out of concrete!What’s even funnier is that since we discovered the Greek columns so long after they were used, the gilding and brightly colored paint used on them had faded, so we associate white columns with eminence and classical majesty… when they in fact were never so pale.
Just in the last twenty years, we’ve gone from writing code on a single PC or Mac that will run on a single PC or Mac and its local filesystem -> writing code on a single PC that will run simultaneously on several PCs, coordinated by a shared database -> writing code on a single PC that will run on a single server and its local database while sending UI files to any PC or Mac that can access the server -> writing code as a team on several different PCs that will run partially on {one or more servers in a cluster and their shared database plus other network-addressable applications such as file servers or ERP/CRM systems} and partially in the browser app sandbox on any PC or Mac that can access the server cluster -> writing code on a single Mac that will run on a single iPhone -> writing code as a team on several different PCs and Macs that will run partially on a single iPhone and partially on one or more servers in a cluster and their shared database plus other network-addressable applications such as file servers, ERP/CRM systems, Twitter, Facebook, Salesforce, or eBay -> writing code as a team on several different PCs and Macs that will run partially on an iPhone, an iPad, an Android phone, a PC, and a Mac and partially on one or more servers in a cluster and their shared database plus other network-addressable applications such as file servers, ERP/CRM systems, Twitter, Facebook, Salesforce, or eBay.
We called it client-server, and it was good
Then we found more servers we needed to get data from
And then we delivered it over the internet in web pages or sometimes just a longer wire (which often broke apps due to WAN/VPN latency).
And then the computers got smaller so people started to move around and work from anywhere
In the beginning, there was a smartphone
Then Apple made phones REALLY smart
So of course we wanted Twitter on our phone
And Facebook. And why can’t we get our work done on this too?
And pretty quickly we ended up back heree
But it got even more complex because we need to support many different devices.[discuss shift from MVC on a web server to “exploded model” – ‘some people call this a distributed model, I prefer exploded to show just how distributed it really is – not just on-prem distribution but to 3rd parties like Salesforce, Facebook, et al]
Issues remain – can’t hit local cache on first use of the app; important in a world of disposable apps and disposable devices. Are we getting the right shape of data at the right time or are we getting more than we need or spending time reshaping it?
Issues remain – can’t hit local cache on first use of the app; important in a world of disposable apps and disposable devices. Are we getting the right shape of data at the right time or are we getting more than we need or spending time reshaping it?
http://www.research.att.com/articles/featured_stories/2011_03/201102_Energy_efficient?fbid=XyFGnPzW0TV“A Call for More Energy-Efficient Apps”
Issues remain – can’t hit local cache on first use of the app; important in a world of disposable apps and disposable devices. Are we getting the right shape of data at the right time or are we getting more than we need or spending time reshaping it?
http://www.research.att.com/articles/featured_stories/2011_03/201102_Energy_efficient?fbid=XyFGnPzW0TV“A Call for More Energy-Efficient Apps”
Issues remain – can’t hit local cache on first use of the app; important in a world of disposable apps and disposable devices. Are we getting the right shape of data at the right time or are we getting more than we need or spending time reshaping it?
Issues remain – can’t hit local cache on first use of the app; important in a world of disposable apps and disposable devices. Are we getting the right shape of data at the right time or are we getting more than we need or spending time reshaping it?
Adapted from http://www.research.att.com/articles/featured_stories/2011_03/201102_Energy_efficient?fbid=XyFGnPzW0TV
Adapted from http://www.research.att.com/articles/featured_stories/2011_03/201102_Energy_efficient?fbid=XyFGnPzW0TV
Adapted from http://www.research.att.com/articles/featured_stories/2011_03/201102_Energy_efficient?fbid=XyFGnPzW0TV
