What are /r/dartlang's favorite Products & Services?

Dart runs on Google Cloud Run (which IMO will replace Cloud Functions potentially since it's better in almost every way). So you can already do this if you want.

Otherwise, it's pretty hard to compete with NodeJS with TypeScript for backend. The community is ENORMOUS and very mature. Every major organization produces a code library for their product for Node by default.

There is nothing stopping the Dart community from developing server-side dart, just not many people are doing it.

Someone could make a NestJS clone for Dart, but it would take a huge team a very long time to create it. And who would do that when they could just use NestJS since TypeScript and Dart have 95% the same syntax. NodeJS also has great performance these days.

Dart is used on the front end specifically because it compiles to native code for high performance in cross-platform apps. Google was able to fully control the ecosystem and their needs for this specific purpose with Dart.

So for the Google team to invest in optimizing compiling for backend server environments (maybe like how Rust does), we would need both Google to work really hard on yet another compile target, and a community of people to develop packages that can take advantage of that. Google doesn't really have a killer implementation for the backend (like they have Flutter for the frontend), so they don't really have a reason to do this.

I think it's possible, but Dart's community will have to be an order of magnitude larger to support that effort.

IMO, having to use two different languages is not a big deal especially if it's TS and Dart. Jumping between TypeScript and Dart is really nothing.

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!

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.

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?

I agree. There are a lot of packages that are not documented well enough. In addition there are likely many more that aren't tested well enough. I genuinely believe a package that is not both well tested (>99% coverage) and well documented (>99% public APIs), is probably not ready for production environments.

On the other hand, there excellent packages that go above and beyond. For example, the bloc library and ecosystem is extremely well documented and boasts 100% code coverage. Packages that don't have a test/ directory immediately indicated they are not production ready, even though could be an excellent look package.

Experience with JS? Sheesh... It's horrible! You need a hundred disparate libraries, each with its own way of doing things, to get a decent app going. The language itself is so bad, it inspired the book JavaScript: The Good Parts, which details how you need to strictly discipline yourself to use only the parts of JS that aren't too bad. Complex typecasting, crazy rules for truthy/falsey, the strange bugs you can produce because of optional semi-colons, terrible tooling because of a lack of strict types...and on and on.

The list of improvements Dart has over JS is so long, I won't have room for it all here, but here's a taste: True object-orientation, unified approach to everything from promises to streams, comprehensive standard library with consistent paradigms, optional types that enable great tools, push-button builds with concatenation, minification, and tree-shaking, predictable typecasting, a cool name that doesn't get confused with some other language, immutable objects that enable VM optimizations...

And it's shiny and new, imparting all kinds of geek cred for the pioneers who can use it while smugly proclaiming their superiority over lesser creatures stuck with crappy old JavaScript. "JavaScript is so 1995," they can say. "Try programming for this century."

Dart runs faster than JS when its own VM is present, and it runs great when you compile it to JavaScript so that it runs everywhere else. For frameworks, you have Polymer and Angular for Dart. There are something like 500 pub packages already available for even more free code.

pant, pant

There's more, but can I stop now?

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!

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

Runs great, so long as you are using WKWebview and iOS 8. The UIWebView is terrible. Android runs flawlessly, honestly you can't notice the difference between a Native or Web app in Android. I don't use Canvas, so I can't say anything on that.

If you are looking for a good xplat game solution, I would suggest LibGDX. I think it would really be your best solution. I have used it several times and I highly recommend it.

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.

typedef link

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

>The DartVM is bundled into the package built for the platform, along with your Dart code in bytecode form. Your Dart code runs on the DartVM on the mobile device.

Nope; Flutter apps are AOT-compiled, especially since iOS doesn't even allow JITs.

> awesome IDE with Dart support.

Does it really? According to:

https://atom.io/packages/atom-dart

Debugging will be supported "someday." The old Dart IDE supported it easily out of the box.

Loving Hackernoon on Medium. Newsvoice are doing cool things with Flutter, too: https://steemit.com/news/@crypticwyrm/newsvoice-an-app-using-google-s-flutter-framework-that-lets-you-see-news-from-different-perspectives-to-combat-bias

The Dart team is REALLY focusing everything on FrontEnd. I would personally suggest learning TypeScript as the developer experience is similar to dart - not as good, but way better than JavaScript, but typescript / node has an extremely mature and diverse backend ecosystem.

I personally build my backends with NestJS.

Hi, I blog about Dart for web at dev.to/graphicbeacon and also run a YouTube channel.

Would love to get your thoughts and suggestions of content to cover. Also subscribe and hit the bell icon if you like what you've seen :)

I've got some tutorials on DEV.to and would start with the below:

dev.to/graphicbeacon/learn-dart-before-you-flutter-2997

> Is this like the equivalent of nodejs for dart?

The standalone Dart VM is the equivalent of Node.js.

Node.js is V8 (Chrome's JS VM) plus libraries for doing I/O.

The standalone Dart VM can do I/O out of the box. Like V8, the VM itself is just a library which you can embed in other applications. Just like Node, the standalone Dart VM is an application which embeds this VM and which then exposes some APIs to scripts running inside it.

It's kinda like the DOM stuff you get in the browser. This too is something which was exposed to the engine.

Redstone is a small framework for writing things like small web servers or web services. It's somewhat similar to all those Sinatra-style frameworks or Node's Express. The direct inspiration was Python's Flask.

The basic idea of all those frameworks is that you just have to define some routes (with or without arguments) and their handlers. Those frameworks will then take care of calling the corresponding handlers whenever there is a request. For a simple service, you only need a few lines of code.

>> 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...

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/effective-dart/usage#dont-use-late-when-a-constructor-initializer-list-will-do

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).

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.)

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&lt;String&gt; arguments) {
  final map = &lt;String, int&gt;{
    'One': 1,
    'Two': 2,
  };

  print(map); // prints: {One: 1, Two: 2}

  map.forEach((key, val) =&gt; map[key]++);

  print(map); // prints: {One: 2, Two: 3}

  final list = &lt;int&gt;[1, 2, 3];

  print(list); // prints: [1, 2, 3]

  for (var i = 0; i &lt; list.length; i++) {
    list[i]++;
  }

  print(list); // prints: [2, 3, 4]
}

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

