sethladd

(disclaimer: I work on Flutter)

Thanks for your feedback! I opened https://github.com/flutter/flutter/issues/12438 to track the "not playing a sound when tapped". We're currently working on improving our accessibility support.

(disclaimer: I'm on the Flutter team)

Thanks for the feedback! We are working on improving our accessibility now, which is required for our business-critical Google users and others. For example, you can follow this issue if you're interested: https://github.com/flutter/flutter/issues/12311

(disclaimer: I work on Flutter)

Thanks for the feedback. We're currently exploring how to do inline video, which we think will teach us about techniques for inline maps. These are very top requested features. Stay tuned! :)

(disclaimer: I work on the Flutter team)

We're working on accessibility right now, it's incredibly important to us and our users. A big driver here is Google's usage of Flutter. There are business-critical teams at Google right now using Flutter, and they can't launch until a11y is finished. So we're working to finish and ship it. Stay tuned!

(disclaimer: I work on the Flutter team)

What do I see when I'm running an older native version?

You will see exactly the pixels that your designer intended and your developer coded. :) Apps built with Flutter ship the renderer and framework inside the app, which helps ensure consistency and fidelity across devices, OEMs, OS, and platform. This is particularly important for brands that want a brand-first design delivered consistently to all their users. Hope that helps!

(disclaimer: I work on Flutter.) Hi, thanks for the feedback! Would you be willing to "thumbs up" this issue? https://github.com/flutter/flutter/issues/73 It helps us when triaging. Thank you!

(disclaimer: I work on Flutter.) Flutter uses its own renderer based on Skia. Flutter essentially asks the OS for an surface to draw onto, and then Flutter draws all the pixels through Skia.

(disclaimer: I'm on the Flutter team)

We're looking at ways to make it easier to glance at and understand Flutter code. Here's one experiment: https://github.com/Dart-Code/Dart-Code/issues/383

Notice how we're auto-inserting "synthetic" comments to clearly mark the closing parens/brackets. So far, the feedback has been very positive, it helps improve scanning and reading the code.

Feedback welcome (via the GitHub issue :)

[disclaimer: I work on the Flutter project]

One of the reasons we picked Dart was that is compiles to ARM (native) code. Dart has been pretty efficient for the project so far, but we haven't yet looked very deeply at battery life. Something to keep an eye on!

[disclaimer: I work on the Flutter project]

We're adding more Cupertino (iOS-flavor) widgets. A few that we already have: spinner, toggle slider, button, alert. Check out the library (https://docs.flutter.io/flutter/cupertino/cupertino-library....) and let us know which ones you'd like to see next! https://flutter.io/issues

Thanks!

(disclaimer: I work on the Flutter team.)

You can use Flutter today to write an app that runs on iOS and Android. :)

