Speaker: Vitalii Braslavskyi, Software Engineer at Grammarly Summary: Today, the dominant approach to software engineering is an imperative one — the best practices have been proven over time. But the world is always evolving, and in order to evolve with it and remain as productive as possible, we need to continue searching for better tools to solve problems of increasing complexity. In this talk, we'll discuss the tools and techniques of the .Net ecosystem that can help us to concentrate on the problem itself — not just on the intermediate steps (which have likely already been solved). We'll compare imperative and declarative approaches and assess solutions to problems. We'll also offer examples of how engineers in Grammarly's Office Add-in team use these tools to improve the efficiency of our engineering and strengthen our solutions to the problems at hand.

2. What is Grammarly?
Grammarly’s AI-powered writing
assistant helps you make your
communication clear and effective,
wherever you type.

3. 200+
team members across offices
in San Francisco, New York,
Kyiv, and Vancouver
2,000+
Institutional and
enterprise clients
20M+
daily active users around
the world
Grammarly by the numbers

4. Let’s imagine a simple function
f(x) = sin(x)

10. KolibriOS / MenuetOS

11. declarativus, from past-participle stem of
Latin declarare, “to make clear, reveal,
disclose, announce”
Declare

12. In computer science, declarative programming is a
programming paradigm—a style of building the structure
and elements of computer programs—that expresses the
logic of a computation without describing its control flow.
Declarative programming

13. DSL
Domain-
Specific
Language
● SQL
● XML / HTML
● … many others

14. SQL
SQL (/ˌɛsˌkjuːˈɛl/ (listen) S-Q-L, /ˈsiːkwəl/
"sequel"; Structured Query Language) is
a domain-specific language used in
programming and designed for managing
data held in a relational database
management system (RDBMS)...

15. CODASYL Data Model

16. CODASYL Data Model

17. CODASYL Data Model

18. CODASYL Data Model

19. CAN RUN FASTER AFTER
UPDATE ✅ ✅
INTUITIVE CONTROLS
✅ ✅
INNOVATIVE SOLUTION AT
THE TIME ✅ ✅
EVERYBODY LIKES IT
❌ ✅

20. MVU / Elm
architecture

21. > State -> View -> Message -
Elm architecture / MVU

22. Model (State) View
f ( )=
John
Dough
OK
name: John
surname: Dough

23. Messages
Message
⏰
☁️HTTP

24. f ( )=
John
Doe
OK
name: John
surname: Doe
f()=message: SurnameFieldEdited “Doe”

26. The Ugly

27. The Bad

28. The Good
3

29. The Better?
❓

30. ❓
❓

31. 🧨
System.NullReferenceException

32. 🧨 System.NullReferenceException
Transforms to the real nullable
Underlying type is the same

33. 🧨 System.NullReferenceException
// won’t compile

34. 🧨 Empty string
// won’t compile

35. Nullable + references + API = 🎁

36. 🎁 Option monad
Some : value
None
❓
nice API

38. Try* Pattern

39. Try* Pattern

40. ❓
❓

41. Try* Pattern

42. LanguageExt.Option<T>

43. LanguageExt.Option<T>

44. LanguageExt.Option<T>

45. 🎁 Either (Result)

46. 🎁 Either

47. LanguageExt

48. ⒡unctional C#

49. Expressions
Expression: produces value or side
effects
Statement: produces only side effects

53. match

55. F#
111
2
43
E A D G B E
1 5 1 3 5 1
1
2
3
4

56. First-Class
Functions

57. First-Class
Functions

58. First-Class
Functions

59. First-Class
Functions

60. First-Class
Functions

61. Remember this guy?
This is him now

62. Which property of the item

63. Partial application
Functions composition Pipe-forward

64. LanguageExt

65. Algebraic
Data
Types

66. Algebraic
Data
Types

67. Algebraic
Data
Types

68. Algebraic
Data
Types
// won’t compile
// compiles ✅
// ... function implementation

69. Domain
Invariants
💼 Case #1

72. Parse,
don’t
validate

74. Server
Messages
👩🔬🧨👨

75. Valid ✅

76. Not Valid ❌

77. F#
JSON Parser

78. F#
JSON Parser

79. eDSL

80. ● Declarative way of specifying JSON structure
● Invariants enforced at the domain boundary
d
What do we get?

81. Version
Distribution
💼 Case #2

82. ⚙️
👩
👨
🎤
👩
🏫
👩
✈️
🧛
♂️
👨
🎨
1.2.5
1.1.6
1.3.3
x.x.x⚙️

83. ● Precise control over the versions distribution
● Clear way to specify which version goes to
which user
Update Rules
1.1.6
1.3.31.2.5

84. Existing QL
for JSON
● Solutions for NoSQL DBs
● Bloated imperative syntax
● Json.NET LINQ requires code
deployments
● GraphQL is too massive

86. Building declarative tools using
declarative tools

87. ● JSON-like, easy to remember, intuitive syntax
● Safe way to adjust behavior without code
deployment
● Straightforward way to tune rules behaviour
without changing configuration
What do we get?

88. Log Crawler 📒
● Select the whole line or go by each word
● Match by regex or substring
● Print to console or write to file

89. Log
Crawler
Domain
Types

90. Log
Crawler
Domain
Types
Discriminated Unions
Records

91. Log
Crawler
FParsec

92. Log
Crawler
Parsing

93. Log
Crawler
Parsing
Running parser on string

94. Log
Crawler
InterpretingMimics our query structure

95. Interpreting

96. Log
Crawler
Interpreting

97. Log
Crawler
Running
Repository: https://github.com/6ruce/log-crawler/
~100 Lines Of Code: Types + Parsing + Interpreting

98. Summary: Make the computer work for you
Compiler
Static
analyzer
Computer
DSL
eDSL
Linter
Type checker
IDE
Syntax
sugar
Runtime
Abstractions

99. Thank you!
Stay healthy!

100. Links:
Parse, don’t validate:
https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-
validate/
Railway-oriented programming:
https://fsharpforfunandprofit.com/rop/
Expressions vs. Statements:
https://fsharpforfunandprofit.com/posts/expressions-vs-
statements/
LanguageExt: Thinking functionally:
https://github.com/louthy/language-ext/wiki/Thinking-
Functionally
FParsec: Parsing library:
https://www.quanttec.com/fparsec/