Well, flutter can talk platform specific code, see https://flutter.io/docs/development/platform-integration/platform-channels

I like the flutter approach better then android or iOS sdk, and the dev UX is better. I just prefer Kotlin to dart though.

I'm very curious about this as well.

From my, admittedly non-exhaustive, searching, it looks like you'll have to build a plugin in the "native" code and then call it from Dart. Much like Cordova's system.

One of the reasons I use Cordova is because of the large number of plugins for things like Facebook, in-app purchasing and the like.

*Edit: Here's the docs I looked at.

Here you go: https://play.google.com/store/apps/details?id=com.enigma.amitjoki since Flutter is a cross-platform development tool, deploying to iOS is entirely plausible too.

But iOS's licensing fee is a bit costly compared to the one-time payment of $25 that Google asks for. If this project gets enough love, I will go ahead and deploy it to the App Store as well :)

I've cross-posted your question on StackOverflow, which is monitored more by the Flutter team than this subreddit. I suspect you'll get an answer soon enough :)

EDIT: Did you mean desktop widget? As pointed out to me:

> The Android lock screen has not supported app widgets since Android 5.0

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

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.

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";

The issue is that you're calling moveNext() in each of your if blocks. To compare it to Java, it's .next() and .hasNext() combined, what you're looking for is .hasNext() which will check if there are more but not move on your iterator.

Issue is quite obvious in the output from here: https://repl.it/repls/HospitableZestyTruespace

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

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.

Follow this book.

This would be a good question for the mailing list: https://groups.google.com/a/dartlang.org/forum/?fromgroups#!forum/misc

Dart is awesome, but still doesn't have quite a big enough following to really get good answers outside the mailing list. Being so early in development, it could possibly be a bug and they may actually ask that you submit a ticket.

You can run server-sided applications written in Dart (or whatever) on any VPS. Digital Ocean is a popular choice, for example. PaaS options like Heroku or GAE are more convenient but also a lot more expensive.

Whether or not you can scale horizontally (that is, across several machines) depends on your architecture. Check this website for some hints: http://12factor.net/

Edit:

I am using Dart to make a Cordova App and Webapp. I like the fact I can hit all of these platforms with one code base that also includes a highly dynamic, easy to make, and modern UI system(HTML/CSS)

