Profile

Cover photo
John Asmuth
Works at Google
Attended Rutgers University
Lives in Rutherford, NJ
508 followers|41,154 views
AboutPostsPhotosVideos

Stream

John Asmuth

Shared publicly  - 
 
My family looks good.
2
Alessandra Sperling's profile photo
 
That they do!
Add a comment...

John Asmuth

Shared publicly  - 
 
 
Software terminology then and now. #Joke   #Technology   #App   #Apple   #Android  
6
1
Samuel Falvo II's profile photo
Add a comment...

John Asmuth

Shared publicly  - 
 
I've been productive in my new job!
2
John Asmuth's profile photoKamil Kisiel's profile photo
2 comments
 
Yes.... a network topology.... that's what I'm doing here!
Add a comment...

John Asmuth
owner

Discussion  - 
 
For those of us thinking about the numerical package collection, and the linear algebra stuff specifically,

Does it make sense to define a set of BLAS interfaces? Then there could be a pure go BLAS implentation as well as a C or even FORTRAN implementation.

If we had a generic BLAS interface (a different one for level 1, 2 and 3, or perhaps 3 could embed levels 1 and 2, etc), then the more interesting stuff could be built on top.

An issue here is execution time - for instance, how much faster would it be if a pure go implementation of LU decomposition had all the arithmetic in place vs if it was all done with BLAS subroutines? Is the overhead low enough so that, if a super-fast BLAS impl written in C were swapped in, it would be faster to use the BLAS interface than to have all the arithmetic written out?

Can we even answer these questions without trying? :)
1
Rauli Mertanen's profile photoDan Kortschak's profile photoBrendan Tracey's profile photo
23 comments
 
To my inexpert eyes it seems a good idea. If it is optional, we can still have a first version working relatively soon, based on yours and John's code.  I guess if we define an API carefully, we can add new and even replace preeliminary implementations if needed
Add a comment...

John Asmuth

Shared publicly  - 
 
 
I wish you run 2013 in four goroutines and accomplish everything just in one quarter! My bag is full of new packages, features, compiler and runtime improvements! Happy and concurrent 2013! Go go go!
                                 - Santa Gopher
12
2
maria alvarado's profile photo
 
eso me farese fenomenal la felicidad cuando es de corazones perfe,
 ·  Translate
Add a comment...
Have him in circles
508 people
Alex Plugaru's profile photo

John Asmuth

Shared publicly  - 
 
Floored the loft!
1
Add a comment...

John Asmuth

Shared publicly  - 
 
 
Lock in, what lock in?

On occasion I encounter the argument that Google App Engine is a proprietary platform, which implies lock-in, which many developers consider a Bad Thing. I’d like to address that complaint. The argument I will be making is this: it’s not as true as you think, it’s mostly unavoidable, and it’s not our strategy - in fact we actively work to minimize it.

It’s not as true as you think

Let’s acknowledge the problem outright: if you develop an application on App Engine, it will require some work to move it somewhere else.

My first “yes, but” to this is to note that there is a bit of an illusion going on. If you’re new to App Engine, you probably feel a sense of lock-in because the runtime environment is very different: it doesn’t allow you to invoke some system calls, write to the file system directly, choose an operating system, or listen to an arbitrary network port, to name a few fundamental ones. These things might be doable with other platforms, especially infrastructure ones, but they are restrictions, not lock-ins to anything proprietary and non-portable. These restrictions are there for good reason, as I’ll point out shortly. And restrictions are always portable.

Software is always built on top of other stacks of software and hardware. No matter how well abstracted, this will leak into your own code to some extent. But the main design principles of App Engine are generic – structure your code so that small front-end workers can respond to requests quickly, pushing longer-running tasks onto a queuing model; separate out short-lived data from long-lived data, and leave the former in memcache and the latter in a key-value store; don’t assume a local file system, because they scale poorly and fail often; don’t hard-code to specific versions of operating systems or libraries; etc. These are good practices for any modern system that strives to be scalable, reliable, efficient and easy to maintain.

The stacks that these abstractions map to are replaceable by you. The Google Cloud Datastore is “just” another NoSQL/NearSQL solution and can be replaced by stacks such as MongoDB; memcache is memcache; MySQL can obviously replace Google Cloud SQL; and the language containers are mostly forward compatible with other containers. Significant portions of the client environment, such as NDB, are open sourced by us already. When we add new building blocks like the Go language, we open source the whole language.

This is not just a theoretical argument. We sample thousands of developers every month to track our customer satisfaction ratings (to a statistical significance sufficient to catch daily variations), and the numbers are rock solid. But it’s important that our developers know that if they became dissatisfied, it should be reasonably straightforward to leave.

