Tip:
Highlight text to annotate it
X
>> SAUER: Maybe you can start by telling us why you chose Google web toolkit for your
project.
>> GUANG: I think we chose Google web toolkit because it's open sourced...
>> SAUER: Yeah.
>> GUANG: Which is very important for developers, right? They want to have--they don't want
to be locked in to any, to the vendor.
>> SAUER: Right.
>> GUANG: And open source is going. And the other fact that we chose Google web toolkit
is that we just unlock Google's domain knowledge.
>> SAUER: Okay.
>> GUANG: And the other thing that is really key to us that we had our problems was browser
compatibility. So what would happen is Naveen will be coding or Vikram will be coding on
one version of Firefox and I will be debugging on IE. And then he will fix that bug and then
it breaks on Firefox and then vice versa and it keeps going that whole round.
>> SAUER: Sure.
>> GUANG: So one feature could take us like days...
>> SAUER: Wow.
>> GUANG: To fix.
>> RANGNEKAR: And you can easily waste time on that.
>> GUANG: Yeah.
>> SAUER: Yeah, because...
>> GUANG: And so when GWT, which my colleagues will talk more about, it actually solves a
lot of those problems. Right? We can actually code once, deploy it, test in a few browsers
and it usually works fine.
>> SAUER: Okay.
>> GUANG: And then we can go next to the features. So it allows us to focus on the app and the
feature set and the UI experience without needing to worry about stupid stuff like it
doesn't bring an IE, it doesn't bring in Firefox or it brings Safari and things like that.
>> SAUER: Okay. Is that where the Google domain knowledge comes in or what do you mean by
that?
>> GUANG: I think Google...
>> RANGNEKAR: Yeah.
>> GUANG: Vikram always tells me, yeah, you know, Google is probably the best web application
campaign of all and we agree. And over the years, right, you guys have built so many
web applications, my guess is that's why you guys created Google Web Toolkit, right, to--because
you face all these problems. So that is how we are standing on the shores of the giants,
right. We leverage on your domain knowledge with respect to creating web application.
>> RANGNEKAR: So to be specific about domain knowledge like the GWT loads, it uses iframes,
which is the way they have done it is it speeds up JavaScript loading. And then there are
certain tools in GWT that allow, for example, if anyone use a lot of small images across
your website, you end up having to, you know, do that manually. But in GWT, you know, you
can actually create a resource. You put them in a resource and when the--when your GWT
code is compiled for deployment, those images actually combine together into one image automatically.
And, you know, and then position using CSS 3 codes, which is great. It speeds up loading
and makes your app a lot more responsive.
>> KUMAR: And basically you're--everyone is developing in one programming language Java,
but you get, you get basically six different versions for each browser, each language,
each--very, basically, each in every different combination, you get a fully working version.
And that really helps, you know, with browser compatibilities. You know, you know, you get
the fastest performance with your browser. So that's the coolest thing. You know, you
don't have to worry about, you know, slowing your code down just to handle one IE bulk
here and there.
>> RANGNEKAR: Also GWT is, it doesn't really have GWT [INDISTINCT] loads. It's--what is
compiled in the output it what you get. It's the final product. And that actually is great
because your code, not only can you improve your code but every time GWT improves, the
compilation will make your final result better. So your code improves even without you really
doing anything, the final result which is really great. And like Naveen said, having
Java on the back end, Java from the front end, really speeds up things. You know, your
chain of thought is not broken and you just get better in, you know, one combined platform
as opposed to, you know, figuring out multiple things.
>> SAUER: Okay, that's a great story. So you mentioned six different versions. Does that
mean that you as developer now have six versions to manage and deal with?
>> KUMAR: No, you only have one because you're writing everything in Java. So you're maintaining
one code base in Java but your compiled output is JavaScript, HTML, all these stuff. That
stuff, if you're going to look at it, it looks like, you know, you know, gibberish almost.
You probably couldn't even follow it if you were, you know, even the smartest guy in the
world. But we don't care because that's just the output of what we've, you know, what we've
already been. So, for us, we're just writing one code base, working on one code base, the
Java and the six different, you know, you can think of it in almost like six different
binary executables that you would get out of any compiler if you're across compiling
over several different architectures.
>> RANGNEKAR: So GWT actually compiles a different version for each browser and it auto, you
know, figures out which one needs to be downloaded, so, which is great.
>> SAUER: It sounds like the, the source code is really optimized for the developer. You
become really productive, but the output is optimized for the browser and for the user.
So an IE user only gets an IE download.
>> RANGNEKAR: Correct.
>> SAUER: A Firefox user in English has a different code than, say, a Firefox user in
Japanese.
>> RANGNEKAR: Yes, absolutely.
>> SAUER: That's okay. I think that's great.
>> GUANG: And I also want to add something that GWT allowed us to have internationalization,
like, in a few days. [INDISTINCT] unicode for Japanese, Hindi on Socialwok. And also
it took us very quickly one added benefit as we went mobile, mobile web, like, in a
week also. So all these, the reason why you should use GWT...
>> RANGNEKAR: Mobile web wasn't part of the Woks but the time to develop it was really
short. I think it must have been 10 percent of the time it took to develop the rest of
the application. So...
>> KUMAR: I mean, one of the beauties is that since you're just working with the Java code,
you know, manipulating Java code is pretty, you know, pretty straightforward once you've
learned it and you can just say, "Okay, let me make a slightly different version of the
same Java code that maybe is more optimal for the mobile interface." But, you know,
so, one thing that really is great about that is that, you're just, you're still maintaining
this one Java code. And the beauty is, is that you can even reuse code. You know, sometimes
we have codes that's not necessarily backend per se is just code that's not, that doesn't
display anything visual. It's a code that interacts with our backend, you know, AJAX
services, things like that and we can share that code. It's a code that just stores data,
you know, stuff that basically marshals and Javas with objects, things like that that
we can just, you know, use that same code. We don't have to, you know, build a mobile
version of that or anything like that.
>> SAUER: Okay. So you really have code reuse between the client and the server.
>> KUMAR: Yeah.
>> RANGNEKAR: I also wanted to make this point that this is a cycle in development that's
kind of important for most developers, they do this all day, where they make a change,
they want to test it; then they make another change or--so that cycle needs to really fast
for a developer to be comfortable in an environment. And the GWT environment, the plug-ins that
they have for Eclipse and stuff actually allow you to do that. So if we change our code,
I don't have to hit a compile button and then wait around until my whole code is compiled.
I actually make a change in Java and just go up to the web browser and I just hit reload
on the browser and the change is displayed. So it's almost, you know, in-time compilation
or something; not entirely clear on how the backend works but it works great stuff.
>> SAUER: Okay. Did you add any extensions to GWT that are specific to Socialwok?
>> KUMAR: Yeah, I mean, one of the--one of the things, from our old JavaScript programming
days and even from our old sort of server site programming days, we used the--we used
a concept called deferred execution. So one of the things that we needed to do is we basically
needed to duplicate that same functionality in GWT. Deferred execution, if any of you
aren't familiar, is a programming model where call backs are basically added on to certain
events. The programming model is called asynchronous programming. It's a--it's very, you're pretty--if
you're familiar with twisted Python which is a great networking sort of stack for Python
developers, it's very familiar to you. And the beauty is, is that you don't have to worry
about when something happens when you--to add the call back. You just add the call back.
And then, whenever it completes, that call back is executed, it's guaranteed. So we basically
did not have that functionality originally in GWT and now we, and now we've added it.
And we probably will be able to contribute it back because it's open source. It's another
great thing.
>> RANGNEKAR: So much of the web is asynchronous that it really helped us, you know, having
that kind of functionality where we can chain call backs or chain deferred objects together
which is tough.
>> SAUER: Okay. What are the, maybe, some of the features that are up and coming that
are in line GWT distribution but that you've had a preview of watching the subversion code
combined. What are the things you're excited about?
>> KUMAR: We, we are actually tend to limit the edge of things. We use the trunks so we
already experienced a lot of the new features that--we've seen, one of the newest features
that we've seen is the client bundle, which is a great system that allows us to do sort
of resource allocation based on a standard Java development or standard C, you know,
almost like writing CSS that can be browser specific that's only loaded for each browser
just like our JavaScript. So we use those things as well already. One of the things
that we're really interested in is this code splitting which is developer guiding code
splitting which is a great way for us to break up our application when, you know, to basically
speed up the volume and time, you know. One of the things that we worry about is that
we're always concerned about performance. We donÃt want our users to experience,
basically, a horrible experience where he's waiting a few seconds for his app to load.
We want it to load very quickly and the user can just use the application. And with GWT's
philosophy is almost aligned with that. So we want to actually take advantage of those
features.
>> GUANG: I think I will add one more thing to encourage people to use GWT. As developers,
I think, what you want is documentation and stuff. And so from our end, we have benefitted
from GWT today, right? And what we would love to do and soon we will have what we call wave.google.com
if you love to contribute articles of what we found on issues that we face on a new paradigm
of programming, we have used with GWT. So Fred look out for more articles from us.
>> SAUER: Okay. I'll look forward to.
>> GUANG: Yeah.
>> SAUER: Thanks guys for coming here and...
>> RANGNEKAR: Thank you. Thank you.
>> GUANG: Thank you.