Yes, strong mode and the Dart analyzer are all available in the Dart SDK. (Strong mode is in development, but it's still quite useful.)

(disclaimer: I work on the Flutter team.)

It's true that Dart is an optionally-typed system, and that type annotations are ignored at runtime. That may seem scary at first, but we built an analyzer that statically analyzes your program and gives you feedback (errors, warnings, and hints).

Dart is used at Google to build very big and complex apps, and our engineers use the analyzer in their build/CI systems to check their program. The analyzer is also wired into their IDEs. So they get feedback if a method doesn't exist, or you are trying to pass a variable into a method that is expecting something else.

The Dart team is also working on an optional analyzer feature called "strong mode", which does even more static checking. In strong mode, you can't write code that is incorrectly typed (but, you can still write code that is dynamically typed, if you want to).

Our experience, at least internally, is that as your program matures and grows in complexity, developers appreciate the extra checks provided by strong mode. The win is that it's something you can turn on later, when you're ready. Early on in the program's development, you are probably refactoring a lot and you don't want to bother with strong mode. This scalability is a win for us.

Thanks for the comment. We'll change our FAQ. Issue filed here: https://github.com/flutter/flutter.github.io/issues/55

(disclaimer: I work on the Flutter team)

Yes, strong mode is something the Flutter team uses to help check their code.

Dart is pretty cool this way: you can scale up or down how much "typiness" you want. As your program matures, you can dial up the static type checking. Hence: strong mode.

Dart is much more full-featured than CoffeeScript. Dart is a completely new language, with much improved semantics. Dart has features such as method cascades, mixins, async/await, optional types, a rich core library, factory constructors, libraries, named parameters, lexical this, Futures, implicit interfaces, generics, and lots more.

[disclaimer: I'm on the Dart team]

Google Ads uses Dart for their next-gen web interfaces. That's a good committed user for us to have as a partner. :)

[disclaimer: I work on the dart team]

Any chance you can share more details? You can send me a message with @sethladd or plus.google.com/+sethladd

[I'm a PM on Dart, and would love to learn more.]

Cheers!

It's only megabyte heavy if you use all of Dart's reflection capabilities. If you don't use dart:mirrors, Dart is competitive in size when compiled to JavaScript, especially when you consider that a modern web app today contains a bunch of support libraries like jQuery (which itself is ~30kb). With Dart, you don't need jQuery because Dart's dart:html and dart:core libraries are pretty good out of the box. Of course, do your own measurements as each app is different.

Dart is great for scripting and server-side today.

Check out https://api.dartlang.org for our core libraries... lots of good stuff in there (collections, async, networking, files, sockets, etc).

And if you don't find what you're looking for, check out https://pub.dartlang.org for third-party packages. Everything from crypto to game loops to graphics to frameworks to database drivers, etc.

As for scripting, you can definitely use Dart for console scripts. You can write really simple scripts with just functions. You can read stdio and stdout. (you can even do it synchronously, which is much easier for console scripts :)

Dart had Futures and Streams (the underlying classes for async) built-in from day one, and Dart has always been an event-loop-per-isolate language. The async/await/etc language features just make asynchronous programming much easier.

You'll need to compile to JavaScript to use Dart on the web. Lots of our developers say that the net win for them is the language, libraries, and tools they use while developing their app.

There are business critical apps built in Dart here at Google. You're in good company. :)

You might want to check out Dart (https://www.dartlang.org)

* Optional types

* The VM compiles source into machine code on the fly, or you can embed the VM into your app.

* No pointers.

* Core library is full-featured (https://api.dartlang.org/apidocs/channels/stable/dartdoc-vie...)

* Third-party libs and packages in https://pub.dartlang.org

* Docs at api.dartlang.org and www.dartdocs.org

* Debugger works in Eclipse, IntelliJ, WebStorm

* Works in Win, Mac, Linux, 32 and 64 bit.

* Also runs on ARM and MIPs

* Isolates for memory-safe concurrency

* Async primitives like Future, Stream, and async/await

(disclaimer: I'm a PM on the Dart team)

Not sure about PDFs, but the text for Dart Up & Running can be found here: https://www.dartlang.org/docs/dart-up-and-running/

[disclaimer: I work for the Dart team, and I'm a coauthor of that book.]

I fixed our repo. The next time we push the site, it should be fixed. Thanks for the report!

Yikes! Not good. I just opened: https://code.google.com/p/dart/issues/detail?id=19708

Our pleasure. If you're curious, I'd recommend trying Polymer.dart again. The latest version (0.11) has a transformer that replaces the reflection code with static code. The resulting output is much smaller. :)

[disclaimer: I work on the Dart team.]

1) Dart VM runs on the command line and server. You can access files, directories, sockets, HTTP, Web sockets, SSL, and more. So the core functionality is all there, out of the box.

2) When people say "node.js", they usually mean at least two different things. Forgive me if I'm assuming too much, but I'll try to answer. Node.js is "javascript + v8 + server", and the equivalent for Dart is "dart + dart vm + server". So we've delivered that. Sometimes, when people say "node.js", they mean "express + v8", and Dart has "shelf + dart vm". You can check out the shelf package here: https://pub.dartlang.org/packages/shelf

3) There are a few emerging server-side frameworks out there (I mentioned shelf above). Dart VM is asynchronous, so you'll get a Node-esque experience. There aren't plans to make a fully sync server API.

4) That would be cool!

Hi! The Dart VM does run on the command line, and can access files, directories, sockets, HTTP, web sockets, and more. The Dart VM is an asynchronous light-weight server. I don't think Dart has a Java EE mentality. Far from it. :)

[disclaimer: I work on the Dart team.]