What is Reddit's opinion of
Dart?
From 3.5 billion Reddit comments
100 reviews of this app found across Reddit:
Going from Flutter v1 to v2 is going to be quite a big job I’m afraid. Version 2 introduced non null by default (NNBD) which means you’ll need to go through your app and mark if each variable should be nullable or not.
There’s a tool to do this, but you shouldn’t trust it blindly. You can also opt out individual files and deal with them later if you like.
There are some more detailed instructions here: https://dart.dev/null-safety/migration-guide
>I call it my billion-dollar mistake…At that time, I was designing the first comprehensive type system for references in an object-oriented language. My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years. – Tony Hoare, inventor of ALGOL W.
Effectively, null makes it way easier to write code that can crash. Devs trained to deal with null know to always check if an argument passed into a function is null or not, but you have to remember to write code to check it, otherwise it can blow up unexpectedly.
By making nullable types explicit to the compiler, you can force the dev to unwrap potentially null objects before using them, or let the dev explicitly say that a function requires a non-null object instead.
At the end of the day, it's about reducing confusion and giving the compiler one more way to check that the dev didn't make a fatal mistake.
If you're interested in learning more, this is a great writeup of both "why" and "how" dart is making types null-safe: https://dart.dev/null-safety/understanding-null-safety
Apps and Examples are packages. Almost all Dart code is some sort of package.
"Library Package" – in the context of that document – refers to packages meant to be reused. Either via pub.dev – or within a bigger project/company/etc.
In general, every Dart file is it's own library EXCEPT for parts.
As noted here - https://dart.dev/guides/libraries/create-library-packages#organizing-a-library-package - we don't recommend using parts. They can be nice for code generation, though!
Why are method names in Enumerable CamelCase? This goes against dart style guide and it makes it rather weird to look at next to other dart code. Dart is very rigid in regards to code style (dart_style doesn't even let you configure indentation), but there is a good reason for that and your package breaks the consistency.
Edit: I see somebody already file issue about this.
See https://dart.dev/guides/language/language-tour#constructors
Use the factory keyword when implementing a constructor that doesn’t always create a new instance of its class. For example, a factory constructor might return an instance from a cache, or it might return an instance of a subtype. Another use case for factory constructors is initializing a final variable using logic that can’t be handled in the initializer list.
https://dart.dev/guides/libraries/create-library-packages Is this what you're looking for? Otherwise, you might want to browse pub.dev's flutter section and look at the repository structures.
​
PS there is no united 'API client' structure. It works on a API by API basis.
Never coded in Dart, but just googled. Could this be what you're looking for: https://dart.dev/guides/language/language-tour#getters-and-setters ?
> It's like that stupid 80 character line limit from the days of 1024x768.
"Readability studies show that long lines of text are harder to read because your eye has to travel farther when moving to the beginning of the next line."
https://dart.dev/guides/language/effective-dart/style#avoid-lines-longer-than-80-characters
Because I already knew how to program, I didn't need much of a tutorial on that, but just to get up to speed with the language differences. I found this site to be extremely helpful. I read it like 3 times. https://dart.dev/guides/language/effective-dart/style
It's an aside, but as I understand it, the Python id() function doesn't actually give the memory location by design. The design is it just returns a unique identifier, which in CPython just happens to be the memory address (see: https://stackoverflow.com/a/15667328).
In Dart, as far as I know, there's no ability to directly manipulate the memory addresses. The only place where the word 'pointer' exists is in the C interoperability (https://dart.dev/guides/libraries/c-interop). Like in Java, all the object variables are references, but no, you can't do arithmetic on the memory addresses (I can't think of a high-level language where you can, let me know if you know of one that does allow it).
Are you able to outline why you would want to use pointers in Dart?
When you "suddenly" upgraded your SDK past dart 2.12, null safety rules came into effect. Be careful when you upgrade a major version of anything (especially your SDK) because major version changes are generally breaking.
https://dart.dev/null-safety/migration-guide
You will definitely need to use null safety in the future, and migrate existing projects.
I don't think it would be ideal. Learning to program is not a focus of the platform. For instance, if you read the Dart Language Tour, this is the first paragraph under the heading of "Classes":
>Classes
>
>Dart is an object-oriented language with classes and mixin-based inheritance. Every object is an instance of a class, and all classes descend from Object. Mixin-based inheritance means that although every class (except for Object) has exactly one superclass, a class body can be reused in multiple class hierarchies. Extension methods are a way to add functionality to a class without changing the class or creating a subclass.
If you haven't had any development experience, you won't know what any of that means.
I'm not saying you couldn't learn programming with Flutter, but I don't think it would be the most efficient route. I would suggest learning something else first, and then coming back to Flutter.
Thank you so much for your valuable reply and feedback! I have modified the post to be a little more accurate, as you said.
Yep, I know about that article. I actually found it on the Chinese Dart Website. It's pretty unfortunate that there's no update on the official dart.dev website.
I will make a tutorial up next on YouTube regarding this and I'll update the post when I'll upload it. Thank you again!
Good overview of the differences between c# and dart, however I think you could’ve also mentioned the getter/setter syntax in dart, like in the first example:
int getAgeInDays() => DateTime.now().difference(dateOfBirth).inDays;
It can be written as (and is recommended by Effective Dart):
int get ageInDays => DateTime.now().difference(dateOfBirth).inDays;
https://en.wikipedia.org/wiki/Tony_Hoare#Apologies_and_retractions
Some newer languages (or more recent versions) fixed it with things like nullable types. E.g. everything is non-nullable by default and if you want null to be also a potential value, you have to opt-in. And then the compiler will remind you to check your nullable values before you do something with them which would break everything if the value happens to be null.
This works pretty well. It encourages you to use nullable types as little as possible and it also reduces the automated nagging to the 100% justifiable minimum (with good flow analysis).
Here's how that kind of thing looks in Dart, for example:
With null safety, your runtime null-dereference errors turn into edit-time analysis errors.
It's really helpful.
The underscore _ refers to a parameter of a function/method that is not being used in the function body.
The signature would normally be build(context, scope, child). I don't use the child parameter, therefore I hint it as unused by placing the underscore.
I think the choice to not promote fields based on flow analysis makes sense to really achieve soundness, since subclasses can always overwrite the field with a getter that has the ability to modify the field again, but I think the docs describe it well enough already.
Personally, I use the pattern where I copy the field to a local variable first and then check its nullness, but I realize that this might be a little inelegant, especially when it comes to setting the field and not just reading it.
However, I think that this forces me to write better code in general and rethink whether I really need a nullable field. For example, if it's an array, I would just give it a default value of [], and so on wherever possible
I am not a fan of fixing the language in the userland. When I have to deal with JS I always use TypeScript but it just fakes OOP. Best part are the visible modifiers private public. The var ist still accessable type-script just puts an "_" in the name.
In my latest projects when I need to deal with js I use Dart instead (https://dart.dev/) and then I use: https://dart.dev/tools/dart2js. This feels better but still the same problem and the end you get normal js. But at least the language itself is not broken.
Very good question! I can give you an example from my personal experience. For context, I was leading a team of Flutter developers.
What are best practices for this platform? Starting with official documentation, you can get a pretty solid idea of how the language should be used. Next, architecture. Given a state management tool, you need to be able to implement it efficiently. We used BLoC. Therefore, check official examples, make a mental map, and never overstep these boundaries. For instance, junior Flutter devs tend to adopt BLoC, not really understand it well, give up and mix business logic in UI layer. When this happens, you need to sit down with your team, solve the particular issue together, discuss it, and then closely supervise as they solve similar issue on their own.
Lastly, code quality tools. Depending on the platform there's a variety of choices. Team needs identical settings of their formatters and linters.
So how do you have a visibility on progress? Well, you already have the official guide (Effective Dart), you already have a mental map on how to implement state management solution, you already have your formatters and linters. The metric is how far away do you deviate from these rules. Closer to zero, the better.
I'm not the control freak who would yield a statistic "you've stick to 94.52% of guidelines in the 27 page guide, that's a 4.91% increase from last month". No. You see the progress as you, and them, solve similar problems faster and better.
Read through the Dart Language Tour and the Effective Dart Style Guide these are two invaluable resources I reflect on frequently. Great code examples in there.
I also recommend reading a widget's documentation when ever you use them. Teaches you a lot about the widget :)
I don't think there is a quick and easy way to convert old projects. Someone can correct me if I'm wrong but if you really need it working you'll probably have to update all plugins and convert the project to null safety yourself.
There should be an easy generator you can pull your project through to convert it to null safety. But it will not fix plugins that are old and have probably changed somewhat.
You can find some stuff on YouTube too.
Actually the compiler error is pretty straightforward. You must either add "late" modifier[1] to tell the compiler that you won't access that variable before its initialization, or make the variable nullable[2].
- late File _image;
- File? _image;
Maybe you can use typedef.
I didn't try it since I am posting from my phone but I can give you the link to the dart doc, so you can experiment.
Please do tell me if it works
By the way, the Dart team recommends you don't specify the type: https://dart.dev/guides/language/effective-dart/design#avoid-type-annotating-initialized-local-variables So if consistency with other packages (especially official ones) seems desirable to you, this might be a good way to go :)
Relevant section of the guide: https://dart.dev/guides/language/effective-dart/usage#avoid-using-iterableforeach-with-a-function-literal
It's what the style guide recommends. Apparently the compiler is not smart enough to work out that two imports are equivalent if you mix import styles, so they settled on a standard of relative imports for all local lib imports as the recommendation.
Also, if you're not using a linter in your workflow, you really should use a linter. The standard dart linter has rules[1][2] for this.
Have a look here: https://dart.dev/guides/language/language-tour#instance-variables
And for late variables: https://dart.dev/guides/language/language-tour#late-variables
Especially this: "This lazy initialization is handy in a couple of cases: 1. ... 2. You’re initializing an instance variable, and its initializer needs access to 'this'."
>> For example, though server-side Dart isn't as popular as some other languages, there are still lots of people in the community who are interested in it.
This has been happening since 2011 and nothing has changed. What do you think: "Why?"
Perhaps you think this was not always the case. And, probably, you think that earlier (9 years ago) the Dart community was not interested in this.
No, nothing has changed. And 9 years ago everyone wanted the same thing, and now everyone wants the same thing, but nothing changes. The world (more precisely, Dart) does not change.
If you can read and understand what you have read, then pay attention to what is written on the first page of Dart.
Dart is a client-optimized language for fast apps on any platform
Google makes it clear to everyone what Dart is not, and in what developers will not invest a penny.
For developers (Google), the question has long been resolved and the answer is already so obvious that trying to understand the obvious is, in fact, pretending that you do not understand what is and what, and what is actually happening.
It may be worth paying attention to the fact that the developer does not hide anything from anyone, but, on the contrary, has placed the obvious in the most conspicuous place so that everyone knows and understands it.
https://dart.dev Dart is a client-optimized language for fast apps on any platform
P.S.
I am not saying that this is good or bad.
This is bad for me, for Google this is what it should have been.
Keep this in mind, if you hope that a kind uncle will come and write the code you need for you, then this may never happen.
If there are such people, then they will definitely not be engineers from Google...
I recommend checking out this documentation regarding formatting in Dart. It contrasts what you are attempting todo. If you read Effective Dart, it states you should have lines that are 80 characters or less, because the human eye can digest narrow columns faster than long ones. I would recommend not disabling this feature.
Thanks for the repro!
One of the things I've noticed is that the versions of the plugin you're using in your pubspec.yaml are very old.
I'd start by updating these to:
google_maps_flutter: ^2.0.0
google_maps_flutter_web: ^0.3.0
(Note that pub dependencies don't roll forward like NodeJS', in pub: ^0.X.0 means: "From 0.X.0 until 0.X+1.0", and not "everything after 0.X.0". Info: Dart Caret syntax)
Other than that, I'll add some tags to the issue so it gets triaged appropriately!
They're usually used to initialize private class fields or do computations for fields that would otherwise have to be marked as late if they were set in the constructor body.
https://dart.dev/guides/language/extension-methods has a small description of the behavior you're describing.
> The reason that dynamic doesn’t work is that extension methods are resolved against the static type of the receiver. Because extension methods are resolved statically, they’re as fast as calling a static function.
By constraining extensions to the static resolution, dart doesn't have to inspect the object at runtime, which makes them more performant. It also eliminates some tricky corner cases when extensions are declared in separate files -- Since the extension doesn't truly alter the underlying String, the extension methods are only valid where they explicitly imported.
If you truly need to apply the extension method on y, AND if you're confident that y will always be of type String, you can do so this way:
extension A on String{ String get foo => 'foo'; }
void main() { print("abc".foo); final String x="bar"; print(x.foo); final dynamic y="baz"; print((y as String).foo); }
May I also suggest doing something like server side apps in Dart? Flutter is one thing on its own as a framework, but your post mentions expanding your knowledge of dart, so I’d suggest using the same language but in an entirely different way. Try something like the recently announced Cloud Run or Compute Engine ways to run Dart in the cloud: https://dart.dev/server/google-cloud
>The opposite is not true (non-null safe into a null safe app).
Not exactly. You can still execute it with unsound null safety. Basically, if I understand this SO answer correctly, types coming from non-null-safe dependencies will be treated as non-nullable (hence the unsoundness).
For a Dart console application it could be feasible to simply call an existing converter application. If you want to compress static assets for a flutter application, such a step can be added to the build process. Webp supports both lossless and lossy compression, results often in a smaller file size than PNG or JPEG and is supported by Flutter.
I had programming experience of other languages, just started reading https://dart.dev/guides/language/language-tour helped me tremendously. Even after one year of Flutter development it's still a standard open tab in my browser as reference.
And if course, googling for specific issues also help a lot...
You're very welcome! The docs have been updated to remove that note: https://dart.dev/guides/language/language-tour#switch-and-case
(If you look at the issue, our theory is that Gilad Bracha just hated switch statements.)
What you can do now:
analyzer: exclude: [build/**] language: strict-inference: true strict-raw-types: true strong-mode: # never implicitly cast types down implicit-casts: false errors: missing_required_param: error
in your analysis_options.yaml. This will treat a missing required parameter like an error.
What you can do soon: https://dart.dev/null-safety/understanding-null-safety#required-named-parameters
you can just host the plugin in your own repo and add the repo dependency in your pubspec.yaml
Hello, sorry to hear that. In my experience, if you haven't breach any refund policy like downloading the video or exceed 30 days, they'll give back your money.
My main source in learning dart is the official dart tour and this playlist on youtube by tensorprogramming. I find that depending on courses to much is restricting me and make me to dependent on that courses (courses are like the starting line), so make a leap of faith to just play with anything i want to explore in dart, read blogs, stackoverflow and official dart videos helps a lot too !
myList.forEach((value) {
value++; // 'value' is just a copy of the actual value
return; // return not necessary
});
Hope this helps:
void main(List<String> arguments) {
final map = <String, int>{
'One': 1,
'Two': 2,
};
print(map); // prints: {One: 1, Two: 2}
map.forEach((key, val) => map[key]++);
print(map); // prints: {One: 2, Two: 3}
final list = <int>[1, 2, 3];
print(list); // prints: [1, 2, 3]
for (var i = 0; i < list.length; i++) {
list[i]++;
}
print(list); // prints: [2, 3, 4]
}
Read more about lists and maps here: * https://dart.dev/guides/language/language-tour#lists * https://dart.dev/guides/language/language-tour#maps
Okay, it seems there are multiple definitions of the "soundness" of a type system.
I meant soundness in the sense of "you absolutely can rely upon the guarantees of the type system". It doesn't imply how strong the type system is - a type system can be weak, but still be sound.
Or, as the dart.dev site puts it:
>Soundness is about ensuring your program can’t get into certain invalid states. A sound type system means you can never get into a state where an expression evaluates to a value that doesn’t match the expression’s static type. For example, if an expression’s static type is String, at runtime you are guaranteed to only get a string when you evaluate it.
That's also in line with what this article uses when demonstrating that Java's type system is unsound because you can assign a String to an Integer with some weird tricks and weird types that cannot have instances.
Note that the documentation of the @sealed annotation talks about packages, not libraries. If you create a separate package and place your Result there and then import it from another package and try to extend it - then you will get a hint which looks like this:
$ flutter analyze
Analyzing xyz...
info • The class 'Result' should not be extended, mixed in, or implemented because it is sealed • lib/main.dart:5:1 •
subtype_of_sealed_class
1 issue found. (ran in 6.2s)
Of course you would still be able to run this code, because annotation does not have any runtime effect.
> Unfortunate at the moment there are not many analyzers that can point to that issue
When you see the word analyzer appear somewhere in the Dart code or documentation - this word refers to the Dart analyzer, which powers IDE completion and CLI like flutter analyze, rather than some abstract analyzer tool.
maybe itsn't fully AOT like Go, it needs runtime to execute AOT compiled code which isn't fully in binary
>The AOT-compiled code runs inside an efficient Dart runtime that enforces the sound Dart type system and manages memory using fast object allocation and a generational garbage collector.
depends on your OS: https://dart.dev/get-dart. Go for dev channel when installing.
then you add on your analysis_options.yaml:
analyzer:
enable-experiment:
- non-nullable
Beware! If you are interested in server-side Dart I recommend looking into the "shelf ecosystem".
https://pub.dev/packages?q=Shelf
Shelf is a modular approach that is officially backed by the Dart team. Alfred is not part of Shelf.
If you like simple approaches I can recommend https://pub.dev/packages/shelf_plus package that looks similar to what Alfred is doing.
Official references: https://dart.dev/server
I'm not sure what you mean? Dart has classes: https://dart.dev/samples#classes
and you can do interfaces as well though it's not as explicit as TypeScript or Java: https://dart.dev/samples#interfaces-and-abstract-classes
Hello sir,
In terms of the installation process you just need to install the ARMV7 SDK from here https://dart.dev/get-dart/archive
In terms of performance:
compiling the dart code from the Rpi is rather slow: a basic main file with a main method takes la 15s.
running the code seems to be good, I did not saw any performance problem.
I'm not that familiar with the Dart language but a quick look at their documentations says that you can write a program using dark then use their JavaScript compiler to turn it into JavaScript so that you can you is for the web.
What made you choose Dart 2.6 instead of the latest version Dart 2.15? By choosing 2.6 you are missing a lot of recent features in the language where the most important are probably null-safety which can prevent a lot of issues.
About Dart development I would recommend actual setting up Dart on your computer and use an actual IDE. If you must do some small examples, I would use the dartpad.dev since that is actual staying updated.
I am not sure what you are looking for specifically when asking about resources for learning Dart. Do you already have a good understanding of the topics described in the language tour? https://dart.dev/guides/language/language-tour
I'm new to flutter, but I wish I'd known about the changes they made to require null-safety. That broke a ton of shit (including example code in the official documentation) and attempting to circumvent those changes leads to all sorts of problems. Updating anything is a major risk and can straight up break your apps.
The next project I make will just start off with null safety right off the bat so I can avoid the headaches.
A few things that I find most helpful now a flutter developer are these:
- Learn dart programming language. It's an excellent language and there are still a few things I learn occasionally that surprise me (in good way). I recommend reading all the way through the Dart Language Tour.
- Learn the flutter framework first (widget tree, render tree,
BuildContext, routing, stateless widgets, stateful widgets, etc). Perhaps learn a widget or two each day via the catalogue). - How to write good tests for my application. From unit to integrations tests.
- Consider how an application/project might scale
- Use the state management solution that works
According to the [official documentation](https://dart.dev/null-safety/understanding-null-safety), your code should be safe by default. What that means is that casting away nullability with ! should only be done when you're absolutely certain that casting type to the underlying non-null type is safe.
A much better approach, in my opinion, is to use the "if null" (??) operator. This provides a default value if the subject is null.
Never used Flutter but you should definitely start learning Dart, before going into Flutter, and somewhat understand the concepts mentioned in the Dart Language Tour (not saying you should remember every single detail but at least recognize stuff so you know it exists and can look it up when needed):
https://dart.dev/guides/language/language-tour
And for API, you can use this if you are only using Dart: https://api.dart.dev/
And this if you are doing Flutter (it includes the Dart SDK): https://api.flutter.dev/
https://dart.dev/null-safety/understanding-null-safety
By the way, this is not directly related to your question, but a useful thing that exists in Dart is ?? which is the "if null" operator. Its official description is:
> If expr1 is non-null, returns its value; otherwise, evaluates and returns the value of expr2.
So, for example, instead of
if (thing == null) {
otherThing = "default value";
else {
otherThing = thing;
}
You could use
otherThing = thing ?? "default value";
… is known as the spread operator.
From the languge tour:
> provides a concise way to insert multiple values into a collection
If it's worth it? Totally!
Null safety is a game changer, a lot of behavior will become clearer and a lot of code will become shorter and safer and more readable.
I migrated my app and a couple of packages I was using that weren't still migrated to null safety, it's not a difficult task.
Watch the video and use the migration tool, you'll finish in no time.
For collections, you have Sets, Lists and Maps. They live in dar:core. The docs for that are pretty good, In my opinion.
You can implement other data structures using these.
https://dart.dev/guides/libraries/library-tour#dartcore---numbers-collections-strings-and-more might be a good place to start.
You shouldn't look at it language-first. You should look at what framework you want to use and then use whatever language the framework employs.
If you want cross-platform you could program using Google's Flutter UI toolkit/framework, which of course uses the Dart programming language. Another possibility is to make the app using HTML-CSS-JS like a web app but wrap it in Electron, which makes it run standalone on desktop OSes such as Windows, MacOS, and Linux. I do consider Flutter to be the superior choice.
​
I'll also add that you usually should avoid using !. Typically you'll see it in cases where there's a nullable non-local variable:
if (object.property != null) { object.property!.doSomething(); }
but a better approach often is to use a local variable so that the null check can automatically promote it to a non-nullable type:
final objectProperty = object.property; if (objectProperty != null) { objectProperty.doSomething(); // No ! needed. }
Also see https://dart.dev/tools/non-promotion-reasons, and for the explanation why only local variables can be type promoted, see https://stackoverflow.com/q/65035574/.
nullableVariable! asserts that nullableVariable is not null. If it is, your program will crash. In other words, it casts a nullable type to a non-nullable type.
nullableVariable?.somethingElse() is a short-circuiting null check. If nullableVariable is null, everything to the right of the ? is ignored. It's essentially shorthand for:
if (nullableVariable != null) { nullableVariable.somethingElse(); }
You should read https://dart.dev/null-safety/understanding-null-safety if you haven't already.
You've missed the point. Of course you can have git packages and refer to them via tags in your pubspec, what you cannot do though is use version and constraint solving between git packages that depend on each other.
If you ever want to create this "while loop" in Dart, use Generators.
https://dart.dev/guides/language/language-tour#generator
An async generator will return a stream. Listen to this stream and you'll receive a notification every time a generator generates a value.
int _value = 0;
// This is obviously bad, an useful generator would
// have a way of knowing it should stop generating values, like
// a "close" method of a class this generator is part of.
Stream<int> intGenerator() async* {
while (true) yield _value++;
}
I made a video series on firebase and there's lots of things which could help you from there:
- Prefer async/await syntax over .then. It is much easier to get the results of futures and make sure things are awaited properly. Error handling and returning a value is also much easier
- Use JSON serializable to model your firestore documents. What this means is, take every field in the JSON of your firestore document and put it into a dart class. By doing so, the type of `document.data` will be your dart class instead of just Object. You will never need to do something manually in the json like
'name': addedRestaurant.nameever again. Firebase has to and from json converters you can pass in and it will parse it all for you automatically - Setup your firebase instance in either main or a splash screen. Create a service which has methods like uploadImage, opposed to static methods. Those helper methods are odd and not very helpful lol, ref already has a method called putFile, what is the point of those methods?
You upgraded past a completely breaking point in flutter/darts history. Your project is not null safe, but now your SDK is. So your project needs to be updated to be null safe.
I read Intro to Dart for Java Developers and A tour of the Dart language. And some things learned in app development process.
It suggest you to use extension
So I didn't need to do
var isLeapYear = WorkWithDateAndTime.isLeapYear(dateTime: DateTime(2021));
print(isLeapYear)
Instead
DateTime(2021).isLeapYear// returns false
Well, the inheritance part of Dart is very similar to other object oriented programming (OOP) languages with classes that can be extended in different ways. I don't really have any guide for a general introduction to OOP concepts but you can find an overview of what you can do with classes in the Dart Language Tour: https://dart.dev/guides/language/language-tour#classes
For asynchronous programming I recommend following the codelab: https://dart.dev/codelabs/async-await
And the new article about doing concurrency in Dart which also describes how Dart program works using event queues: https://dart.dev/guides/language/concurrency
Could you give some details about what you are looking for and for what skill level? Normally, I would recommend going though the documentation on https://dart.dev since that is updated for the newest release and is rather good and detailed enough for most developers.
But I don't know if you have already tried going though the official documentation and found it boring, not fitting for your skill level or some other reason.
Bad docs . They have
- little to no cross-referencing,
- few code examples,
- no alternate suggestions,
- no user comments/questions,
- many obvious omissions (such that I think the documenting may have been passed off to a junior).
- too many assumptions to be pedagogically useful to a newcomer
They're written by Google engineers, compiled mostly from the source (ie, like javadocs), and best suited to internal Google consumption. They are wholly unsuitable for learning from and mostly unsuitable as a reference. For public consumption and learning purposes it should have been professional documentation writers, as in the old days.
Meanwhile the cookbooks and guides are superficial and miss out details needed for obvious use-cases making them mostly useless. Even just the dart language 'guide' (misleadingly calling itself a 'tour', and which took me hours to realise it was THE language manual) doesn't go in to details, and you are left having to resort to a dense and difficult language specification that even a CS student would hurrumph at unless the exercise were specifically about language specifications. Enjoy this https://dart.dev/guides/language/specifications/DartLangSpec-v2.10.pdf
In the end I think you would get more value from reading the source after you've used third party resources to learn. But first whip up a couple of apps to get in to the groove.
Looking pretty good, but paddings are off everywhere, in general UX is so so.
Also pretty tough to give feedback as it is not in English.
Ok after a glance
File names should be low_case_underscore
https://dart.dev/guides/language/effective-dart/style
why insertCustomCake does not use Cake.toJson
urlAPIBD + '/bolo' should be '$urlAPIBD/bolo'
use SafeArea
use l10n
use theming for text themes
one file = one widget
200+ lines long build methods are no go
I strongly advise to read effective dart guide
Thanks for the code example. In your class Quiz you have the field questionIndex. As you marked this variable as a final it can't be change after you gave it a value and that's why you can't use it into constructor. For be able using it into class constructor you can assign it there with some default value like it:
class Quiz extends StatelessWidget {
final int questionIndex;
Quiz({
this.questionIndex = 0,
});
And the second one that I can see you trying to assign value of type int to the type Function here:
final Function() answerQuestion = 0;
You can't do this because they have the different types. You can only assign int = int or Function = Function. Try to just delete = 0;.
And by the way what code editor do you use? Because it seems like you don't have dart analayzer there. Maybe this article will be helpful https://dart.dev/guides/language/sound-problems.
Did you take a look at this?
Basically you’re trying to assign null to a value that’s is not nullable.
You only need to write required this.someVariable without the @.
I think this is a great project. I'd just like to comment on the code style. Yes, I know, I'm the "tech boomer" that's overly into sticking to best practices, but still.
- Class members should use lower camelcase
- I see you're not using any linter, and it seems like you're not always passing static code analysis. Use formatters!
- Documentation is mixing English and Japanese. Now, I'm totally for translation of English documentation into your native tongue, but I'm not sure mixing them together like that is legible. Maybe it's just me, but I'd rather have two separate documentation available.
Otherwise, good project!
Prefer is not an error. This is called linting. If you look in your pubspec.yaml file, you probably have this included:
# The "flutter_lints" package below contains a set of recommended lints to
# encourage good coding practices. The lint set provided by the package is
# activated in the `analysis_options.yaml` file located at the root of your
# package. See that file for information about deactivating specific lint
# rules and activating additional ones.
flutter_lints: ^1.0.0
What it is saying is, use const when possible. Presumably you don't know the difference yet between const, late, static, final, var and how they interact with each other. This is a pretty large subject so I'll just link you the language tour. Don't expect to understand it all right away, it's a lot of new words. Maybe to start, scope down your reading to what "compile time constant" means.
const variables are compile time constants (and are implicitly final).
There are other differences too - for example, you can change the fields of final objects, but you cannot do that with const.
Check the language tour for more info - https://dart.dev/guides/language/language-tour#final-and-const
Other people suggested overriding the dependency version. This really can work if the API didn't change or if just new things got addeed.
Also I suggest looking if the affected packages have a developer build on their git page. Sometimes the author has already fixed the issue but hasn't released a stable version yet.
Then you can use this to add a dependency directly from GitHub or other git remote repositories.
I would not have been able to Google that myself although I went through most of Packt Flutter Cookbook, dart.dev tutorials and some other cookbooks and tutorials on flutter.dev, terminology seems to be the key in successful searches.
You can use ffi (Foreign Function Interface) for calling methods in C libraries. You can write your code in C, C++ or even Rust and export methods you want to access from dart and compile the code as dynamic library (.dll, .so, .dylib) file. And you can use dart:ffi package to import and call methods in the library.
This is not exactly what you're asked for but I don't think it's possible for flutter projects and dart team suggests using ffi for running code from another languages.
You can check out C interop from dart docs for additional information.
If you know you will only listen to a Stream once during the entire lifetime of that Stream, then you can use an ordinary Stream.
If you will listen to it repeatedly, or by different listeners at the same time, you need to make the stream into a Broadcast Stream.
https://dart.dev/tutorials/language/streams#two-kinds-of-streams
Actually the migration tool has added quite a few "!"'s on the old textbook code found here: https://github.com/PacktPublishing/Flutter-Cookbook/tree/master/chapter\_06
Migration tool: https://dart.dev/null-safety/migration-guide#migration-tool
I think the best suggestion, while most ambiguous at the same time, is the Effective Dart rule that says to consider naming things such that the code reads like a sentence.
https://dart.dev/guides/language/effective-dart/design#consider-making-the-code-read-like-a-sentence
For example, if you had a bank API where you want to take money out, I'd say this:
void withdraw(num amount) {
...
}
Is better than this:
void withdraw({num amount}) {
...
}
Because the usage of it would make the named parameter redundant.
I feel like it's safe to say withdraw(1000) or withdraw(amount) is better than withdraw(amount: 1000) or withdraw(amount: amount).
It's always a judgment call, but I like this particular rule of thumb 😄
At the time I first read the Dart programming language manual, I was already proficient in both Java and JavaScript for a number of years. I just didn't see the appeal of Dart.
Here you have a young niche language that Google is pushing, with no native environment and not many interesting libraries. The design of Dart seemed to cater towards a lowest common denominator of Java and JavaScript, failing to embrace the unique or powerful features on each side.
Java and JS are both freestanding, complete programming environments, whereas Dart has a dependent relationship to them. Worse, because there is so much Java and JS code out there already, you still end up needing to understand the quirks of those languages (e.g. data types, foreign function interfaces) and to read other people's code in those languages. Oh and by the way, I have similar unfavorable opinions for similar reasons regarding JVM-based languages such as Scala, Kotlin, Groovy, etc.; I don't see the point compared to writing straight Java.
Hey! Sorry to bother you again. I followed all of the steps and made sure my google-services.json was in the app folder but for some reason, the app is crashing on startup. Would you happen to know what this error message means?
---------------------------------------------------------------------------------------------------------------------------------
Running Gradle task 'assembleDebug'...
Error: Cannot run with sound null safety, because the following dependencies
don't support null safety:
- package:firebase_core
- package:firebase_core_platform_interface
- package:quiver
- package:plugin_platform_interface
For solutions, see https://dart.dev/go/unsound-null-safety
FAILURE: Build failed with an exception.
* Where:
Script 'C:\src\flutter\packages\flutter_tools\gradle\flutter.gradle' line: 1035
* What went wrong:
Execution failed for task ':app:compileFlutterBuildDebug'.
> Process 'command 'C:\src\flutter\bin\flutter.bat'' finished with non-zero exit value 1
* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
* Get more help at https://help.gradle.org
BUILD FAILED in 22s
Exception: Gradle task assembleDebug failed with exit code 1
---------------------------------------------------------------------------------------------------------------------------------
Ahm... Make sure you don't get into trouble tho:
The “Dart” name and logo are trademarks owned by Google. These Brand Guidelines describe the appropriate uses of the Dart trademarks by members of the developer community who have obtained our consent to use the trademarks pursuant to the Dart terms of service.
Not off hand, but it's not a big lift. Make a directory, fill it with files, zip it and move it to where the user saves the file. That's the whole thing, `dart:io` can be used to make the folder and write the files, then just zip them using the example from the package I linked. If you're looking for some magic silver bullet code you can copy paste into your project, I doubt that exists for this. The contents of that zipped folder are very specific to whatever data you need to store. I think before trying to make a single file, you need to figure out what data you need serialized and write those files into a folder. The `dart:io` guide to files can show you how to do all the directory stuff, you'll also probably need to use `package:path_provider` to get the OS's temp folder or something to write the files into before you zip them.
Look at this: https://dart.dev/codelabs/dart-cheatsheet String Interpolation To put the value of an expression inside a string, use ${expression}. If the expression is an identifier, you can omit the {}.
The term identifier refers to a variable that is not a property of an object. For example, a local integer variable (final int i = 10) would '$i'. If you were referencing an object like a variable passed to the constructor (final String bio) of a stateful widget within its state object, you would use '${widget.bio}'.
You could also combine it with other strings. For example, looking at the integer example, if you wanted the resulting string to be object.10, you could use 'object.$i'. You could also concatenate the contents of the widget.bio as well by using 'object.${widget.bio}'. I hope that helps.
This reminds me of dart, which allows if and for statements inside collection literals (array, map, and sets). There are examples in the language tour.
Yeah, dart:io/html/FFI can be challenging, especially if you're migrating an already existing app to more platforms.
Currently there's two ways to work around this (which you're probably are already aware of):
- Plugins: to have your code separate per platform; your app will only use what's needed automatically.
- Conditional Imports/Exports: To import/export code that will work on a specific platform, from the libraries that are available (if dart:io is available: use FFI, if dart:html is available, use something else).
(I'd recommend conditional imports for small bits and pieces, like this shim, and plugins for things that look more like a larger package)
I have another question. I've noticed that there are some Dart source code that dated back to AngularDart that was able to lazy-load pages by "importing asyncronously". Is there a way to do something similar in Flutter without making the mobile code too complicated?
https://dart.dev/guides/language/language-tour#lazily-loading-a-library This is what I was looking into. This should help get faster paint by reducing the main bundle on big flutter apps that are coming into web. I would like to know why this isn't too extended.
Yikes. Does Debian not have a Dart package?
Why aren't you just following the official installation instructions from the official website??
Just click on "Linux" and do what it says.
>ZDart sounds like something fucking rad
There is sh (for shell scripting) and zsh (the z shell). There's dart so maybe someday there will be a similar fork that will become zdart :)
You’re correct. However, it’s normal to not put everything into just one .dart file, but to use several files arranged into a directory structure.
If you haven’t seen it before, here are the standard conventions for file system layout
You can use Dart on the backend as well, but you're likely a bit more on-your-own there (https://dart.dev/tutorials/server/httpserver). I wouldn't worry about having to learn Dart. It's going to be very similar to C#, Java, Kotlin, etc. It isn't a radically different style of programming. Still, it's definitely a language that some at Google are pushing hard that doesn't seem to have found a following outside of Flutter.
If Flutter is appealing, I wouldn't worry about learning Dart. You haven't really said if you're at the point in your career where you're proficient in several languages like C#, Java, Kotlin, JS, but if so Dart should be easy to pick up. Even if Dart isn't going to be a long-term language for you, I don't think learning it would mean wasting time. You're going to see the same concepts (with slightly different syntax) in a lot of similar languages.
t1 = _this.button is probably because button is a field, which the compiler can guarantee is stable (returns the same result across different calls) as opossed to unstable (getters, which can return different results across different calls), so the compiler accesses the field once and stores the result in the stack (an variable in the local scope in js). THIS IS ALL GUESSES, you may want to use --dump-info https://dart.dev/tools/dart2js?ref=hackernoon.com#basic-options .
Packages published on pub are not audited. If you want to audit them yourself you need to audit the source code retrieved by dart pub get stored in Dart's package cache.
https://dart.dev/tools/pub/cmd/pub-get#the-system-package-cache
>you cannot create web components which Dart
Oh...
Could you please give any doc links — wanna know why it can't be done in Dart.
I have seen some articles from 2012 with information about web components in dart but there's nothing in the docs now — just 404 pages :(
I am not good with modern JS/TS and frontends — mostly work with plain HTML+vanilla JS/Jquery, so don't know much about the topic.
> after a couple of days of work? Yeah, I just quit it.
You can't really learn a new UI framework from scratch and develop a complete app in just "couple of days".
> having separated logic & view languages and system dramatically reduces the productivity
Yeah... that's what MVC is.
Flutter is build around Dart, and the worst is : "Dart tools may send usage metrics and crash reports to Google" (source: https://dart.dev/get-dart#install). Even if analytics aren't enabled in the release version that's a big no-no for me.
If you are super new to programming and just want to start being productive very quickly, Flutter (Dart) is a really easy to pick up language/framework.
https://www.appbrewery.co/p/flutter-development-bootcamp-with-dart
$10 gets you the video tutorials, they are a little out of date, but there is a Discord group to join and ask for help in.
There's also r/FlutterDev/ and r/flutterhelp/
If you only have a Windows or Linux machine this will easily let you make Android apps, that VERY easily migrate to iOS Apps once you can get your hands on a Mac to shore everything up.
If you have a little JavaScript knowledge then you already have a head start on it.
As someone that has made both React Native and Flutter apps, I have greatly enjoyed the ease of Flutter when using built in widgets.
BUT, if you really want a highly customizable app React Native is great!
I just personally think Flutter is a lot easier to jump into.
Honestly, just pick one and set a goal and schedule daily time to learn it and stick with it even when it seems like things aren't working or are actively working against you.
Just struggle bus through it and ask questions.