I most recently wrote a Dart wrapper around MapBox. Dart's JS integration is quite impressive. I had some serious doubts until I tried it, but there are no hiccups and it preforms flawlessly. I also learned today not to include main.dart.js in your index.html file. I kept having all these weird bugs from having things double initialize.

I look forward to better compiled JS, the Ability to export JS Libraries, and AngularDart 2!

I learnt following the course from Angela Yu. Despite it is a bit outdated ( I think it is from 2019, maybe) I believe it is still a very good way to start. You can find it on udemy or on https://www.appbrewery.co/.

After that, you'll be able to go in depth in any topic that you want.

Hi there, I recently got back into development for a startup I'm working on and was in the same situation. I was initially looking at ReactNative but Flutter and Dart won me over with it's more native-like experience + having worked a lot with C, Java and C# in the past I fell instantly in love with Dart.

I went through a few different courses and tutorials and have to say the the following course, which was recommended by the Flutter team themselves, proved to be the best by far: https://www.appbrewery.co/p/flutter-development-bootcamp-with-dart

There's some sort of arrangement these guys have with Google too, which means they sell the course for a mere $10. An absolute steal, even if you decide to cherry pick the modules like I did.

Good luck!

I like dart & Flutter but if you want to stay within the .NET ecosystem for a cross-plaform UI solution then https://platform.uno/ is the way to go. I think of it as .net's Flutter.

>List.from(a)..sort()

yes, that definitely looks more readable. I just tried it but unfortunately it didnt work. maybe its cause I am using dart 1.24.2 (exercises at codesignal.com). I will keep it in mind for the future though.

thank you!

>I can't imagine Dart gaining much traction server side, as there are many languages that do what Dart does, but better (like TypeScript). Dart's real niche is Flutter.

How do you see TypeScript doing better server-side? I think Dart has potential to gain momentum, but it doesn't have enough content produced to show people how to work with it server-side. I hope to change that. There are cases where it makes sense to have server-side Dart, like having a backend for Flutter mobile apps.

I would learn Dart as much as possible without the use of frameworks. See my DEV feed below for Dart tutorials. I aim to post every 2 weeks.

https://dev.to/graphicbeacon

The syntax is very similar but i also saw in dart a syntax like .. instead of the regular .

I cant use dart:html for some reason

Is there any reason string is capital but int isnt

Does dart have something like this https://dlang.org/articles/cpptod.html

I've not used them, but this is what I found - regarding Sealed Classes in Kotlin, from kotlinlang:

>They are, in a sense, an extension of enum classes: the set of values for an enum type is also restricted, but each enum constant exists only as a single instance, whereas a subclass of a sealed class can have multiple instances which can contain state.
>
>...
>
>The key benefit of using sealed classes comes into play when you use them in a when expression

'When' is the Kotlin equivalent to dart's 'switch', so I'm assuming it could somehow be useful for a switch expression, or if you just want the enum to carry some specific state.

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

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.

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 😄

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.

https://dart.dev/brand

Yikes. Does Debian not have a Dart package?

Why aren't you just following the official installation instructions from the official website??

https://dart.dev/get-dart

Just click on "Linux" and do what it says.

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 .

>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.

Extension methods allows you to add functionality to existing classes or types without modifying the internal code.

Actually, they are a syntax sugar for something like creating a new class and static methods passing the target type as argument.

To learn about it take a look at this video from Google.

sorry I forgot about the sub command.

I normally use dcli to compile scripts which is:

dcli compile <path to script>

When using dart I also normally use:

dart compile exe <path>

As this generates a standalone exe where as the snapshot requires a dart runtime.

Full doco here:

https://dart.dev/tools/dart-compile

I Core advantage of the exe is that you can copy a the exe to another machine and run it even without dart installed.

Finally I assumed the requirement to have a main entry point was generally understood, my mistake.

It is also convention to store the main executables for your package in the bin directory.

For example dcli ships with a no. of executables:

dcli

dcli_install

dcli_complete

Each has a 'main' and all live in the bin directory.

Dart will insert static null-checks to guarantee your program fails as soon as something is not right (e.g. access a late variable before it gets its value). late is really just a pinky promise you make with the analyzer. I am sorry to tell you, that Dart runtime does not trust you. :)

