Profile

Cover photo
Joshua Hou
130 followers|12,915 views
AboutPostsPhotosVideos

Stream

Joshua Hou

Shared publicly  - 
 
 
Dizzying but invisible depth

You just went to the Google home page.

Simple, isn't it?

What just actually happened?

Well, when you know a bit of about how browsers work, it's not quite that simple. You've just put into play HTTP, HTML, CSS, ECMAscript, and more. Those are actually such incredibly complex technologies that they'll make any engineer dizzy if they think about them too much, and such that no single company can deal with that entire complexity.

Let's simplify.

You just connected your computer to www.google.com.

Simple, isn't it?

What just actually happened?

Well, when you know a bit about how networks work, it's not quite that simple. You've just put into play DNS, TCP, UDP, IP, Wifi, Ethernet, DOCSIS, OC, SONET, and more. Those are actually such incredibly complex technologies that they'll make any engineer dizzy if they think about them too much, and such that no single company can deal with that entire complexity.

Let's simplify.

You just typed www.google.com in the location bar of your browser.

Simple, isn't it?

What just actually happened?

Well, when you know a bit about how operating systems work, it's not quite that simple. You've just put into play a kernel, a USB host stack, an input dispatcher, an event handler, a font hinter, a sub-pixel rasterizer, a windowing system, a graphics driver, and more, all of those written in high-level languages that get processed by compilers, linkers, optimizers, interpreters, and more. Those are actually such incredibly complex technologies that they'll make any engineer dizzy if they think about them too much, and such that no single company can deal with that entire complexity.

Let's simplify.

You just pressed a key on your keyboard.

Simple, isn't it?

What just actually happened?

Well, when you know about bit about how input peripherals work, it's not quite that simple. You've just put into play a power regulator, a debouncer, an input multiplexer, a USB device stack, a USB hub stack, all of that implemented in a single chip. That chip is built around thinly sliced wafers of highly purified single-crystal silicon ingot, doped with minute quantities of other atoms that are blasted into the crystal structure, interconnected with multiple layers of aluminum or copper, that are deposited according to patterns of high-energy ultraviolet light that are focused to a precision of a fraction of a micron, connected to the outside world via thin gold wires, all inside a packaging made of a dimensionally and thermally stable resin. The doping patterns and the interconnects implement transistors, which are grouped together to create logic gates. In some parts of the chip, logic gates are combined to create arithmetic and bitwise functions, which are combined to create an ALU. In another part of the chip, logic gates are combined into bistable loops, which are lined up into rows, which are combined with selectors to create a register bank. In another part of the chip, logic gates are combined into bus controllers and instruction decoders and microcode to create an execution scheduler. In another part of the chip, they're combined into address and data multiplexers and timing circuitry to create a memory controller. There's even more. Those are actually such incredibly complex technologies that they'll make any engineer dizzy if they think about them too much, and such that no single company can deal with that entire complexity.

Can we simplify further?

In fact, very scarily, no, we can't. We can barely comprehend the complexity of a single chip in a computer keyboard, and yet there's no simpler level. The next step takes us to the software that is used to design the chip's logic, and that software itself has a level of complexity that requires to go back to the top of the loop.

Today's computers are so complex that they can only be designed and manufactured with slightly less complex computers. In turn the computers used for the design and manufacture are so complex that they themselves can only be designed and manufactured with slightly less complex computers. You'd have to go through many such loops to get back to a level that could possibly be re-built from scratch.

Once you start to understand how our modern devices work and how they're created, it's impossible to not be dizzy about the depth of everything that's involved, and to not be in awe about the fact that they work at all, when Murphy's law says that they simply shouldn't possibly work.

For non-technologists, this is all a black box. That is a great success of technology: all those layers of complexity are entirely hidden and people can use them without even knowing that they exist at all. That is the reason why many people can find computers so frustrating to use: there are so many things that can possibly go wrong that some of them inevitably will, but the complexity goes so deep that it's impossible for most users to be able to do anything about any error.

That is also why it's so hard for technologists and non-technologists to communicate together: technologists know too much about too many layers and non-technologists know too little about too few layers to be able to establish effective direct communication. The gap is so large that it's not even possible any more to have a single person be an intermediate between those two groups, and that's why e.g. we end up with those convoluted technical support call centers and their multiple tiers. Without such deep support structures, you end up with the frustrating situation that we see when end users have access to a bug database that is directly used by engineers: neither the end users nor the engineers get the information that they need to accomplish their goals.

