Update JS to Dart #4354

atsansone · 2022-11-08T20:05:33Z

Original comments are in a Google Doc.

lrhn

Some comments. Most stylistic.
The initial section on "primitive types" really doesn't work for me. The original wasn't better.
I'll try doing a rewrite myself.

src/_guides/language/coming-from/js-to-dart.md

lrhn · 2022-11-09T16:48:39Z

src/_guides/language/coming-from/js-to-dart.md

-checking for that identifier.
+Both JavaScript and Dart use data types.
+Types determine what kinds of values can be stored and what operations can be performed on a variable of that type.
+Dart differs from JavaScript in that it identifies as a strongly typed language.


The below sounds more like it describes a statically typed language,
which is also what we otherwise say Dart is: https://dart.dev/faq#q-is-dart-a-statically-typed-language.

(I know "strongly typed" is being used inconsistently on the interwebs, and it's probably also used like this.)

Pedantically, both Dart and JavaScript are strongly typed, in the sense that a value has a specific inherent type, which doesn't change over time. An example of a non-strongly typed language is C/C++, where you can reinterpret_cast a value (really a chunk of bytes in memory) to a completely different type.

Dart is statically typed in that we assign a static type to every expression and variable.
(And it's soundly typed because the runtime type of the value of an expression is correctly predicted by the static type. Sound static typing requires static typing, JavaScript does not have static typing.)

Made some changes.

lrhn · 2022-11-09T16:48:43Z

src/_guides/language/coming-from/js-to-dart.md

-or assigned as `dynamic`, which disables static type
-checking for that identifier.
+Both JavaScript and Dart use data types.
+Types determine what kinds of values can be stored and what operations can be performed on a variable of that type.


Typed variables is something that JavaScript doesn't have, so it feels weird after a "Both languages" sentence.

lrhn · 2022-11-09T16:48:47Z

src/_guides/language/coming-from/js-to-dart.md

-inferrable by the analyzer, explicitly defined,
-or assigned as `dynamic`, which disables static type
-checking for that identifier.
+Both JavaScript and Dart use data types.


Not sure what "data types" mean here, or what "using" them means.

Both JavaScript and Dart values have consistent runtime types. A value doesn't change what type it has over time.

Updated with a better definition.

lrhn · 2022-11-09T16:52:25Z

src/_guides/language/coming-from/js-to-dart.md


-Dart supports nullable and non-nullable versions
-of the the following built-in types:
+Dart supports nullable and non-nullable versions of the following built-in types:


Dart supports nullable and non-nullable versions of all types (depending on how you think about the type Null itself). I wouldn't mention nullable types, or nullability, first here, just list the built-in types.

(Not sure I'd include Symbol in the list. There are lots of platform types, but some are more fundamental than others. I don't think Symbol should make that list, not as much as the other ones here.)

src/_guides/language/coming-from/js-to-dart.md

lrhn · 2022-11-10T13:10:00Z

src/_guides/language/coming-from/js-to-dart.md

+const bat =
+  Object.assign(
+    new Bat(),
+    new Flyer()


This works, but it relies on the fly/walk "methods" being declared as fields instead.
If you wrote it as

class Flyer { fly() => console.log('Flaps wings'); }

instead, which would be the canonical way to write a JS class, the assign would not copy the method (because it's on the prototype and is not enumerable).
Might be a caveat worth mentioning.

As this describes a specific caveat for JS, I'll leave it as is.

lrhn · 2022-11-10T13:16:51Z

src/_guides/language/coming-from/js-to-dart.md

+This means that you can access private members from code in the same library.
+By default, this works anywhere in the same file.
+Private class members can be accessed from code in the same file.
+Using the `part` directive to expand the scope of a library scope a single file.


Word missing? Maybe "beyond a single files"?

lrhn · 2022-11-10T13:17:55Z

src/_guides/language/coming-from/js-to-dart.md

+By default, this works anywhere in the same file.
+Private class members can be accessed from code in the same file.
+Using the `part` directive to expand the scope of a library scope a single file.
+When possible, [avoid doing so using `part`][]. The common practice would be


Just [avoid using `part`]. There are other reasons to use part files and you should avoid those too if you can.

lrhn · 2022-11-10T13:21:42Z

src/_guides/language/coming-from/js-to-dart.md

-when the field is first accessed,
-rather than on initialization. 
+In the preceding example, the compiler does not know to assign
+`captures` if `capture` is true. In this case `capture` is true,


Drop "In this case capture is true,", we don't know that. The logic is sound whether it's true or not.

atsansone

@lrhn : Made the requested changes.

src/_guides/language/coming-from/js-to-dart.md

atsansone · 2022-11-10T18:39:35Z

src/_guides/language/coming-from/js-to-dart.md

-inferrable by the analyzer, explicitly defined,
-or assigned as `dynamic`, which disables static type
-checking for that identifier.
+Both JavaScript and Dart use data types.


Updated with a better definition.

atsansone · 2022-11-10T18:51:53Z

src/_guides/language/coming-from/js-to-dart.md

-checking for that identifier.
+Both JavaScript and Dart use data types.
+Types determine what kinds of values can be stored and what operations can be performed on a variable of that type.
+Dart differs from JavaScript in that it identifies as a strongly typed language.


Made some changes.

atsansone · 2022-11-10T19:10:18Z

src/_guides/language/coming-from/js-to-dart.md

+Dart differs from JavaScript in that it identifies as a strongly typed language.
+In practice, this means that all Dart types must meet one of three conditions:
+
+1. The analyzer can infer the type from the operations run on the variable.


atsansone · 2022-11-10T19:10:39Z

src/_guides/language/coming-from/js-to-dart.md


-Dart supports nullable and non-nullable versions
-of the the following built-in types:
+Dart supports nullable and non-nullable versions of the following built-in types:


atsansone · 2022-11-10T19:53:53Z

src/_guides/language/coming-from/js-to-dart.md

-Dart doesn’t have the concept of abstract equality,
-so the `==` and `!=` JavaScript operators have no equivalent.
+Unlike JavaScript, Dart doesn’t have the concept of abstract equality.
+The `==` and `!=` JavaScript operators have no equivalent.


Deleted the line.

atsansone · 2022-11-10T20:02:27Z

src/_guides/language/coming-from/js-to-dart.md

-to a boolean, not one of the two values like these
-operators do in JavaScript.
+JavaScript allows empty strings, `0`, and other values to have
+inherent boolean values. JavaScript considers these values to be


atsansone · 2022-11-10T21:01:45Z

src/_guides/language/coming-from/js-to-dart.md

-  of an object but you can override it to resemble
-  a data class. For more information,
+  of an object. You can override the hash value to resemble
+  a data class. To learn more,


atsansone · 2022-11-10T21:52:31Z

src/_guides/language/coming-from/js-to-dart.md

-and always return a `Stream` instead of an `Iterable`.
+Async generator functions can create streams.
+These generators resemble a synchronous generator function.
+These functions use the `async*` keyword and return a `Stream`.


Made a slight change. I am trying to keep sentences concise and easier to follow.

atsansone · 2022-11-10T22:00:14Z

src/_guides/language/coming-from/js-to-dart.md

+const bat =
+  Object.assign(
+    new Bat(),
+    new Flyer()


As this describes a specific caveat for JS, I'll leave it as is.

lrhn · 2022-11-14T18:01:31Z

src/_guides/language/coming-from/js-to-dart.md

+add the trailing comma. Avoid adding the trailing comma for the formatting
+benefit alone.
+
+JavaScript supports trailing commas in list and map literals only.ß


Spurious "ß"

lrhn

Ah, had this late yesterday, but forgot to submit.

lrhn · 2022-11-14T18:07:24Z

src/_guides/language/coming-from/js-to-dart.md

+Dart assigns a static type to every expression and variable.
+In Dart, the static type predicts the runtime type of
+the value of an expression.
+This means Dart values have sound static typing.


I'd drop that line. "Values" is a runtime concept, and "static typing" happens at compile-time.
Or maybe rather:

This means that Dart programs have sound static typing.

lrhn · 2022-11-14T18:07:30Z

src/_guides/language/coming-from/js-to-dart.md

+Every variable has an associated type.
+The type determines the kind of value the variable can store and
+what operations can be performed on these values.
+Dart differs from JavaScript as its types never change; they remain _static_.


Rather, Dart has static types at all. JavaScript doesn't. It's not that JS variables have static types that change, they concept of "static type" is entirely absent in JS, and the only thing that matters is the dynamic type of values.

So, maybe:

Dart differs from JavaScript in that it assigns a static type to every variable and to every expression.
In Dart, the static type predicts the runtime type of the values of a variable, or of the value of an expression.

lrhn · 2022-11-14T18:15:55Z

src/_guides/language/coming-from/js-to-dart.md

-are implemented to be immutable (unchanging)
-and are canonicalized,
-which means they behave as if they are value types.
+All types in Dart are of the type Object. All values are also objects.


(Nit: The null object is the one value which is not an Object. More correctly, all non-Null types are subtypes of Object. Might be a mostly academic distinction at this point, though.)

lrhn · 2022-11-14T18:18:21Z

src/_guides/language/coming-from/js-to-dart.md


 Dart has three data types for holding numbers:

 `num`
 : The equivalent to the generic number type in JavaScript.

 `int`
-: Any numeric value without a decimal point. 
+: Any numeric value without a fractional part.


I think that "Any" can be confusing. There are non-fractional numeric values that are not int (1e+302 is a double with no fractional point, but is not an int. Except on the web, which muddies the message.)
Could we change "Any" to just "A".

lrhn · 2022-11-14T18:19:32Z

src/_guides/language/coming-from/js-to-dart.md


 `double`
-: Any numeric value, including those with a decimal point.
+: Any numeric value as a 64-bit (double-precision) floating point.


The "Any" here also confuses me. What is the domain it's ranging over? If they can all be doubles, is this just

Any 64-bit (double-precision) floating point number.

?
I think that might be more precise.

lrhn · 2022-11-15T09:58:21Z

src/_guides/language/coming-from/js-to-dart.md

-it doesn’t have an equivalent.
+{{site.alert.note}}
+When you create an Object, the class constructor must initialize the `final` instance variables.
+This ensures that these variables have a value before anyone can read it.


it -> them

(Refers to "these variables".)

lrhn · 2022-11-15T10:03:31Z

src/_guides/language/coming-from/js-to-dart.md


 ### Nullable vs non-nullable types

-For example, all the variables in the following code
-are non-nullable:
+All the variables in the following code example cannot be `null`.


The "All ... cannot" reads wrong to me.
Could it be "None of ... can"?

lrhn · 2022-11-15T10:06:54Z

src/_guides/language/coming-from/js-to-dart.md

+These functions return an iterable collection of items
+computed to avoid unncessary work.
+
+To write a generator function,


(Maybe add "in Dart" here, since the previous paragraph talked about "both languages", so the context isn't completely clear.)

lrhn · 2022-11-15T10:13:55Z

src/_guides/language/coming-from/js-to-dart.md

-Adding new operators is not supported in either language,
-but Dart allows you to overload existing operators
+Neither language supports adding new operators.
+Dart supports overloading some existing operators
 with the `operator` keyword. For example:

 {:.include-lang}


I'd just change the code example to:

class Vector { final double x; final double y; final double z; Vector(this.x, this.y, this.z); Vector operator +(Vector other) => Vector( x + other.x, y + other.y, z + other.z, ); // maybe even add: Vector operator *(double scalar) => Vector( x * scalar, y * scalar, z * scalar, ); }

Adding vectors is a well-defined mathematical operation, so this example should be uncontroversial. "Adding" boxes doesn't really make sense if you try to visualize boxes.

lrhn · 2022-11-15T10:15:18Z

src/_guides/language/coming-from/js-to-dart.md

+| Strict equal              | `===`               | `indentical(,)`  |
+| Abstract equal            | `==`                | `==`             |
+| Strict not equal          | `!==`               | `!indentical(,)` |
+| Abstract not equal        | `!=`                | `!=`             |


It might be better to not equate any of them.
Or just recommend using Dart == for everything.

parlough · 2022-11-18T02:29:47Z

I'll take a final look at this tomorrow. Sorry about the delay, I wanted to wait for Lasse to finish his review.

parlough

Some comments, suggestions, and issues. Feel free to push back on any. I noticed @lrhn has a few open comments that still seem relevant as well. I commented or reacted on them.

If possible, avoid squashing commits and rebasing as it made it hard to see what changed between/after reviews and sometimes messes with GitHub's review comment handling.

parlough · 2022-11-18T16:33:53Z

src/_guides/language/coming-from/js-to-dart.md

-  **Pro tip:** Dart provides [`dart fix`][],
-  which finds and fixes errors found by the analyzer.
-{{site.alert.end}}
+Dart provides [`dart fix`][] to find and fix errors that the analyzer finds.


I feel someone reading this will not be familiar with what "the analyzer" is. Could we add a link or small explanation here, especially since the rest of the article refers to the "the analyzer" a few times.

Understood. I'm removing it here because, well, if dart fix finds and fixes, why does the analyzer matter here?

parlough · 2022-11-18T16:36:26Z

src/_guides/language/coming-from/js-to-dart.md

+// Declare a variable without a type
+// and Dart infers the 'dynamic' type
+var name;
+// Declare a variable with a specific type
+// when you don't provide an initial value
+String name;
+// Initialize the variable
+// and the type remains `dynamic`
+name = 'bob';


I think using the same variable name here is confusing. The comment for name = 'bob' says the type is dynamic, but the declaration before creates a name variable with a String type.

parlough · 2022-11-18T16:38:32Z

src/_guides/language/coming-from/js-to-dart.md

+because you initialized the variable. By convention, use `var` when the
+analyzer can infer the type.


Should we mention final here as well?

Suggested change

because you initialized the variable. By convention, use `var` when the

analyzer can infer the type.

because you initialized the variable. By convention,

use `var` or `final` when the analyzer can infer the type.

parlough · 2022-11-18T16:41:04Z

src/_guides/language/coming-from/js-to-dart.md

+var name = 'bob';
+// Dart understands the variable's type to be 'String'.
+// Dart can infer that type from the variable's
+// initial value.
+```


This seems a bit duplicated from the last entry in the previous codeblock(L375-378) and again below (L406-408).

I rewrote all of this. Woof.

parlough · 2022-11-18T16:44:41Z

src/_guides/language/coming-from/js-to-dart.md

+Dart uses `final`. When Dart adds `final` or JavaScript adds `const`,
+you must initialize the variable before _reading_ it.
+When Dart adds `const`, you must initialize the variable
+before _compiling_ it.


Due to the squashed history, I'm not sure what has changed, but I think some of the suggestions here are still valid. "you must initialize the variable before compiling it" doesn't make much sense to me as a reader.

parlough · 2022-11-18T17:04:16Z

src/_guides/language/coming-from/js-to-dart.md

@@ -1695,15 +1840,28 @@ to their JavaScript counterparts.
 ### Futures

 `Future` is Dart's version of a `Promise`:
-an asynchronous operation that resolves at a later point. 
+an asynchronous operation that resolves at a later point.


This clarification makes sense and I think should still be addressed.

parlough · 2022-11-18T17:06:02Z

src/_guides/language/coming-from/js-to-dart.md

+  .catchError((err) {
+    print(
+      'Future encountered an error
+       before resolving.'


@atsansone These should still be fixed.

parlough · 2022-11-18T17:07:11Z

src/_guides/language/coming-from/js-to-dart.md

-and multiple methods for controlling the stream,
-such as emitting new items using the `add` method,
-or completing the stream using the `close` method.
+The utility class [StreamController][] can create and control streams.


Keep this in code syntax to be consistent with elsewhere:

Suggested change

The utility class [StreamController][] can create and control streams.

The utility class [`StreamController`][] can create and control streams.

parlough · 2022-11-18T17:12:42Z

src/_guides/language/coming-from/js-to-dart.md

 Like JavaScript, Dart has no access modifier keywords:
-all class members are public by default. 
+all class members are public by default.

-While private class members are not yet officially
-part of JavaScript because they are not part of any
-published EcmaScript standard,
-a proposal for this has been completed and is ready
-to be included in the next publication of the standard.
+JavaScript will include private class members in the next
+practical revision of the EcmaScript standard.


This whole talk about the EcmaScript spec for private members not being complete is confusing and I'm not sure it should be included. Either way, it looks like PrivateIdentifiers were part of EcmaScript 2022 which has been released.

Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Private_class_fields

I checked the reference specifically; privates are in stage 4, which means they will be in the next practical revision. That's why I phrased it as I did.

parlough · 2022-11-18T17:18:08Z

src/_guides/language/coming-from/js-to-dart.md

+To indicate that Dart initializes class fields at a later point,
+assign the `late` keyword to those class fields.
+Those class fields remain non-nullable.
+Do this when a variable cannot be observed before being initialized.


This new sentence is confusing as every variable technically "cannot be (at least successfully) observed before being initialized". I think the original text was trying to say something like "Do this when a variable does not need to be(or is not) observed/accessed right away and can be initialized later".

Fair. Fixed.

atsansone

@parlough : Back to you!

atsansone · 2022-11-18T19:42:25Z

src/_guides/language/coming-from/js-to-dart.md

-  **Pro tip:** Dart provides [`dart fix`][],
-  which finds and fixes errors found by the analyzer.
-{{site.alert.end}}
+Dart provides [`dart fix`][] to find and fix errors that the analyzer finds.


Understood. I'm removing it here because, well, if dart fix finds and fixes, why does the analyzer matter here?

atsansone · 2022-11-18T20:34:01Z

src/_guides/language/coming-from/js-to-dart.md

+var name = 'bob';
+// Dart understands the variable's type to be 'String'.
+// Dart can infer that type from the variable's
+// initial value.
+```


I rewrote all of this. Woof.

atsansone · 2022-11-18T20:43:48Z

src/_guides/language/coming-from/js-to-dart.md

+Dart uses `final`. When Dart adds `final` or JavaScript adds `const`,
+you must initialize the variable before _reading_ it.
+When Dart adds `const`, you must initialize the variable
+before _compiling_ it.


Rewrote. Should read better now.

atsansone · 2022-11-18T20:44:45Z

src/_guides/language/coming-from/js-to-dart.md

-that null reference exceptions are caught when writing code,
-so they are unlikely to occur at runtime. 
+Unlike JavaScript, Dart supports null safety.
+As of Dart 2.12, all types default to non-nullable.


atsansone · 2022-11-18T20:51:02Z

src/_guides/language/coming-from/js-to-dart.md

+By default, Dart _requires_ functions to provide all parameters
+as positional parameters.


atsansone · 2022-11-18T20:51:43Z

src/_guides/language/coming-from/js-to-dart.md

+// Assign an anonymous function
+// to a variable.
+var blockFunc =
+  optionalCallback ?? (int a, int b) {


Lasse raised it, so I'll count it.

atsansone · 2022-11-18T20:59:52Z

src/_guides/language/coming-from/js-to-dart.md

+| Meaning                   | JavaScript operator | Dart operator    |
+|---------------------------|---------------------|------------------|
+| Strict equal              | `===`               | `==`             |
+| Abstract equal            | `==`                | `==`             |


atsansone · 2022-11-18T21:07:30Z

src/_guides/language/coming-from/js-to-dart.md

+for evaluating expressions.
+Some developers refer to this operator as a ternary operator
+as it takes three operands.
+Dart has another operator (`[]=`) that takes three operands.


I think I have this updated correctly.

atsansone · 2022-11-18T21:37:22Z

src/_guides/language/coming-from/js-to-dart.md

 Like JavaScript, Dart has no access modifier keywords:
-all class members are public by default. 
+all class members are public by default.

-While private class members are not yet officially
-part of JavaScript because they are not part of any
-published EcmaScript standard,
-a proposal for this has been completed and is ready
-to be included in the next publication of the standard.
+JavaScript will include private class members in the next
+practical revision of the EcmaScript standard.


I checked the reference specifically; privates are in stage 4, which means they will be in the next practical revision. That's why I phrased it as I did.

atsansone · 2022-11-18T21:39:07Z

src/_guides/language/coming-from/js-to-dart.md

+To indicate that Dart initializes class fields at a later point,
+assign the `late` keyword to those class fields.
+Those class fields remain non-nullable.
+Do this when a variable cannot be observed before being initialized.


Fair. Fixed.

parlough · 2022-11-18T23:56:13Z

src/_guides/language/coming-from/js-to-dart.md

+Dart has one official layout conventions and includes a linter to make
+compliance effortless. Dart calls this linter the analyzer.


The analyzer is a lot more than just the linter, providing warnings and errors for misuse of language features,
code completion, actions like "Find usages", "Go to definition", "Fix X", etc.

Suggested change

Dart has one official layout conventions and includes a linter to make

compliance effortless. Dart calls this linter the analyzer.

Dart has official layout and styles conventions and includes

a linter to make compliance effortless.

Support for this and other analysis functionality is provided by the analyzer.

parlough

Thanks for cleaning up this article. Looks good to me.

I left one suggestion around the analyzer introduction.

parlough self-requested a review November 8, 2022 20:06

atsansone requested a review from lrhn November 8, 2022 20:08

atsansone assigned lrhn Nov 8, 2022

atsansone added the review.tech Awaiting Technical Review label Nov 8, 2022

lrhn reviewed Nov 10, 2022

View reviewed changes

atsansone force-pushed the js-to-flutter-2 branch from 2c36aa0 to b1d5cff Compare November 10, 2022 22:05

atsansone commented Nov 10, 2022

View reviewed changes

parlough requested a review from lrhn November 11, 2022 17:08

lrhn reviewed Nov 14, 2022

View reviewed changes

lrhn approved these changes Nov 16, 2022

View reviewed changes

atsansone force-pushed the js-to-flutter-2 branch 3 times, most recently from cfc4c0d to a02c028 Compare November 17, 2022 18:30

atsansone assigned atsansone and unassigned lrhn Nov 18, 2022

atsansone added st.RFM Ready to merge or land and removed review.tech Awaiting Technical Review labels Nov 18, 2022

atsansone removed the request for review from parlough November 18, 2022 16:28

parlough requested changes Nov 18, 2022

View reviewed changes

parlough removed the st.RFM Ready to merge or land label Nov 18, 2022

atsansone force-pushed the js-to-flutter-2 branch from ad0694a to 25f2f52 Compare November 18, 2022 21:40

atsansone commented Nov 18, 2022

View reviewed changes

parlough reviewed Nov 18, 2022

View reviewed changes

parlough approved these changes Nov 18, 2022

View reviewed changes

Updated per @lrhn review

8454155

atsansone force-pushed the js-to-flutter-2 branch from ee0ac7e to f45b094 Compare November 21, 2022 16:06

Updated per @parlough review

eeff95a

atsansone force-pushed the js-to-flutter-2 branch from f45b094 to eeff95a Compare November 21, 2022 17:30

atsansone merged commit 9d67c7c into dart-lang:main Nov 21, 2022

		because you initialized the variable. By convention, use `var` when the
		analyzer can infer the type.

	The utility class [StreamController][] can create and control streams.
	The utility class [`StreamController`][] can create and control streams.

		By default, Dart _requires_ functions to provide all parameters
		as positional parameters.

		Dart has one official layout conventions and includes a linter to make
		compliance effortless. Dart calls this linter the analyzer.

-Dart has one official layout conventions and includes a linter to make
-compliance effortless. Dart calls this linter the analyzer.
+Dart has official layout and styles conventions and includes
+a linter to make compliance effortless.
+Support for this and other analysis functionality is provided by the analyzer.

Update JS to Dart #4354

Update JS to Dart #4354

Conversation

atsansone commented Nov 8, 2022 • edited

lrhn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

atsansone left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lrhn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

parlough commented Nov 18, 2022 • edited

parlough left a comment • edited

Choose a reason for hiding this comment

parlough Nov 18, 2022 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

parlough Nov 18, 2022 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

atsansone left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

parlough left a comment • edited

Choose a reason for hiding this comment

atsansone commented Nov 8, 2022 •

edited

parlough commented Nov 18, 2022 •

edited

parlough left a comment •

edited

parlough Nov 18, 2022 •

edited

parlough Nov 18, 2022 •

edited

parlough left a comment •

edited