> The late modifier means “enforce this variable’s constraints at runtime instead of at compile time”. It’s almost like the word late describes when it enforces the variable’s guarantees.

I'm not sure that they are called "static extension methods", at least according to dart language guide. Also it's hard to think about them as a syntactic sugar for static methods since they have access to instance members while static methods don't.

I started programming 40 years ago, so I don't feel qualified to answer this. Still, I'd recommend to start small and first learn the language before diving into libraries and/or Flutter.

It might feel underwhelming to create simple command line programs that add numbers, compute your weekday of birth, or play a simple number guessing game if you have an overflowing stack of knowledge at your fingertips, ready to copy & paste everything you can think of and even more, but I'd consider it very important to first understand concepts like variables, control flow, conditions and loops, data types, objects and classes, methods and so one.

To me, the Tour of the Dart language looks like a great introduction, but it is mainly targeted at people who already know the basics, I'm afraid. It still might be something, you can use to notice what you need to learn and then dive deeper. If you feel comfortable with learning by watching Youtube, perhaps this course is helpful. It is very basic.

I think official documentation is enough and it has well written https://dart.dev/guides and also you can search google/youtube to help you understand on that particular topic

If you know nothing about Dart, then that tutorial is not the right place to start.

You should catch up with the Dart fundamentals first. What a great place Dart language tour is to start.

Give it a whirl.

>https://dart.dev/guides/language/extension-methods

I'm sorry maybe you don't understand my question, when i use a class with mixin i want to put the mixin methods in a separate extension out of the class then later i can put the extension in a separate file, but when i do that because i already ask the main class to conform to the mixin but the main class cannot find the methods in the extension. do u know how to solve this ?

In Dart (and many other languages) it is possible to make methods that look like normal properties by turning them into getters and setters.

I believe the original motivation was to avoid having to write endless getLength(), setLength() methods like you normally would in Java or C++. However I don't think getters and setters are really a great solution - they have two major problems:

It's now no longer clear when you are calling a function.
It means some properties of properties no longer hold, e.g. if you do something like this:

var a = myObject.foo; var b = myObject.foo;

Then there's no guarantee that a and b are the same. This makes NNBD really awkward.

I think with some thought we could have had a better solution to the getLength(), setLength() problem than getters and setters, but here we are.

According to https://dart.dev/guides/language/language-tour

Dart supports top-level variables, as well as variables tied to a class or object (static and instance variables). Instance variables are sometimes known as fields or properties.

If you see https://www.github.com/dart-lang/sdk/tree/master/sdk%2Flib%2Fcore%2Fstring.dart

You will find length is not a variable (external or internal) but is preceded by get keyword.

You don't need it. Like the other person said, it's for initializing class variables when you can't do it immediately for some reason.

For example, if you are using flutter and you have a TextEditingController that has an initial value passed as an argument to the constructor. Then you would use late.

This is pretty clear in the docs.

If you're starting a new project now, you should definitely consider using null safety right away.

See https://dart.dev/null-safety/migration-guide

This will fix this and so many other common issues.

Also be sure to configure the analyzer to be stricter, see https://dart.dev/guides/language/analysis-options

I use this for example:

include: package:pedantic/analysis_options.yaml

analyzer:
  language:
    strict-inference: true
    strict-raw-types: true
  strong-mode:
    # never implicitly cast types down
    implicit-casts: false
  errors:
    missing_required_param: error
    missing_return: error
    # allow having TODOs in the code
    todo: warning
    unused_import: warning
    uri_has_not_been_generated: warning
    dead_code: warning

If you turn on null safety, the answer would become obvious immediately: the second one.

In null safety they introduced a new nullish short-circuiting feature https://dart.dev/null-safety/understanding-null-safety#smarter-null-aware-methods . Basically if there was ever a `?.` operator appeared in the expression, then every following method invocation automatically becomes `?.`.

Applying this feature, you will see that the second solution becomes the most clean one. Fewest `?` (counting in `??`, three question marks in total), fewest parenthesis (no unnecessary parenthesis), also fewest operations (skips all transformation operations when null) happened.

in your example "ex1" is not constant, but the value it holds is. If you try to change the content of the list you will get an error. Read more about it here

The Dart language spec discusses this at length.