That is why the mainstream press and the general population has talked so much about Steve Jobs' death and comparatively so little about Dennis Ritchie's: Steve's influence was at a layer that most people could see, while Dennis' was much deeper. On the one hand, I can imagine where the computing world would be without the work that Jobs did and the people he inspired: probably a bit less shiny, a bit more beige, a bit more square. Deep inside, though, our devices would still work the same way and do the same things. On the other hand, I literally can't imagine where the computing world would be without the work that Ritchie did and the people he inspired. By the mid 80s, Ritchie's influence had taken over, and even back then very little remained of the pre-Ritchie world.

Finally, last but not least, that is why our patent system is broken: technology has done such an amazing job at hiding its complexity that the people regulating and running the patent system are barely even aware of the complexity of what they're regulating and running. That's the ultimate bikeshedding: just like the proverbial discussions in the town hall about a nuclear power plant end up being about the paint color for the plant's bike shed, the patent discussions about modern computing systems end up being about screen sizes and icon ordering, because in both cases those are the only aspect that the people involved in the discussion are capable of discussing, even though they are irrelevant to the actual function of the overall system being discussed.

CC:BY 3.0
1
Add a comment...

Joshua Hou

Shared publicly  - 
 
Selecting audio output devices in ALSA
1
Add a comment...

Joshua Hou

Shared publicly  - 
 
Koushik Dutta originally shared:
 
"Extreme programming, that's like RAID 0 for your brain."
1
Add a comment...

Joshua Hou

Shared publicly  - 
 
hell yes, 275 users now
4
Kelly Dunn's profile photo
 
Nice!
Add a comment...

Joshua Hou

Shared publicly  - 
1
Add a comment...

Joshua Hou

Shared publicly  - 
 
Peter Magnusson originally shared:
 
TL;DR: New pricing postponed to Nov 1, instance hour discount extended to Dec 1, Python 2.7 expected by Dec 1, your bill is likely to go up but less than you fear, plus an analysis of why App Engine is still a great deal.

I’m the Engineering Director at Google responsible for App Engine. Nice to meet you!

We’re excited about coming out of preview and becoming a fully supported Google product. Besides new features, a 99.95% SLA, new Terms of Service, paid support, and monthly invoicing, we’re also changing the pricing model. We rolled out “side-by-side” billing last week to all App Engine developers, and sent an email with accompanying information, showing the predicted effects of the new pricing on all applications.

This has created a bit of consternation. I’d like to take the opportunity to provide some commentary on two topics: the timeline, and the price increase per se.

First topic, the timeline.

Many developers feel that they are being given too little time to make adjustments. We announced the new prices in May, and we thought the side-by-side billing would be just the next phase; instead, for many (arguably most) developers the side-by-side billing is just the start of their adjustment.

It’s clear we were wrong: expecting developers to figure out their future costs from information in the admin console was simply too obtuse. We made a classic error: we’re too familiar with our own product.

So I apologize: we should have realized this and put out a version of side-by-side billing much sooner. But this is easy enough to fix: we’ll just give you more time. So instead of turning on the billing in the second half of September, we are giving developers more time to fine tune their application by moving that date to November 1st.

Another aspect of the timeline that has caused concern is the uncertainty about the availability of Python 2.7, which will bring concurrent request support to our Python developers (it’s already in place for Java). We added a 50% instance price discount to compensate for the delay, and said we would remove that discount on November 20th. We’ve decided that we’ll extend that discount to December 1st, by which time we expect to have Python 2.7 available.

Second topic, the pricing increase per se.

The vision for Google App Engine is to provide a development environment for cloud applications to run on Google’s infrastructure. In particular, if you build on App Engine, it should be:

* free to get started and easy to use
* simple to make it scalable
* trivial to maintain it

App Engine is a classical case of platform computing trade-offs. What would you like? High scalability, ease of use, low maintenance, high reliability, security? Pick any two and somebody can make it super cheap. But if you want three or four, or all five, things become a little more dicey. With App Engine we are targeting doing all five at the same time, because we think that’s what cloud application developers ultimately want, and we think that’s what the future of cloud computing entails. And we’ve decided to package that offering into a free tier and two paid tiers:

* The generous free tier that App Engine has been offering has remained unique in the industry. We will continue to offer a free tier: a small web application with low traffic should not cost anything to run on App Engine. The new free quota levels are lower than before, so many pre-existing free applications will require tuning, however the principle will remain: App Engine is the only major platform to offer a free tier that’s not time-limited. If you have a small app that you can’t get under the free quotas, post in our forums and we’ll try to help. (But please try to tune it first.)
* The paid tier will charge for resource usage, with a minimum $9/month to enable the 99.95% SLA. And that SLA does not carve-out time for maintenance windows: App Engine can be upgraded without planned downtime for your app. The pricing in the paid tier is structured so that the vast majority of applications will find their total cost of ownership (TCO) to be lower than the competition. If you find that this is not the case for you, then feel free to share your calculations with us. The second paid tier, premier accounts, adds operational support and monthly invoicing.

