Flutter: The Best Way to Build for Mobile?

Kasper Lund

Recorded at GOTO 2017

Get notified about Kasper Lund

Sign up to a email when Kasper Lund publishes a new video

so I'm I'm Casper I'm here to talk about
flutter but before I really dive into
what flutter is I just wanted to tell
you bit about myself that's not it
I work for a I work for Google I've
worked there for him a bit more than
eleven years and when I joined the
company and this notion of us building a
new browser was born not by me and but
that's my first project at Google
working on under the Chrome browser and
specifically the v8 project and which is
a practice parted the many years ago and
since then I've ventured on and today
I'm not gonna spend too much time
talking about v8 but if people
interested in that whole story and I'd
be happy to talk about that a bit later
as well today I'm here to talk about the
possibly the best way to build for
mobile and before I do that I just want
to give you a sense for why I think it's
really important for us to improve the
way we built for mobile so this might be
a really odd slide here in in Denmark
does anyone know who these two persons
are okay good usually people know Barack
Obama at least if Dick Cheney is also a
familiar face what do you think they
blank stares that's okay this is help
this is a hint they do have something in
common is it's not very widely known
here in Denmark s but what they have in
common is that they both like this new
upcoming show in the u.s. called
Hamilton it's a big deal there it's not
very well-known here in Denmark but
apparently that is the thing that both
Dick Cheney and Barrack Obama likes and
agree on
it's a itself a phenomenon in the u.s.
come to Europe at some point but having
having witnessed how how big that show
is in the US I just needed to tell you
about this the show before we go in so
if you if you have that like a really
popular show and what's left like what
do you need what's missing and the
office entered to almost all questions
like that is a mobile app this show need
a mobile app to go from being super
popular to even more popular and and the
team and the ante producers of this this
show felt like that app had to be so a
good environment of the after of the
atmosphere around the show and they also
had this notion that they know they need
it not yesterday but close enough they
want it now right so you have this
problem you want to build a new mobile
app and you need to build it really
really quickly and it has to be just
right no compromises the right quality
the right identity it looks it has to
look like the right kind of app and but
you have to build it really quickly how
do you do that and to be successful with
this you need a really productive
framework you need a developer
environment that makes your developers
really productive
you need a a platform that supports what
I like to call custom UIs really well
because sort of the brand identity for a
for something I can have for a show of
this kind has to be preserved in that
app it shouldn't look like an ordinary
to look like that of an the extension of
the show so this custom UI bit is really
really important and of course you need
to have a platform that supports doing
this and ending up with them like really
beautiful fast applications so of course
I'm here to tell you that there is a
framework like this that you could be
using and and that thing is called
flutter flutter is a is a new project it
has a logo so it's not entirely new and
it's a something we've been developing
on for a for a number of years now it's
it's out there and open source and you
can look at it if you want to and it
actually stopped there's a bit of an
experiment we want to see if it was
possible for us to build a mobile app
stack based in some of the core ideas in
in browsers and the team behind it
actually itself comes to a great extent
from the from the work done in the
chrome team we tried to really like
shrink the amount of features necessary
in this platform take the the web mat
massage a bit and make it much better
for for mobile apps
and there are lots of ways to develop
mobile apps out there today and we
wanted to try to come up with a
something and we feel like it's actually
a really compelling story for for the
kind of app that we see people building
today and if you you should walk through
the different kinds of software
development kits that are out there this
is a gross oversimplification of course
like any slide like this should be and
but if you look at it from a far enough
you have you basically have a set of
SDKs that offer sort of a classical
model view control setup and there's a
lot of really neat SDKs in that space
everything from the sort of the
classical iOS SDK is based on Xcode and
Android studio for Android it's towards
something that's more dynamic easier to
to to to work with for a lot of people
like a Cordova phone gap and frameworks
reactive frameworks like a presentation
yesterday about react native which fits
really well in here react native is
against of an interpreter it's set up
with them with JavaScript to tie
together all the native components but
it's done with a very different
framework at the bottom the the way you
construct your views is not the
classical model you control setup it's
it's more of a reactive style framework
where you map the application state to
the representation and that you wanted
to end to appear in and then you have
the framework taking taken care of
computing there the difference between
the previous state and the currently
there is one thing missing here and of
course flutter fits in here and flutter
is Aves or a functional reactive
framework and it is compiled to native
code so the applications you ship in in
app stores is mostly arm a machine code
and I'm gonna give you more insight into
like what makes flutter attractive in
the space and what does it mean for a
flutter to be a reactive framework so
so it them it's built on on a foundation
which is a small core C++ code and into
that and that core of it it's very
ologies skia is a 2d graphics library
that we've been using for android and
chrome for a long time and some of the
text layout is super complicated and
browsers do that well so we had a
browser lying around that we could we
could steal that code from and and then
we have thought the the language runtime
that the power is the the rest of the
stack so everything in green is written
in dart code and but it's still layered
so you can approach the different parts
of it and then hook in where it makes
sense for you in some ways you could
think of the the green stuff as the user
code of the system you can see all of it
you can you can change it you can work
with it
and it gets loved flexibility for for
every use of this framework to be able
to peek inside change and manipulate
what they need to there are a couple of
really important things here and I think
if you look at the top line as an as a
developer you need to have a set of
predefined high quality widgets
available for you to to be productive
and build apps really quickly so the top
line with the material design components
is probably one of the the key points
that that users will see as they come on
to a lot or based staing material design
is a it's a very big sort of design
language and this is just a set of the
widgets that that comes build into
flutterin that you can use from there
from the get-go and the point is really
that you get this out of the box and
there's a lot of widgets in here and
widgets are not just classical controls
in the kinds of that's the sense of
people usually refer to them in flutter
all witches are composed of other
widgets and the widgets also control the
layout so there are sort of layout
centric which is like centering or
stacking or having columns there are
some in here as well I'll show you how
this actually looks like in code in a
bit but the core of it is that you have
a sort of highly composable set of
widgets that you can use to build any
kind of UI like so before we actually
just keep talking about these things I
want to show you how it actually looks
like on
emulator device it's the EC's I can do
of course it runs fine on unreal device
as well
but let me see if I can just run this on
the emulator so what you'll see here is
now a flutter starting up it's using the
Android SDK underneath to compile and
build this this a debug version of the
app uploaded to the emulator and start
running it so here we have a an emulated
sorry flutter app and that is packed
with all the widgets that we could find
so you can just see a gallery of
everything here it it has sort of the
common cards from material design it has
everything you need to build this and
build from in itself it's not super
exciting and it's not intended to be
super exciting but it's really easy to
get this up and running you run the
program just like this and and you have
a an emulated version of this really
quickly running if you look into the the
core of it right you can actually find
all sorts of interesting material design
widgets in here and and all of this is
easy to to get inspired from or even use
in your app let's go back so running
flutter come to a flower comes with a
command line interface that makes it
really easy to manipulate these things
later we'll see how it integrates in the
in an IDE as well because most people
don't like just having a command line
interface it's it's very clear that
people like the quality and the end of
these materials languages that we've
included and people note that if they
start building apps and flutter and the
fact that they have this set of which
it's built in a available from the from
the ground up is really useful for them
it is however not really the full story
right so today and most people actually
don't ship apps just with material
design or anything like mobile pay and
then Mike as an example of an app that
doesn't look like a of a classical
native app we see people designing UI
look more like this this is not a native
Android widget or an iOS widget there's
something custom built for this kind of
app to get a specific look and feel
there are even things that are perhaps
even more sort of specialized and we see
lots of this a lot of the very popular
apps out there are some starting to
enter into the area of more custom UI
and custom UI is interesting it means
that some people that design apps really
want the same look and feel across
Android and iOS it also means that the
amount of work that goes into an app is
very much determined by how a house sort
of fancy the interactions say that that
involved these custom UI elements need
to be and it's very common and you have
designers that come up was it a sign
like this and then there's a hot
negotiation about like the cost of
implementing these things because it is
it is hard so traditionally I would say
that doing custom is hot we've talked to
lots of people that but find that this
is the tricky part in these in managing
the native native apps but even more so
doing custom twice for the two platforms
is really really painful and and it's
hard to keep these things in sync and
have a have the same experience across
these things so flutters solution to
this is actually kind of simple flutter
solves this by being very layered and
essentially everything that we have as a
built in set of widgets for material
design is based on the same framework in
the same layer so you can build them the
same way yourself and you have access to
all these underlying layers and you can
use them so in some sense because we've
had to support building these material
design widgets we've had to build a very
good support into the platform for
building custom UI so in some sense in
flutter everything is custom UI I just
want to show you that very very briefly
here how how this looks like in in the
device if I go back here I actually have
we have actually went ahead and build
one of these things in here and it's
it's it takes a few days of work to
build these things but it the platform
really supported well so I think um this
is a really useful way of showing you
exactly how the code in this in this
case looks like and let's take just a
bit of it because otherwise it might be
too much and the point is not for you to
look through all this code it's just to
show you that everything here is
actually based on importing sub parts of
the of the flutter package and the
foundation the material and rendering
and reusing those things to build custom
UI from them and there's still a lot of
magic constants and and things like that
so it's not it's not an easy task in
that sense but you have access to
everything you to do this so building
custom UI and flutter is is it's a very
doable thing but I think one of the
really key differentiators here is that
you don't have to do it twice so you can
actually say I want to use this thing
and I want to run it across all the
devices not just the Android phone here
and now let me see it again fine the the
iPhone I don't know why that needs to be
so much bigger it bothers me a little
bit that the the iPhone is so huge here
but what you see in the background now
is actually us a building and compiling
for both platforms the end of one was
apparently the one we started with and
now we were actually running Xcode in
the background and asking that to do the
heavy lifting us we're getting the right
application signing and now you see the
app here and you have the same custom UI
written once but for both both am
Android and iOS and it comes with a bit
of customization for the platforms too
so if you look at sort of simple things
like the the cars here you'll find that
on an iOS the overflow or the over
scroll and the way people expect it to
behave is is with a bounce back effect
but if you do the same thing on on
Android people would be very surprised
you find the same thing here so on
Android is suppose
to actually look like this with this
sort of visible marker that comes up in
the bottom so even though it's the same
F there is customization at the at the
platform level that gives it the right
look and feel the way the the scrolling
has to feel is also different on two
platforms and you can you can really
feel it if we if we get it wrong and so
we try not to ok so you've seen now that
you can build and you can build an app
here simulator this one as well with one
code base and you can have material
design widgets you can have what we call
the computer cupertino widgets apples
headquarters in Cupertino so these are
the Apple iOS look and feel and widgets
and you have access to all of these all
of these things and we allow you to hook
in and build the cities of custom UIs in
a very smart way and this is part of the
reason why the the team behind the
Hamilton app were very interested in the
in the stack here the support for custom
UI built in and in a way that allowed
them to target both Android and iOS with
it's not always that the app have the
same exact look and feel but this notion
that iOS and Android can be the apps can
be built by the same team and it's a
it's a I could read a time-saver one of
the things we've seen that there at
Google is that the effect of having two
teams is it's it's not just double work
it's also very painful work of keeping
these things in sync and and having
feature parity between these things can
be very important for a product but it's
very hard to deliver that for the
developers so there's a lot of friction
that you remove by just having one thing
so I would claim that with flutter doing
custom is is easy and as importantly
doing custom twice it's not needed in
this case so that's it's a major selling
point for therefore the stack here one
of the things of course that some people
think when they when they see a solution
to is a cross-platform issue and is that
often solutions in this space come with
a lot of compromises
often it's very hard to get the right
performance and it's very hard to to get
the right to look and feel of your app
and we've had good experience with them
with them with building apps and
actually sort of cloning a previous
version and built built with a native
SDKs and and sort of just upgrading the
app underneath the feet of the users
without telling them that they got a new
version on a new tech stack without them
being able to tell the difference that's
of great testament that it's it's very
possible in Florida to write high
performant applications to case if you
take a step like further into the this
back here and look at the C++ path I
showed you and one of the components
there is the the dark component and that
are part of the if the fodder system is
the one I'm a I'm most familiar with and
six or seven years ago I don't remember
but it's it's a very sort of a long
ongoing project and we were seeing a lot
of success with it and this is our logo
and probably not super interesting but
they're one of the most important things
for us is that that is developed at
Google and by a five my team there and
we've we've recently gotten a lot of
success internally with it with a with
the web part of our product where you
can develop web apps based on on that
and actually Google's largest businesses
Adsense ad words the product that we
make and the money through are now all
using using dot so it's a it's a good
way of us officers to keep supporting
the development of thought and then
pushing it to M we see lots of growth
it's the fastest growing language inside
of Google and and perhaps more
importantly for me is the it's a notion
that the teams that go to the stack here
they report a and increased productivity
this number is kind of weird
they claim that that going to the new
stack year all in all gives them a their
developers a 2x productivity this is not
even in a mobile setting where they get
the one platform for free but just the
sort of the the the quality of the stay
alone gives them a higher degree of
in this context dart has trended to
JavaScript and runs in all the browsers
and inside the company mostly don't see
so much outside the the version of
angular written in that is this really
taking off we see lots of these big
enterprise apps being rewritten in in
dart and with the angular stack there
and they usually look a bit like this
like big apps full screen apps for
mobile and they're all these are all
built in dart and angular em so there's
this of course this notion that having
the same language to support those
mobile and web is it's pretty attractive
for a for for lots of reasons so if you
look at that and it's an unsurprising an
object-oriented language some would say
it's a little bit boring and that's it's
almost flattering I would say it's a
it's supposed to be familiar to people
who have a background in Java C sharp
JavaScript and and that's also the
feedback we get from from people trying
it out how many of you are like Java
developers quite a lot okay and c-sharp
is that you see as well yeah JavaScript
that's a good mix I think this would be
like very easy for you guys to see when
I go through a few examples class-based
single inheritance from the syntax the
the the latest addition I would say is
that we've we've upgraded the type
system in dart from being an optionally
typed language to now having a sound
type system and we found that at scale
like when you hit like multi million
lines of code and that was the right
trade-off for us to do in terms of
supporting our developers better but
also as we start compiling to to native
where the predictability performance
predictability it was really a key thing
that the interaction should be it should
be easy for developers who understand
like how the app performs and not sure
we're quite there yet but there's a
major upgrade to that to the language
and the way we usually deal with dart
code is we have this sausage maker in
the middle or compiler and we throw in
dart code and and then the other side we
get either a PKS or
or IPAs for him for iOS out and so with
native code in there or we get
JavaScript code out that runs across the
browsers so a compiler like this is is
sort of what I've been doing for the
last many many years and it's it's a
complicated piece of machinery but in
some sense this is all most people need
to know about right you throw code in
and you get something out on the other
side almost exactly like a sausage maker
it does give us a lot of benefits to
have this approach right we can put in
an optimization phase in the middle of
the compiler here that that makes it
makes the code that we emit small fast
and that's something that's really
applicable both with JavaScript and and
native code as the output and and we can
do a lot of the heavy lifting there too
to be smart about what kind of code we
use and and I think it's not the entire
reason why people find that apps been
built in flutter perform well but it's
part of the part of the reason clearly
the framework also has a huge role to
play in that in that space there is one
problem with it though and it's super
involved let's like compile step right
so you throw code in and we we chew on
it you have coffee and even just like
showing you guys how to run flutter on
and let emulate device just a few
minutes ago I took awhile for that whole
thing to spin up and and get the code
running on the device and if you're used
to like Java and c-sharp and you've
probably familiar with this like waiting
around for the compiler to finish and
it's a it really has a big impact on
your productivity and we find that
people enjoy their work a lot less if
they have to wait and they also develop
workflows that are not necessarily super
effective and so we'd like to get a
slightly simpler picture in front of you
than this thing maybe these guys are not
very good at making sausages either but
it is quite involved and it does take a
long time one of the attractions the
attractions I think of going to a
JavaScript like react native or
in PhoneGap or cordova is that there is
no comparison for that right that's all
dealt with at runtime and so we
certainly also wanted to try to provide
the same benefits as you can with those
things and our solution is really really
simple we just introduce just-in-time
compilation and you pay-as-you-go that
has has been built this way for a long
time but the combination of having both
just-in-time compilation for development
and ahead of time compilation for
deployment is really a powerful thing
so that hybrid is is really really
useful you don't compile the application
upfront you compile the asset execute
and you only pay for compiling the parts
that are actually executed and but in
the the overhead of data after compile
or at least you move it to two runtime
where people tend to have a bit more
patience for these things let me show
you how that actually works
and give you a proper introduction to
what coding in fodder actually looks
like let me see here
so slaughter is comes with a and
IntelliJ plugin and very soon this
plugin will also work in Android studio
so if you have that installed already
you don't have to install another
version of IntelliJ and IntelliJ is sort
of a full fully fledged
environment some of you're probably
familiar with it and I imagine most of
you probably are but flutter has a
plugin for it that is a plugin for it
and you can write apps in this in this
context let me just fire up a an
emulator here so we have something soon
that needs to boot the entire Android
system and that takes a while to so it's
another one of those things that you
you'd like to not wait for that often
but let me walk you through the code as
it boots up at the top you have the the
main function
hopefully that is not super surprising
that's where the application starts and
in there and you just use the flutter
framework to run your app and an app is
is a widget everything's basically a
widget here there are two kinds of
widgets there are these stateless
the state and the widget are separated
because they have different lifetimes
and I'll be able to show you that in a
moment and but this is a reason why
there we have split it up this way so
the way you actually construct UI in in
flutter is reacting to to a method call
called built that tells you to take the
current state and map it to the set of
widgets that should represent that state
visually so you have here a a built
method that returns a new material app
that has a homepage in it and so it's
all widgets all the way down if you go
into the home page that is the stateful
widget so it's not super interesting on
its own but the home page state is a
little bit more interesting and the home
page state has a more complicated built
method down here that returns a scaffold
with an app bar and some body and some
centering this looks almost like
something you you could also written in
XHTML and but here you can start at all
in dart code that means that you can use
a debugger in it you can you can have
local variables you can refactor it
using the common tools that you use for
the language so abstractions like
classes and whatever can be used to
actually abstract over these these
things in the construction of these
device here see if that works and I
promise to you it would be fast but it
really isn't fast with the first run
here we still have to build the version
of the app and get it moved over there
and but once we're done with that and we
actually have an app on the other side
in the end we start interacting with so
the app is pretty simple and there's a
count in the middle it's very small an
apartment at the in the core here I can
press it and what happens inside the app
is actually there's the unpressed event
that calls increment counter up here an
increment counter is implemented at the
top it updates the counter and it tells
the system that the state has changed
then the framework will say okay state
has changed let me call the built method
again get new UI elements back from
there and the widgets and then look at
what what kind of difference that was
from the previous widget tree to the new
one and only update
where it becomes really nice is that say
we wanted to change the the font size of
that counter we can just go in here and
say style new text style see something
like this and we can say I'd like to see
this change done on the device right
away and then we actually preserve the
state so count is still five but we've
updated the the code over there that
that tells the system how we map from
state to UI so the UI changes and of
course we can change anything we want to
in here we could say that the the icon
it's not the one we want we want
something else here at C access time
it's probably a silly one to choose but
I can just reload that thing you get the
new icon down in the corner and you can
continue working so you can iterate on
your design change the code update
things as you go you can see that the
hot wheel only has we called it is an
action here so it means that we do as a
state preserving update of the code and
the UI and in this case we do it in 558
milliseconds which is a the goal for us
it's a sub second so it doesn't get in
the way there's a really powerful way of
actually manipulating building apps and
it works on both Android and iOS and
it's a I think it's a sort of it's about
time we had a frame with the support of
this really well and there's lots of
things you can you can experiment with
in this in this context and there are
lots of different design things but they
have the core of it is really pretty
much what you see here you construct
your UI from the state you manipulate
the code as you want to see how that
behaves and you have the option to start
over if you really want to if you do
want to clear the state and but you
don't have to in most cases one of the
things that that I've found working on
native apps and I'm really painful is
often the interaction that you you're
debugging or working or improving is
fairly deep into there into the product
and can be hearted navigate to the right
place with the right state and and try
to manipulate it and see how it updates
with this you don't have to do that and
that's a really powerful thing if you
look at the the counter example here it
is not just the it's not just the UI
elements we can change we can also
change the the logic of the app so if we
wanted to we could go ahead and say
let's update the counter a little bit
more whenever we do this and this
shouldn't change the UI but the code
over there is now updated and behave
differently than before probably a
little bit silly but now it actually
adds adds to every time you want to do
anything here one of the things that I
think work work really well here is that
you can also it's a break point in the
code and work through it this way and
and it works really nicely with a but
that holds an integration thing another
thing that is also important to mention
is that having everything in encode here
means that you can use the same tools
for profiling and finding the
bottlenecks in your app across
everything you do here you don't have to
be an expert on CSS and how animations
work with that it's also governed by one
system so people that start using
flutter actually pick up on this the the
way you develop the way you interact
with the system is very pleasant and it
gives a big sort of productivity boost
and we find that people that that that's
thought it's not using flutter here have
a very hard time going back to a more
classical tool change where they have to
wait for longer so let's let's go back
to Hamilton and just like see if if
these things here I actually end up
making sense for them so Hamilton ended
up with one code base and two great apps
on Android and iOS after about three
months they're very happy with the app
it's it's it's a it's downloaded a lot
in the u.s. not so much here for obvious
reasons and people really interact with
it and the custom UI that they built in
that context they really work for them
the it's available in both app stores so
it's sort of an official app launched
here and
we also have apps built at Google and
that are not so publicly available
because it's their internal tools that
we're building with this thing and but
so flutter makes it easy to build a
beautiful mobile apps and fast to I mean
it's a it's a new SDK so there is a
learning curve but the language and the
framework is not in many ways they're
they're not that new in the sense that
that is a very familiar language and the
reactive paradigm is certainly happening
out there with the success of react and
react native it is available as an open
source alpha release right now and the
quality of it is really a it's not the
reason why we call it alpha we we know
that there are a couple of areas
dimensions that we haven't completed yet
that that real projects tend to need and
these are things like localization
accessibility and having support
built-in so that screen readers work
correctly with apps built in Flour it's
a really important thing if you want to
take a look at it you can go to a
flutter dial that's the website for it
and there you can download it there and
try it out it works across Linux Mac
Windows and supports building apps for
for Android and iOS that's it but we
have time for questions so I'm kind of
hoping that we can get some some good
ones and I think we have a microphone as
well and maybe some questions questions
from the app so I'll start with how do
you access platform specific api's like
bluetooth etc so the the way if we
access the the capabilities of the
underlying platforms is and based on a
messaging approach where you you
implement the native code in Java
Coughlin's swift or Objective C and then
you expose that through a messaging API
to the dart layers on top and that means
that if there's a service
or a platform capability that you need
to access that nobody has has written
this kind of interface for and there are
some work to done there there is a a
collection of packages out there that
start sort of plugging back part of the
holes are there you can find access for
GPS and battery levels and all those
things so that's what I growing part of
the ecosystem and so the real answer is
you write the native code and and then
through that native code you expose a
message based API to the downside how
stable is flutter at the moment our
breaking changes likely to happen often
so flutter is quite stable and has been
stable for for a while that's very
important as we started getting
customers on board the stack that they
had a solid foundation and it doesn't
mean that we will never do a breaking
changes but we know that these things
have to be dealt with announced and
taken care of in a good way and we've
seen a few API changes that were
actually breaking over the last half
year but all in all I think that process
has gone pretty smoothly so I would say
fairly stable with very few hard
guarantees are not breaking things we do
learn from from getting new customers on
board and sometimes we find that we can
improve the API so make them easier to
discover and easier to use correctly and
we tend to do that what exactly do you
mean by compiles to native so so the way
we compiled to native code is that we
we've written a compiler from there from
top code that actually translates to
essentially a shared library objects so
beta we produce a machine code it
compiles to two not two native Java code
but two native machine code so these are
arm instructions
I'm 64 I'm 32 and we control that that
whole pipeline and generate the
efficient code for running the
applications an interesting part was
actually that early in the project we
had a bigger blue base layer more code
in C++ it's a more of the layout
were in C++ and we found that actually
moving into the to the dark side
improved their performance mostly
because you didn't have to cross the
boundary between C++ and artists often
so just like getting things together
exposing them as more user code and
getting the compiler to see all of that
actually sped up the code quite
so compiling the native code is straight
to like off code what is the migration
story for converting an existing
application to flutter and so the
migration story that's a really good
question and flutter is technically just
a view and you've seen it run in full
screen here and so there's it's it's
very conceivable to take that flower
view and embed it into some some other
other app we see people doing this where
the flutter part of their app is is
introduced and extended out on a
page-by-page basis and where it gets
more tricky is if you want to embed some
native controls directly into your your
flutter app and flutter of controls and
paints all the pixels on the screen so
that sort of merging those two things is
very hard and so we find that people get
more success if they can do it at like a
fairly coarse grained level at the
basically at the screen level so most
people that start with fodder probably
find some simple part of their app and
try it out there and we've seen people
have lots of stats were like settings
page and things that feel like they're
sort of off the side anyway but I think
that's there's a touch on a very
important thing that and most of the the
apps that we've seen ship on this so far
have been like all written in flutter
and and that that of integration story
is something we'll be looking at like
how we can improve going forward okay
there's a number of questions on this
does flutter require you to develop
using dart or can you use other
languages as well so I think the short
answer is flutter pretty much requires
you to use that in the sense that all
the API is the entire framework is
exposed as a set of bad api's something
will be very hard to do anything about
that in theory you can do anything you
put your mind to but I think that the
tooling and the framework really
promotes the writing that code here it's
very very easy to integrate Java cotton
or a swift objective-c code in a project
like this and we do this all the time to
expose native functionality or platform
capabilities and but usually these
things are put in there for things that
are not driving the UI so if you have
like logic or computation or things like
that that you would like to keep in
cotton or Java you can certainly do that
I think once you start wanting that to
actually have an impact on the UI in a
in a complex way that's gonna be much
harder well do one more I think there's
a lot of questions so maybe you can stay
around after it I will be around and I
can come up any drawbacks why shouldn't
we why shouldn't we use butter or Dart
why shouldn't you use flat or dot and I
think in some sense we already touched
on that if you have a desire to do a
very sort of integrated system where you
have like lots of swift code around the
touches and builds a UI and then this is
going to be hard to use in that context
also if you're relying on custom
controls Britain in those languages that
need to be there to to build your UI
from that's also going to be hard to do
due rights I think those are the areas
where you would have less fun with it
was flutter than then and you're
supposed to alright again said yeah
Casper will stand wait I was like all
the questions I have no and hi very nice
talk Thanks I'm Lars I am wondering how
do you see in the near and far future
Florida a coexist with pwace because it
seems that there's a lot of overlap but
where for example in the Hammond told
yeah what features did they need that
would not be possible in the PWA
assuming that Apple had their thing
going at the time which they didn't and
I think there's a there's there's a big
overlap here between these technologies
and I think we'll find find things that
are better and on one or the other side
depending on what your what you need to
build here it is true that the iOS bit
used to be a real issue for for a PWA
progressive web apps and hopefully
that's going to be a solved issue in the
not-too-distant future and in some ways
what I like about slaughter over
something like PWA is is that and the
web is a fairly complex like piece of
machinery it can do a lot of things and
do it does a lot of things really really
well but it also comes with a ton of so
if legacy features things that it has to
support because it's always been done
that way and when you're building a new
mobile app on top of a foundation that's
so complex they're interesting
trade-offs involved also at the
performance front a something like
flutter and and dot is much more sort of
tuned for for that set up we've just cut
away the things that we didn't need to
build mobile apps and so they're
definitely things that we don't have to
carry around and this is where I see the
your biggest sort of difference between
those two stacks right there's something
really nice about pwas and you can just
build on top of what was already there
and there's a lot of power from that I
think when you look at the the
trade-offs and on performance and then
those things this is an area where I
think we'll see see more differences
become visible as we as we continue with
this development of a flutter is that I
sort of answered your question it's a
very hard thing right also religious yes
best questions are yes does anyone have
any burning questions would you like to
come well thank you all right otherwise
yes please remember to vote as well and