And it is. We know this because we’ve had unhappy customers who have decided to migrate off App Engine (shocking). For every such large customer, we do an exit interview to determine exactly how we failed them – and we’re working hard to fix everything that comes up in these reviews. As a side effect of these interactions, we know very well what it takes: for a large application, it’s about 3-4 months of work. Nota bene: that’s for a large, at-scale application; I would posit that this is not materially worse than any other public-cloud-to-public-cloud transition once you have a complex system up and running.

Even if you did code to “standards”, the plug-and-play promise of standards aren’t here yet. Google supports standards - they are key to our success. But the cloud computing and big data areas are new and rapidly evolving. 

It’s mostly unavoidable

Things in life have plusses and minuses.

The restrictions of the App Engine programming model allow us to do a laundry list of things on your behalf: you don’t need to worry about firewalls, most denial of service attacks, viruses, patches, network configurations, failover, load balancing, capacity planning, OS patches and upgrades (in particular security related), hardware upgrades or fixes, certification levels, most security issues, routing, etc.

Because the runtime is minimal for most web and mobile applications, we can start new instances real quick, so that your app can scale fast, and we can move your application to another datacenter when there’s trouble.

You don’t have to wire up supporting services like memcache, email, authentication, backups, SQL, logging, etc. They’re all there, preconfigured and ready to use when you want them.

You can’t build an innovative platform without some measure of lock-in. For example, the Datastore is unlike any other NoSQL or NearSQL service or stack out there. It has multi-datacenter synchronous replication, cursors, distinct queries, projection queries, zigzag merge join, transactional tasks, automatic sharding/load balancing, managed secondary indexes, and multi-row and multi-machine transactions. Our developers don’t want us to dumb down those features to some lowest common denominator; they want us to build more features that leverage the unique underlying software systems.

Engineering is always about trade offs. The more you use someone else's abstractions, the more productive you will be, and the more tied your implementation will be to that platform. But guess what? You got more done. The platform did more work for you. Time is opportunity. Now when (not if) you rewrite your service/app, there will be less of it to rewrite, because the platform did more of the work, and it also guided you to a good structure. Sure, some of the abstractions leaked in to your design. But, they're just different from the other abstractions that would've leaked in had you used something else.

Any good platform will result in this net effect. Namely: that it’s not trivial to migrate, but neither are you artificially locked in. With some work you can move somewhere else. That’s why we set our deprecation policy to one year: no matter what we do, you should have plenty of time to say bye-bye. That’s why we’re serious about our data liberation policy, too: your data should not be locked in.

Giving you options is, after all, one of the reasons we’re doing Google Compute Engine as well. In fact, we’re specifically investing in making it simpler for you to choose appropriate trade-offs between managed and unmanaged infrastructure.

It’s not our strategy

We do not want to lock you in. We don’t like lock-ins. We believe we can both build and run the best underlying stacks and infrastructure in the world. As a company, we disavow artificial use of APIs or Data Jails to tie customers down. Any APIs we design, we strive for them to be the simplest possible encapsulation of the underlying service.