https://dart.dev/guides/language/specifications/DartLangSpec-v2.2.pdf#page165

> A Dart program consists of one or more libraries, and may be built out of one or more compilation units. A compilation unit may be a library or a part ⋄ (18.3). A library consists of (a possibly empty) set of imports, a set of exports, and a set of top-level declarations. A top-level declaration is either a class (10), a type alias declaration (19.3), a function (9) or a variable declaration (8). The members of a library L are those top level declarations given within L.

Basically, every Dart file is it’s own library. A set of files can be part of the same library if they all start with the same library declaration.

This other post someone made might help you.

https://www.reddit.com/r/FlutterDev/comments/j8kt5k/flutter_file_structure_for_big_projects/?utm_source=share&utm_medium=ios_app&utm_name=iossmf

Otherwise this documentation for creating packages might be more helpful https://dart.dev/guides/libraries/create-library-packages#organizing-a-library-package

Sorry about your inconvenience. If chocolatey is continuing to be a problem, I'd recommend just downloading the zip file and install from there. The sdk will manage versioning itself, so the package manager is really only used for installation.

Actually just checked (branch stable) - the latest stable version 2.10.0 and flutter's latest stable version 1.22.0! I'm not sure what I've checked before! It's already accessible from here. I'm personally getting it just by upgrading flutter!

it is public at https://dart.dev/tools/sdk/archive.

I guess they delay it to the public so they can make a blog article about it. However, couldn't find any article about 2.10 for now.

This package looks very strange. Can it even be used in any way? It doesn't have a lib directory and instead the code is in several top level directories. This is what it should look like: https://dart.dev/guides/libraries/create-library-packages

Also, the package is marked as discontinued on pub: https://pub.dev/packages/dart_music_theory

And for no apparent reason it has a dependency on flutter.

You'll become proficient in dart after going through the language tour and understanding everything in it. It shouldn't take more than a few hours if you've never used an OOP language before.

As it pertains to widgets. A stateless widget is just a dart class with a build method and some properties. Just like you'd have an animal class with name,weight properties and a walk() method.

If you prefer video tutorials, there's a free flutter course that also covers dart fundamentals: https://flutter.dev/freecourse

But I suggest you do the language tour first.

Sort of but not really. OP was asking about final and const which I'm pretty sure can't be local variables. I know final can't and I don't remember wanting to create a const in a function.

The section of the doc you linked refers to local variables. Check out the section directly above it -https://dart.dev/guides/language/effective-dart/design#consider-type-annotating-private-fields-and-top-level-variables-if-the-type-isnt-obvious. It says to CONSIDER annotating what OP asked.

that's right. I will also add that when you use constructor({this.a, this.b}) the fields a and b are set so you don't have to do :

constructor({ this.a, this.b }) { this.a = a; this.b = b; }