Our goal is to make the best possible cloud application platform for developers. The feedback we’ve received over the years is that people want things like great reliability, more features, quicker bug fixes, fewer restrictions, etc. We can deliver all these things but it requires App Engine to become a sustainable product for Google. To be clear, we’re not in the business of selling cycles. The vast majority of our costs are in the talented engineers that develop, maintain, operate, and support the overall App Engine service. And they’re not just any engineers, they’re some of the most talented and dedicated individuals I’ve had the honor to work with. They care passionately about the platform and the developer experience. And that’s where we want to invest.

But even if we look at just the cycles - then no, not all cycles are created equal. This is one of the reasons we want to change our resource concept from “CPU” to “Instance”. App Engine instance hours are fully managed, fully provisioned, run in the context of a set of fully-maintained services, and there are no hidden costs. Just the consumer cost of electricity for running a single server in your home will cost you more than running most apps on App Engine.

And our instances are fully redundant, and we take care of switching between redundant data centers for you. We have over 100% capacity provisioning: we can lose not just one but more than one data centers and still run the entire workload, without applications being impacted. And we have full provisioning for spikes: in the week following the Japanese earthquake, our traffic to Japan doubled. Japan is our second largest country in terms of App Engine traffic after the US, so this amounted to adding capacity for a whole 100M population country in a just a few days. App Engine is so well provisioned that we didn’t need to add more capacity or intervene in any way.

App Engine instances run on Google’s own infrastructure in our own data centers, with the same security and monitoring as services like Gmail and Docs: Google employs a large team of security experts. And our extremely talented reliability engineers are on pagers 24/7 across global time zones: when subsystems have problems, we’re on the case, so you don’t have to be. The high replication datastore (HRD) that we rolled out in January has had no outages since launch.

That said, the new App Engine prices are higher. In fact I expect many large applications after optimizing will end up paying 2-5x more than before. Many small applications will no longer fit into the free quota without optimization or performance tradeoffs. And many applications that only had to pay a little bit above free quota now have to pay more.

But I believe that for the vast majority of applications, a reasonable total cost analysis will find that App Engine is a great deal. And it’s only going to get better. We have a ton of cool improvements in the pipeline.

Thank you for your attention, and feel free to email me directly at psm@google.com. And if you come to Thirsty Bear in San Francisco tonight, I’ll buy you a beer.
1
Add a comment...
In his circles
122 people
Have him in circles
130 people
Jason Koeffler's profile photo
Sarah Reno's profile photo
David Brodbeck's profile photo
David Wax's profile photo
Thiam Sun Yee's profile photo
Jaime Dughi's profile photo

Joshua Hou

Shared publicly  - 
5
Todd Nelson's profile photo
2 comments
 
Sorry, the story didn't show at first?
Add a comment...

Joshua Hou

Shared publicly  - 
 
Guido van Rossum originally shared:
 
+1 on today's XKCD: http://xkcd.com/
3
Add a comment...

Joshua Hou

Shared publicly  - 
 
Chris Chabot originally shared:
 
A journey of a thousand miles begins with a single step. Lao-tzu

I’m super excited about how the Google+ project brings the richness and nuance of real life sharing to software, and today we’re announcing our first step towards bringing this to your apps as well by launching the Google+ public data APIs.

These APIs allow you to retrieve the public profile information and public posts of the Google+ users, and they lay the foundation for us to build on together - Nothing great is ever built in a vacuum so I’m excited to start the conversation about what the Google+ platform should look like.

Please follow the link to the blog post to find out what exactly we’re launching and you can find the technical details on how to use this on our new developer site at http://developers.google.com/+

I’d also like to take a moment to introduce my team who will be joining me on working with our developer community (ie: you!) and answering any questions you may have about the Google+ platform on our discussion forums.

We’ll all also be doing a bunch of Hangouts over the next few days and beyond to talk to you directly and hear what you think of the +Platform as well as helping with any coding questions you may have, so make sure to add them to your Google+ developers circle!

+Timothy Jordan
+Jonathan Beri
+Ade Oshineye
+Will Norris
+Jenny Murphy
+Wolff Dobson

Now let's see lots of re-shares on this post & let's get this party started!
1
Add a comment...

Joshua Hou

Shared publicly  - 
 
nooooooo, several months, google?
1
Add a comment...
People
In his circles
122 people
Have him in circles
130 people
Jason Koeffler's profile photo
Sarah Reno's profile photo
David Brodbeck's profile photo
David Wax's profile photo
Thiam Sun Yee's profile photo
Jaime Dughi's profile photo
Work
Occupation
Software Engineer
Links
Other profiles
Story
Tagline
computational linguist, software engineer, pianist
Introduction
computational linguist, software engineer, jazz pianist, juggler (in no particular order)
Basic Information
Gender
Male