rjz · February 3, 2022 11:09 · Nov 14, 2018 · Nov 14, 2018 · Nov 14, 2018 · Nov 14, 2018
diff --git a/whats-so-great-about-reasom.md → whats-so-great-about-reason.md b/whats-so-great-about-reasom.md → whats-so-great-about-reason.md
diff --git a/whats-so-great-about-reasom.md b/whats-so-great-about-reasom.md
@@ -1,6 +1,6 @@
 # What's so great about Reason?
 
-PDXReactJS meetup / 13. Nov 2018 [https://twitter.com/benjamminj](@benjamminj)
+PDXReactJS meetup / 13. Nov 2018 [@benjamminj](https://twitter.com/benjamminj)
 
 ## Maintainability?
 

diff --git a/whats-so-great-about-reasom.md b/whats-so-great-about-reasom.md
@@ -9,7 +9,7 @@ We want to make complex problems simple, and solve them in ways we can extend on
 JavaScript v. ReasonML:
 
 | Task | JavaScript | ReasonML |
-| ---- + ---------- + -------- |
+| ---- | ---------- | -------- |
 | Lint | via Tooling (e.g. ESLint) | Compiler warnings (it's impossible to ship "unlinted" code) |
 | Format | via Tooling (e.g. Prettier) | `reformat` is built in |
 | Immutability | via Tooling (e.g. ImmutableJS) | by default. With some "mutable" niceties for imperative code |

diff --git a/whats-so-great-about-reasom.md b/whats-so-great-about-reasom.md
@@ -8,14 +8,14 @@ We want to make complex problems simple, and solve them in ways we can extend on
 
 JavaScript v. ReasonML:
 
-Task | JavaScript | ReasonML
----- + ---------- + --------
-Lint | via Tooling (e.g. ESLint) | Compiler warnings (it's impossible to ship "unlinted" code)
-Format | via Tooling (e.g. Prettier) | `reformat` is built in
-Immutability | via Tooling (e.g. ImmutableJS) | by default. With some "mutable" niceties for imperative code
-Utilities | via Tooling (Lodash / Ramda) | OCaml/BuckleScript standard library
-Types | via Tooling (TypeScript / Flow) | yep.
-Tests | via Tooling (Jest, Mocha, Enzyme, React Testing, etc) | left to userland
+| Task | JavaScript | ReasonML |
+| ---- + ---------- + -------- |
+| Lint | via Tooling (e.g. ESLint) | Compiler warnings (it's impossible to ship "unlinted" code) |
+| Format | via Tooling (e.g. Prettier) | `reformat` is built in |
+| Immutability | via Tooling (e.g. ImmutableJS) | by default. With some "mutable" niceties for imperative code |
+| Utilities | via Tooling (Lodash / Ramda) | OCaml/BuckleScript standard library |
+| Types | via Tooling (TypeScript / Flow) | yep. |
+| Tests | via Tooling (Jest, Mocha, Enzyme, React Testing, etc) | left to userland |
 
 At least 6-10 tools for a project. Lots of them are cool. But that also means
 juggling lots of documentation, lots of different configurations.

diff --git a/whats-so-great-about-reasom.md b/whats-so-great-about-reasom.md
@@ -0,0 +1,97 @@
+# What's so great about Reason?
+
+PDXReactJS meetup / 13. Nov 2018 [https://twitter.com/benjamminj](@benjamminj)
+
+## Maintainability?
+
+We want to make complex problems simple, and solve them in ways we can extend on.
+
+JavaScript v. ReasonML:
+
+Task | JavaScript | ReasonML
+---- + ---------- + --------
+Lint | via Tooling (e.g. ESLint) | Compiler warnings (it's impossible to ship "unlinted" code)
+Format | via Tooling (e.g. Prettier) | `reformat` is built in
+Immutability | via Tooling (e.g. ImmutableJS) | by default. With some "mutable" niceties for imperative code
+Utilities | via Tooling (Lodash / Ramda) | OCaml/BuckleScript standard library
+Types | via Tooling (TypeScript / Flow) | yep.
+Tests | via Tooling (Jest, Mocha, Enzyme, React Testing, etc) | left to userland
+
+At least 6-10 tools for a project. Lots of them are cool. But that also means
+juggling lots of documentation, lots of different configurations.
+Decision fatigue is a real thing.
+
+## What does Reason give us?
+
+Focus on why: why it's cool, worth using.
+What's reason?
+- A syntax and toolchain for OCaml
+- OCaml is an old, statically typed, functional language. It's been around for
+  a while.
+- Reason hasn't. Created by Jordan Walke (React creator) a few years back
+- OCaml behavior is similar to JS in how it works. Not how it looks, but how it
+  works
+
+Remember that list of JS Tools? (Revised above)
+
+### Aside: types aren't tests
+
+**Q: Do I really need types when I can write unit tests for everything?** No, but you
+don't want to write a test for every datatype flowing through your function.
+
+**Q: And tests, if I have types?** No, as long as you don't have any business
+logic. A type-checker won't tell you if calculations are right, or if you added
+to the front of an array when you should have added to the end of the array.
+
+### More, ahem, Reason/s
+
+**Pragmatism over Dogma**. Reason (OCaml) likes functional programming, but you can
+still write `for` loops, mutable references, etc. A _very_ functional language
+(e.g. Haskell) can obstruct what you're trying to do (ultimately, deliver value
+to your users). Reason isn't that.
+
+**Reason can compile for native** (via various? experimental? OCaml backends), web
+(via BuckleScript--optimizing compiler targeting JS).
+
+**Syntax isn't too far off JavaScript** (one of Reason's goals was opening the
+OCaml ecosystem to JS devs). Syntax is terse and light on types--the compiler
+can infer a lot of stuff.
+
+**Workflow, same**: still via `npm`.
+
+### Interop with the JS world?
+
+Write `external` declaration.
+
+## Some examples
+
+- List (immutable) - Linked list under the hood
+- Array (mutable) - Slightly more awkward syntax, sometimes convenient
+- Record - Sort of like a JavaScript object (with a type definition separate from
+    the declaration)
+- Variant - Union type, but branches can take arguments
+- Pattern matching - Variants lend themselves well to matching, but you can
+    match over all sorts of things. And if you forget to match elements in an
+    array, you'll get a warning!
+
+## `ReasonReact`
+
+Stateless components are easy: declare a `make` factory function. Otherwise it
+looks a lot like React.
+
+- JSX is built-in as a language macro. Some small changes (don't need
+  curly-braces to escape params, or assignment of attributes that match
+  variable names)
+
+State_ful_ components are created with the `reducerComponent` generator and
+another `make`.
+
+- Reason doesn't have `this`, but can reference an explicit `self`. Use
+  `self.send()` to pass actions back to the component reducer
+
+- Reason is production-grade, but it's still early. OCaml is well-established;
+  community around ReactReason is still figuring things out (you might spend
+  some time digging through the docs to find answers for yourself).
+
+- Definitely ready for a side project! Or converting some utility functions
+  over.
No results found