learn more here (https://dart.dev/guides/language/effective-dart/usage)[https://dart.dev/guides/language/effective-dart/usage]

To add on to #3...

The class definition creates all of the methods that are intended to be used by instances of the class.

However, in Dart you can add methods to a class even if you didn't define it. These are called extension methods: https://dart.dev/guides/language/extension-methods

With Dart, > If you want to depend on a specific commit, branch, or tag, add a ref argument: > dependencies: kittens: git: url: > :munificent/kittens.git ref: some-branch The ref can be anything that Git allows to identify a commit.

https://dart.dev/tools/pub/dependencies#git-packages

It does not help performance. When declaring and initializing a variable, e.g., MyType foo = bar, the type checker verifies that the static type of bar can be assigned to a variable of type MyType. When you write var, it simply means "whatever the static type of bar is".

The style guide recommends using var for all local variables: https://dart.dev/guides/language/effective-dart/design#avoid-type-annotating-initialized-local-variables

Great question. I can be hard to know exactly where to start. If you want to learn dart, that language tour can be an excellent place to start. Wish you luck

I think you can mix in a regular class too as long as that class has no explicitly declared constructor.

Back to my question. Why wouldn't I just use a regular class with mixins?

class NotAnAbstractClass with Mixin1, Mixin2, Mixin3 {

...

}

This is definitely out of the scope of what I know. A good pointer would be this page: https://dart.dev/server/c-interop-native-extensions

There are mentions of unit test files that could possibly tell you more about how you can do what you want.

Basically what you intend to do is the opposite of what FFI was meant to do. Calling Dart from native that is.

In any case, this is very interesting and once you figure things out, I'd be super happy to read about what you achieved.

i repost my reply here. Hope it help.

Hm, I rememberred I had also faced the same issues. At that time I run the powershell to install Dart SDK follow the guide from https://dart.dev/get-dart And it goes well with powershell. Tip to launch powershell in Win10 (might apply to other ver): Using hot key "Win+X A" to run PowerShell with Admin rights.

Hm, I rememberred I had also faced the same issues. At that time I run the powershell to install Dart SDK follow the guide from https://dart.dev/get-dart And it goes well with powershell. Tip to launch powershell in Win10 (might apply to other ver): Using hot key Win+X A to run PowerShell with Admin rights.

Sounds like a problem with Chocolatey perhaps. I installed Dart using choco initially till I gave up when experiencing Windows permission issues. Would suggest you download the SDK and place the folder somewhere like C:\src\. Then update your Environment Path variable to point to the bin folder C:\src\dart-sdk\bin.

I recommend that you get comfortable with dart before diving into flutter. The bare minimum is to read the entire language tour. It's most of what you'll need on 1 page: https://dart.dev/guides/language/language-tour

You can finish that in a couple hours.

Your other option is IntelliJ, which I love. When you paste code online, do it on a site designed for code and select Dart so it can be easier to read. Here's an example. https://pastebin.com/Y6ybtJ2u.

What language did you come from? I'm guessing a C or Java language, based on your coding style. I recommend studying and restudying the Effective Dart page on their website.

There are some adjustments that need to be made to this code as well.

Welcome to the Dart world!

Edit: Oh. Read your post completely. You came from C++

> Which style do you recommend and why?

Don't prefix. Almost no one does. Also see overarching rule #2 in Effective Dart:

> Be brief. Dart was designed to be familiar, so it inherits many of the same statements and expressions as C, Java, JavaScript and other languages. But we created Dart because there is a lot of room to improve on what those languages offer. We added a bunch of features, from string interpolation to initializing formals, to help you express your intent more simply and easily. > > If there are multiple ways to say something, you should generally pick the most concise one. This is not to say you should code golf yourself into cramming a whole program into a single line. The goal is code that is economical, not dense.

If you have some experience in OOP then you don't have to read book to be able at least build a flutter apps. You can go through dart language tour where they explain the main differences between js and show a great examples of how language supposed to be used: https://dart.dev/guides/language/language-tour

Yes Flutter comes with it's on version of dart. This is especially useful for master and dev channels. These channels make use of newer dart features.

And about your question: If you want dart on your system, install dart on your system: https://dart.dev/

Hey there :)

Did you already look at this guide? https://dart.dev/guides/libraries/c-interop

I think it's well written and helped me to understand how to bind C functions.

If you've already read this guide, could you please explain a bit more at which step you're stuck?

This does not generate idiomatic Dart: https://dart.dev/guides/language/effective-dart/design#avoid-starting-a-method-name-with-get

What you probably want is something that can turn: int foo; into int _foo; int get foo => _foo; int set foo(int value) => _foo = value;

Also see https://dart.dev/tools/pub/package-layout#implementation-files

Files under lib/src are considered private to the package. You can use export from a public library to make them available, or keep them only for internal use by not exporting them. Note that this is convention only, there are no language level restrictions to importing them.

Make things private to a library by naming them with a prefixed _. Make things private to a package by putting the library in lib/src.

What are /r/dartlang's favorite Products & Services?
From 3.5 billion Reddit comments

The most popular Products mentioned in /r/dartlang:

Dart for Absolute Beginners

Dart Apprentice (First Edition): Beginning Programming with Dart

Dart for Hipsters

Data Structures & Algorithms in Dart (First Edition): Implementing Practical Data Structures in Dart

The most popular Services mentioned in /r/dartlang:

Dart

Flutter

DEV Community

Kotlin

Atom

AngularJS

Google Groups

The App Brewery

React

Nest

Stack Overflow

Sublime Text

WebStorm

Repl.it

Codecov

The most popular reviews in /r/dartlang:

What are /r/dartlang's favorite Products & Services? From 3.5 billion Reddit comments