But we go further than this. Appscale (http://www.appscale.com) is a fully open source implementation of App Engine, and we partner closely with them. CapeDwarf (http://www.jboss.org/capedwarf) is a Red Hat project to support App Engine APIs on JBoss and OpenShift, and we work closely with them too, as some of you have noticed (http://goo.gl/5tLgH). With JBoss, for example, Red Hat supports Datastore functionality using Infinispan, and our engineers have worked directly with them (http://goo.gl/9kZjJ) to develop a TCK for compatibility testing.

We actively direct customers to these partners. It’s good for them, but it’s good for us too: a false sense of lock-in simply blocks potential customers from trying us out. And once they try us, they generally like us.

Lock in, what lock in?

I think you’ll find it best to try to leverage key features with whoever is your public cloud vendor, so that you can be more productive in developing your core product. Just structure your code properly. It’s coding hygiene. If you’re a CEO, CTO, or VP of Engineering, your decision on “lock-in” should be: “can we refactor parts such that we could migrate everything in a 3-6 month timeframe, if we had to, without disrupting the business?”

If the answer is yes, that’s all you need to know. Choose a vendor that fits you best, and focus on your product.

The truth is that the public cloud market is a highly competitive business. That’s good for you.
7
1
John Asmuth's profile photoCalvin Prewitt's profile photoAdam Vollmer's profile photo
2 comments
 
Didn't write this, it's a reshare. 
Add a comment...

John Asmuth

Shared publicly  - 
 
#ifihadglass  I would enable symmetric surveillance.

I don't know where I saw it, but I recently read an article about how Glass could be a platform for symmetric surveillance. Specifically, the government currently has all the power when it comes to surveillance. If you witness a police officer commit a crime, odds are your cell phone is going to get confiscated if they can reach you, physically.

It's easy to quickly record and archive such things with Google Glass. Then the question becomes, "How do we protect and broadcast this information?"

As much as I love Google, services like Youtube are not the answer (though they are a good start). We still have powerful self-interested entities who are able to generally censor Youtube or frankly any other centralized repository of video or other information.

It is almost never in the immediate interests of those in power to allow the free flow of information. Sure, they want their message to get out, but that's not the same as all messages. And, for what it's worth, I believe that many politicians support the free flow of information as a matter of principle. It's a great principle, and it plays a huge part in our quality-of-life today, but it's still almost never in the immediate interest of anyone other than the person spreading the information. We can rely on "enlightened self interest" to a point, but you will always have people who will feel justified and righteous when they censor.

Information is a weapon.

I really think that the motivation behind the second amendment applies better towards freedom of information than it does to guns. But since governments typically do not relinquish power, it's unlikely that we'll see a change in the constitution. Instead, what we need to do is to make it impossible for a single actor (be it the government, a corporation, or an ISP) to shut down the spread of information.

It is necessary and inevitable that we create effective decentralized means of spreading information. I am considering designing a peer-based cloud, which I will somehow call P.H.O.G. (I haven't figured out what the letters stand for, except P which is obviously for "peer"). But the gist is that it's a cloud that you are part of, rather than a cloud somewhere far away.

I expect at least 50% of my time working on this project will be spent coming up with a cool name.

It will be a protocol and a go program that will make you a node in the phog.

Some goals:
- Security: This is probably the easiest bit. Until quantum computing becomes a reality, the encryption problem is basically solved as long as you do it right.
- Anonymity: Your immediate peers will know your IP, but the protocol won't preserve this information. This is not the whole solution - inferences can still be made in many situations, so more thought will have to go into this.
- Robustness: I feel like the phog is something that 4chan would support, but you can make plans based on a prediction of how 4chan will react. Byzantine agents (that is, agents who run something other than the approved software) are real and have to be accounted for.

There is a bit more, but I'm still in the design phase, so I won't share quite yet.
6
John Asmuth's profile photoTim Shannon's profile photoJohn Fries's profile photo
3 comments
 
you should check out the documentary "we live in public"

http://www.imdb.com/title/tt0498329/
Add a comment...

John Asmuth

Shared publicly  - 
 
Oh my god a baby! (not my baby)
1
Add a comment...

John Asmuth
owner

Discussion  - 
 
I created this group in response to this golang-nuts post: https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/QBwBWtr7NzU

I figure this will be a place where we can spread the knowledge and do our best to avoid unnecessary duplication of effort.

Maybe make a github collection, too? a la github.com/go-gl
6
Rauli Mertanen's profile photoSebastien Binet's profile photoYves Junqueira's profile photo
4 comments
 
Also, the github collection, seems like a good idea.
Add a comment...

John Asmuth

Shared publicly  - 
 
From the #golang   IRC channel:

other person: "it's kind of like this. lets say you want to go out to eat. you could go to your bank, withdraw a $20, then go to the restaurant and pay in cash. Or you could go straight to the restaurant and swipe your debit card. :P (cash is the value, debit card is the pointer)"

me: "that is about the worst analogy for pointers that i have ever heard!"
10
Nathan Youngman's profile photo
 
Lol :-)
Add a comment...
People
Have him in circles
508 people
Alex Plugaru's profile photo
Work
Occupation
Software Engineer
Employment
  • Google
    Software Engineer, 2013 - present
  • Clarity
    Contractor, 2012 - 2013
  • Rutgers University
    Teaching/Graduate assistant, 2006 - 2012
  • Sarnoff Corporation
    Intern, 1999 - 1999
  • Wordnet
    Programmer, 2001 - 2003
  • Sarnoff Corporation
    Contractor, 2004 - 2005
  • CNA Financial Corporation
    Intern, 2007 - 2007
  • AT&T
    Intern, 2009 - 2009
  • SRI
    Intern, 2011 - 2011
Places
Map of the places this user has livedMap of the places this user has livedMap of the places this user has lived
Currently
Rutherford, NJ
Previously
Princeton, NJ - Highland Park, NJ - Avenel, NJ
Links
Contributor to
Story
Introduction
I'm a rockstar in my head.
Bragging rights
Official NCTTAA record of 0-5
Education
  • Rutgers University
    Computer Science PhD, 2006 - 2013
  • Rutgers University
    Computer Science BSc, 1999 - 2004
Basic Information
Gender
Male
Birthday
November 18
Other names
skelterjohn