diff --git a/content/blog/2017-09-17-handling-exceptions-arrow.md b/content/blog/2017-09-17-handling-exceptions-arrow.md
new file mode 100644
index 00000000..6d2141e0
--- /dev/null
+++ b/content/blog/2017-09-17-handling-exceptions-arrow.md
@@ -0,0 +1,10 @@
+---
+title: Handling exceptions in Arrow
+image: /img/blog-image-header.png
+category: articles
+tags: [core, articles]
+link: https://www.spantree.net/blog/2017/09/15/kotlin-exception-handling-with-kategory.html
+---
+[@uris77](https://github.com/uris77) explains how to use [Try](https://arrow-kt.io/docs/apidocs/arrow-core-data/arrow.core/-try/) in real world examples.
+
+[Handling Kotlin Exceptions with Arrow – A Functional Approach](https://www.spantree.net/blog/2017/09/15/kotlin-exception-handling-with-kategory.html)
diff --git a/content/blog/2017-10-20-functional-approach.md b/content/blog/2017-10-20-functional-approach.md
new file mode 100644
index 00000000..66455899
--- /dev/null
+++ b/content/blog/2017-10-20-functional-approach.md
@@ -0,0 +1,9 @@
+---
+title: Functional approach to Android architecture using Kotlin
+image: https://img.youtube.com/vi/qGef3sFAIxU/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=qGef3sFAIxU
+event: Mobilization 7, Łódź
+---
+Move side effects to the edges of the system, implement a functional oriented architecture for Android apps based on purity.
diff --git a/content/blog/2017-11-02-fp-kotlin.md b/content/blog/2017-11-02-fp-kotlin.md
new file mode 100644
index 00000000..fd7c2808
--- /dev/null
+++ b/content/blog/2017-11-02-fp-kotlin.md
@@ -0,0 +1,14 @@
+---
+title: Functional Programming in Kotlin
+image: https://cdn-images-1.medium.com/max/600/1*NpQ5mqoY4SH5iwsWG35RqQ.jpeg
+category: tutorials
+tags: [core, fx, mtl, tutorials]
+link: https://medium.com/@JorgeCastilloPr/kotlin-functional-programming-does-it-make-sense-36ad07e6bacf
+---
+An ongoing blog series introducing Functional Programming architectures from scratch
+
+[Kotlin Functional Programming: Does it make sense?](https://medium.com/@JorgeCastilloPr/kotlin-functional-programming-does-it-make-sense-36ad07e6bacf)
+
+[Kotlin Functional Programming I: Monad Stack](https://medium.com/@JorgeCastilloPr/kotlin-functional-programming-i-monad-stack-518d1bd8fbee)
+
+[Kotlin Functional Programming II: Monad Transformers](https://medium.com/@JorgeCastilloPr/kotlin-functional-programming-ii-monad-transformers-b1f020f14dd8)
diff --git a/content/blog/2017-11-09-pragmatic-functionalist.md b/content/blog/2017-11-09-pragmatic-functionalist.md
new file mode 100644
index 00000000..8375a542
--- /dev/null
+++ b/content/blog/2017-11-09-pragmatic-functionalist.md
@@ -0,0 +1,9 @@
+---
+title: Kotlin for the Pragmatic Functionalist
+image: https://img.youtube.com/vi/s9oMED6ZikQ/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=s9oMED6ZikQ
+event: KotlinConf, San Francisco
+---
+An introduction to Arrow and the enhancements it brings to Kotlin's standard library.
diff --git a/content/blog/2017-11-17-architectures.md b/content/blog/2017-11-17-architectures.md
new file mode 100644
index 00000000..1bfb688c
--- /dev/null
+++ b/content/blog/2017-11-17-architectures.md
@@ -0,0 +1,9 @@
+---
+title: Architectures Using Functional Programming Concepts
+image: https://img.youtube.com/vi/qI1ctQ0293o/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=qI1ctQ0293o
+event: KotlinConf, San Francisco
+---
+Introductory talk to Functional architectures to be built on top of Arrow.
diff --git a/content/blog/2017-11-22-happy-path.md b/content/blog/2017-11-22-happy-path.md
new file mode 100644
index 00000000..38aeefaf
--- /dev/null
+++ b/content/blog/2017-11-22-happy-path.md
@@ -0,0 +1,10 @@
+---
+title: "Happy path: Kotlin + Actors + Arrow"
+image: https://cdn-images-1.medium.com/max/600/1*kF_bpeNe0THMssFEa2enYA.jpeg
+category: articles
+tag: [core, articles]
+link: https://medium.com/@javipacheco/happy-path-kotlin-actors-arrow-proof-of-concept-322e9099d2ea
+---
+[@javipacheco](https://github.com/javipacheco) creates a Proof of Concept architecture for Android using the Actor pattern and modelling the domain with [`Either`]({{ 'https://arrow-kt.io/docs/apidocs/arrow-core-data/arrow.core/-either/' | relative_url }}).
+
+[Happy Path: Kotlin + Actors + Arrow](https://medium.com/@javipacheco/happy-path-kotlin-actors-arrow-proof-of-concept-322e9099d2ea)
diff --git a/content/blog/2017-11-24-building-dsl-kotlin.md b/content/blog/2017-11-24-building-dsl-kotlin.md
new file mode 100644
index 00000000..da564dd9
--- /dev/null
+++ b/content/blog/2017-11-24-building-dsl-kotlin.md
@@ -0,0 +1,9 @@
+---
+title: Building a DSL… in Kotlin
+image: https://img.youtube.com/vi/qGef3sFAIxU/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=qGef3sFAIxU
+event: droidconSF, San Francisco
+---
+Make DSLs stack safe, composable and reusable under different runtime requirements thanks to Arrow.
diff --git a/content/blog/2017-11-29-fp-kotlin-arrow.md b/content/blog/2017-11-29-fp-kotlin-arrow.md
new file mode 100644
index 00000000..1820e870
--- /dev/null
+++ b/content/blog/2017-11-29-fp-kotlin-arrow.md
@@ -0,0 +1,9 @@
+---
+title: Functional Programming in Kotlin with Arrow
+image: https://img.youtube.com/vi/IL5XzaCMKpQ/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=IL5XzaCMKpQ
+event: Lambda World, Cádiz
+---
+A rundown of all the features included in the library, focusing on implementation details.
diff --git a/content/blog/2018-01-17-optics-type-classes-arrow.md b/content/blog/2018-01-17-optics-type-classes-arrow.md
new file mode 100644
index 00000000..f1f297c0
--- /dev/null
+++ b/content/blog/2018-01-17-optics-type-classes-arrow.md
@@ -0,0 +1,12 @@
+---
+title: Optics and Type Classes in Arrow
+image: https://speakerd.s3.amazonaws.com/presentations/4b938d99415a416c8f908ac5302a66cb/slide_0.jpg
+category: slidedecks
+tags: [core, optics, slidedecks]
+event: Kotlin Brooklyn Meetup
+link: https://speakerdeck.com/heyitsmohit/functional-programming-with-arrow
+---
+[@msya](https://github.com/msya) explains how to use various optics and type classes in Arrow. He discusses optics such as
+[`Lens`]({{ '/docs/optics/lens' | relative_url }}) and [`Iso`]({{ '/docs/optics/iso' | relative_url }}). He also goes over the purpose for type classes and how [KEEP-87](https://github.com/Kotlin/KEEP/pull/87) will make it easier to implement them.
+
+[Functional Programming with Arrow](https://speakerdeck.com/heyitsmohit/functional-programming-with-arrow)
diff --git a/content/blog/2018-03-21-morphisms.md b/content/blog/2018-03-21-morphisms.md
new file mode 100644
index 00000000..73fb8317
--- /dev/null
+++ b/content/blog/2018-03-21-morphisms.md
@@ -0,0 +1,9 @@
+---
+title: It's all about morphisms
+image: https://img.youtube.com/vi/Eq8dv4H3RTE/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=Eq8dv4H3RTE
+event: Voxxed Days, Vienna
+---
+[@uberto](https://github.com/uberto) gives a gentle introduction to Category Theory for programmers used to OOP but interested in Functional Programming. No Haskell knowledge required. We will explain main concepts behind functional programming with many diagrams and simple metaphors and examples. Some code will clarify how to translate these ideas in programs.
diff --git a/content/blog/2018-03-26-kotlin-arrow.md b/content/blog/2018-03-26-kotlin-arrow.md
new file mode 100644
index 00000000..67b1e922
--- /dev/null
+++ b/content/blog/2018-03-26-kotlin-arrow.md
@@ -0,0 +1,9 @@
+---
+title: Introduction to Kotlin Arrow by Jacob Bass
+image: https://img.youtube.com/vi/tM2wEI-e80E/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=tM2wEI-e80E
+event: Kotlin Meetup, Sydney
+---
+[@bassjacob](https://github.com/bassjacob) goes through how Funktionale and Kategory merged into Arrow, consolidating two of the most popular FP libraries in the Kotlin space into one powerhouse. The talk is an introduction to some FP concepts, how the libraries work, what features they bring to the table and where you might use them in your code.
diff --git a/content/blog/2018-04-14-android-functional-validation.md b/content/blog/2018-04-14-android-functional-validation.md
new file mode 100644
index 00000000..d8e72aef
--- /dev/null
+++ b/content/blog/2018-04-14-android-functional-validation.md
@@ -0,0 +1,15 @@
+---
+title: Android Functional Validation
+image: https://i.vimeocdn.com/video/713283357_1280x720.jpg
+category: tutorials
+tags: [core, tutorials]
+link: https://player.vimeo.com/video/279931528
+---
+[@dcampogiani](https://github.com/dcampogiani) explores some data types in Arrow and uses them to validate a form on Android.
+
+[Video (in italian)](https://player.vimeo.com/video/279931528)
+
+* [Introduction](http://danielecampogiani.com/blog/2018/02/android-functional-validation-1-intro/)
+* [Option](http://danielecampogiani.com/blog/2018/02/android-functional-validation-2-option/)
+* [Either](http://danielecampogiani.com/blog/2018/02/android-functional-validation-3-either/)
+* [Validated](http://danielecampogiani.com/blog/2018/02/android-functional-validation-4-validated/)
diff --git a/content/blog/2018-04-23-how-do-i.md b/content/blog/2018-04-23-how-do-i.md
new file mode 100644
index 00000000..bd8a9c36
--- /dev/null
+++ b/content/blog/2018-04-23-how-do-i.md
@@ -0,0 +1,10 @@
+---
+title: "1/n - How do I… in FP: Validation"
+image: https://images.unsplash.com/photo-1518169811655-27c3a4327016?ixlib=rb-0.3.5&q=80&fm=jpg&crop=entropy&cs=tinysrgb&w=600&fit=max&ixid=eyJhcHBfaWQiOjExNzczfQ&s=383b467064497d356a0b05b3a3d180be
+category: tutorials
+tags: [core, tutorials]
+link: https://www.enhan.eu/how-to-in-fp/
+---
+[Emmanuel Nhan](https://www.enhan.eu/author/enhan/) showcases different approaches to validation including examples for `ValidatedNel` from Arrow in this great and in depth post using Kafka Streams Config parameters as example.
+
+[1/n - How do I… in FP: Validation](https://www.enhan.eu/how-to-in-fp/)
diff --git a/content/blog/2018-06-22-hk-types.md b/content/blog/2018-06-22-hk-types.md
new file mode 100644
index 00000000..f2eea85d
--- /dev/null
+++ b/content/blog/2018-06-22-hk-types.md
@@ -0,0 +1,9 @@
+---
+title: Higher Kinded Types in a Lower Kinded Language by Jacob Bass
+image: https://img.youtube.com/vi/ERM0mBPNLHc/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=ERM0mBPNLHc
+event: Yow! Lambda Jam, Sydney, Australia
+---
+It's hard coming back down to the earth of a JVM based language after spending time with Haskell and OCaml. This talk will discuss functional programming in Kotlin with the Arrow library, how the abstractions it provides can improve your code, and how this magic that provides higher-kinded types works under the hood.
diff --git a/content/blog/2018-06-24-arrow-101.md b/content/blog/2018-06-24-arrow-101.md
new file mode 100644
index 00000000..e2accf5a
--- /dev/null
+++ b/content/blog/2018-06-24-arrow-101.md
@@ -0,0 +1,12 @@
+---
+title: Arrow 101  -  Building an Android app using Functional Programming
+image: https://cdn-images-1.medium.com/max/2000/1*7HJJpOQE8M1-xXW0_5eePQ.png
+category: articles
+tags: [core, articles]
+link: https://medium.com/@lehen01/arrow-101-building-an-android-app-using-functional-programming-fe959675d96d
+---
+[Leandro Ferreira](https://twitter.com/mLeandroBF) presents how to build a simple app using Arrow and how to implement solutions with Semigroups.
+
+[Arrow 101 — Building an Android app using Functional Programming](https://medium.com/@lehen01/arrow-101-building-an-android-app-using-functional-programming-fe959675d96d)
+
+[Arrow 101 — Modelling a real world problem with Semigroups](https://medium.com/@lehen01/arrow-101-modelling-a-real-world-problem-with-semigroups-d8f22cdf54c)
diff --git a/content/blog/2018-06-24-state-ecosystem.md b/content/blog/2018-06-24-state-ecosystem.md
new file mode 100644
index 00000000..b4453be4
--- /dev/null
+++ b/content/blog/2018-06-24-state-ecosystem.md
@@ -0,0 +1,11 @@
+---
+title: "State of the functional ecosystem in Kotlin: Mid 2018 checkup"
+image: https://img.youtube.com/vi/q_1xPYQLyaU/maxresdefault.jpg
+category: videos
+tags: [core, optics, fx, incubator, videos]
+link: https://www.youtube.com/watch?v=q_1xPYQLyaU
+event: Conference for Kotliners, Budapest
+---
+This talk focuses on the day-to-day problems Arrow solves, from small ideas to big concepts.
+
+It includes an overview of all the modules available, and some of the 3rd party libraries made by the community.
diff --git a/content/blog/2018-06-27-fp-kotlin-arrow.md b/content/blog/2018-06-27-fp-kotlin-arrow.md
new file mode 100644
index 00000000..75bebe6a
--- /dev/null
+++ b/content/blog/2018-06-27-fp-kotlin-arrow.md
@@ -0,0 +1,9 @@
+---
+title: Functional Programming in Kotlin with Arrow by Emmanuel Nhan
+image: https://image.slidesharecdn.com/fpkotlinsunnytech-180628144002/95/functional-programming-in-kotlin-with-arrow-sunnytech-2018-1-638.jpg
+category: slidedecks
+tags: [core, slidedecks]
+link: https://www.slideshare.net/EmmanuelNhan/functional-programming-in-kotlin-with-arrow-sunnytech-2018
+event: Sunny Tech, Montpellier
+---
+[@nhanmanu](https://twitter.com/nhanmanu) introduces Kotlin and how it is a good fit for functional programming. The talk goes through some interesting features of Kotlin, then show how to use them to enter the world of Higher Kinds and Typeclasses. In the last part, we explore some Arrow capabilities & built-in syntax, using validation as an example.
diff --git a/content/blog/2018-07-24-arrow-fp-kotlin.md b/content/blog/2018-07-24-arrow-fp-kotlin.md
new file mode 100644
index 00000000..b50b0423
--- /dev/null
+++ b/content/blog/2018-07-24-arrow-fp-kotlin.md
@@ -0,0 +1,9 @@
+---
+title: Arrow and Functional Programming for Kotlin Developers
+image: https://img.youtube.com/vi/qYgilPqMOp0/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=qYgilPqMOp0
+event: DroidJam India, Bangalore, India
+---
+A beginner level introduction to Functional Programming for Kotlin and/or Android Developers or developers with OOP background.
diff --git a/content/blog/2018-10-05-kotlin-conf-fp-in-kotlin-with-arrow.md b/content/blog/2018-10-05-kotlin-conf-fp-in-kotlin-with-arrow.md
new file mode 100644
index 00000000..92f4a32e
--- /dev/null
+++ b/content/blog/2018-10-05-kotlin-conf-fp-in-kotlin-with-arrow.md
@@ -0,0 +1,12 @@
+---
+title: Architecting Typed FP Applications & Libraries in Kotlin with Λrrow
+image: https://img.youtube.com/vi/VOZZTSuDMFE/maxresdefault.jpg
+category: videos
+tags: [core, fx, videos]
+link: https://www.youtube.com/watch?v=VOZZTSuDMFE
+event: KotlinConf, Amsterdam
+---
+
+This talk includes a comprehensive walkthrough of the most important patterns covered by the data types and type classes we find in Λrrow. Each pattern will be accompanied by code examples that illustrate how Λrrow brings Typed Functional Programming to Kotlin.
+
+[Sources and slides](https://github.com/47deg/arrow-architecture)
diff --git a/content/blog/2018-10-21-polyjokes.md b/content/blog/2018-10-21-polyjokes.md
new file mode 100644
index 00000000..f7e9e8cc
--- /dev/null
+++ b/content/blog/2018-10-21-polyjokes.md
@@ -0,0 +1,10 @@
+---
+title: Polyjokes  -  A polymorphic approach using Arrow
+image: /img/blog-image-header.png
+category: articles
+tags: [core, articles]
+link: https://github.com/dcampogiani/polyjokes
+---
+[@dcampogiani](https://github.com/dcampogiani) is using a polymorphic approach to retrieve a random user and then a joke about him.
+
+[Polyjokes — A polymorphic approach using Arrow](https://github.com/dcampogiani/polyjokes)
diff --git a/content/blog/2018-11-07-simple-management-dependency.md b/content/blog/2018-11-07-simple-management-dependency.md
new file mode 100644
index 00000000..7368c425
--- /dev/null
+++ b/content/blog/2018-11-07-simple-management-dependency.md
@@ -0,0 +1,9 @@
+---
+title: Simple Dependency Management in Kotlin
+image: https://img.youtube.com/vi/CR5h2Wq1yPE/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://www.youtube.com/watch?v=CR5h2Wq1yPE
+event: AndroidTO, Toronto
+---
+In this talk we introduce the concepts of Dependency Management as a language feature, typeclasses, and a live demo of [KEEP-87](https://github.com/Kotlin/KEEP/pull/87). You can follow along the example in [this folder](https://github.com/arrow-kt/arrow/tree/master/modules/docs/arrow-examples/src/test/kotlin/arrow/typeclasses).
diff --git a/content/blog/2018-11-24-ank.md b/content/blog/2018-11-24-ank.md
new file mode 100644
index 00000000..808be132
--- /dev/null
+++ b/content/blog/2018-11-24-ank.md
@@ -0,0 +1,9 @@
+---
+title: Manual documentation is dead. Long live automated documentation! Automated documentation with ΛNK
+image: https://img.youtube.com/vi/kr8iWE4Jfhc/maxresdefault.jpg
+category: videos
+tags: [core, incubator, videos]
+link: https://www.youtube.com/watch?v=kr8iWE4Jfhc
+event: droidconSF, San Francisco
+---
+It includes how the ΛNK plugin works: from having a tool that evaluates and verifies your doc snippets at compile time, to generating code documentation that is always correct and up to date.
diff --git a/content/blog/2018-11-30-hangman.md b/content/blog/2018-11-30-hangman.md
new file mode 100644
index 00000000..08ae0cd5
--- /dev/null
+++ b/content/blog/2018-11-30-hangman.md
@@ -0,0 +1,8 @@
+---
+title: Functional Hangman Game written with Arrow
+image: /img/blog-image-header.png
+category: articles
+tags: [core, fx, articles]
+link: https://lordraydenmk.github.io/2018/functional-hangman-in-kotlin-with-arrow/
+---
+[Functional Hangman](https://lordraydenmk.github.io/2018/functional-hangman-in-kotlin-with-arrow/) game - console application written with Arrow. Uses the `IO<A>` monad to push side effects to the edge of the system.
diff --git a/content/blog/2019-01-03-getting-started.md b/content/blog/2019-01-03-getting-started.md
new file mode 100644
index 00000000..6e1f5d37
--- /dev/null
+++ b/content/blog/2019-01-03-getting-started.md
@@ -0,0 +1,8 @@
+---
+title: "Getting started with FP in Kotlin and Arrow: Typeclasses"
+image: /img/blog-image-header.png
+category: articles
+tags: [core, fx, articles]
+link: http://www.smartjava.org/content/kotlin-arrow-typeclasses/
+---
+[Getting started with FP in Kotlin and Arrow: Typeclasses](http://www.smartjava.org/content/kotlin-arrow-typeclasses/) explores part of the Arrow library by explaining how you can use Arrow to create your own typeclasses and use the ones provided by Arrow to make your code more concise and better readable.
diff --git a/content/blog/2019-02-03-arrow-webflux.md b/content/blog/2019-02-03-arrow-webflux.md
new file mode 100644
index 00000000..e79bc098
--- /dev/null
+++ b/content/blog/2019-02-03-arrow-webflux.md
@@ -0,0 +1,8 @@
+---
+title: "Webflux with Kotlin and Arrow"
+image: /img/blog-image-header.png
+category: articles
+tags: [core, fx, articles]
+link: http://www.smartjava.org/content/webflux-arrow/
+---
+[Webflux with Kotlin and Arrow](http://www.smartjava.org/content/webflux-arrow/) shows how you can use Arrow together with Spring Webflux to create a reactive REST application. This article explains how to use the `MonoK` and the `FluxK` Arrow extensions together with the `binding` function to make working with the `Mono` and `Flux` reactor constructs much easier and better understandable.
diff --git a/content/blog/2019-02-10-imperative-functional-programming-arrow.md b/content/blog/2019-02-10-imperative-functional-programming-arrow.md
new file mode 100644
index 00000000..afacba1e
--- /dev/null
+++ b/content/blog/2019-02-10-imperative-functional-programming-arrow.md
@@ -0,0 +1,8 @@
+---
+title: From Imperative to Functional Programming using Arrow
+image: https://blog.frankel.ch/assets/resources/imperative-functional-programming/arrow-brand.svg
+category: tutorials
+tags: [core, fx, tutorials]
+link: https://blog.frankel.ch/imperative-functional-programming/1/
+---
+As its name implies, [From Imperative to Functional Programming using Arrow](https://blog.frankel.ch/imperative-functional-programming/1/) is a tale about migrating a simple Kotlin application written in imperative style to a fully function application with the help of the Arrow library.
diff --git a/content/blog/2019-03-12-immutable-conv-1.md b/content/blog/2019-03-12-immutable-conv-1.md
new file mode 100644
index 00000000..ac74c5a1
--- /dev/null
+++ b/content/blog/2019-03-12-immutable-conv-1.md
@@ -0,0 +1,8 @@
+---
+title: Immutable Conversations - Past and Future of Arrow
+image: https://img.youtube.com/vi/YtchNDjQuTU/maxresdefault.jpg
+category: videos
+tags: [core, fx, videos]
+link: https://www.youtube.com/watch?v=YtchNDjQuTU
+---
+In this episode, we capture a conversation between Arrow maintainers Raúl Raja and Paco Estevez as they discuss the past and future of the library which is designed to bring Functional Programming to Kotlin.
diff --git a/content/blog/2019-04-11-introducing-arrow-playground.md b/content/blog/2019-04-11-introducing-arrow-playground.md
new file mode 100644
index 00000000..83213446
--- /dev/null
+++ b/content/blog/2019-04-11-introducing-arrow-playground.md
@@ -0,0 +1,8 @@
+---
+title: Introducing Arrow Playground
+image: https://www.47deg.com/assets/img/blog/featured_images/2019-04-11-introducing-arrow-playground.png
+category: articles
+tags: [core, articles]
+link: https://www.47deg.com/blog/arrow-playground/
+---
+Arrow Playground is a JavaScript library that creates Kotlin-aware, including Arrow, editors capable of running code from HTML block elements. This is a fork of the original Kotlin Playground work done by the JetBrains team.
diff --git a/content/blog/2019-06-04-keep-87-and-typeclasses.md b/content/blog/2019-06-04-keep-87-and-typeclasses.md
new file mode 100644
index 00000000..cfb09adf
--- /dev/null
+++ b/content/blog/2019-06-04-keep-87-and-typeclasses.md
@@ -0,0 +1,8 @@
+---
+title: How KEEP-87 & Typeclasses will change the way we write Kotlin
+image: https://quickbirdstudios.com/blog/wp-content/uploads/2019/05/xFirebird.jpg.pagespeed.ic.e0DeqxTqSE.webp
+category: articles
+tags: [core, articles]
+link: https://quickbirdstudios.com/blog/keep-87-typeclasses-kotlin/
+---
+Short introduction into the proposal [KEEP-87](https://github.com/Kotlin/KEEP/pull/87) and how it would be able to improve the language.
diff --git a/content/blog/2019-06-07-kotliners-arrow-fx.md b/content/blog/2019-06-07-kotliners-arrow-fx.md
new file mode 100644
index 00000000..6c0d89a3
--- /dev/null
+++ b/content/blog/2019-06-07-kotliners-arrow-fx.md
@@ -0,0 +1,9 @@
+---
+title: "ArrowFx: Functional Programming for the masses"
+image: https://img.youtube.com/vi/uyqqoooKpmI/maxresdefault.jpg
+category: videos
+tag: [fx, videos]
+link: https://www.youtube.com/watch?v=uyqqoooKpmI
+event: Kotliners, Budapest
+---
+In this talk we recap about the imminent future of Functional Programming in Kotlin. With ArrowFx you are able to encode “effectful” programs in a controlled way following the FP principles through a direct syntax. You’ll think you’re writing imperative code!
diff --git a/content/blog/2019-07-02-modular-app-kotlin.md b/content/blog/2019-07-02-modular-app-kotlin.md
new file mode 100644
index 00000000..67730540
--- /dev/null
+++ b/content/blog/2019-07-02-modular-app-kotlin.md
@@ -0,0 +1,8 @@
+---
+title: Modular functional programming with Kotlin
+image: https://blog.frankel.ch/assets/resources/imperative-functional-programming/arrow-brand.svg
+category: articles
+tag: [core, articles]
+link: https://www.msec.it/blog/modular-functional-programming-composition-with-kotlin/
+---
+This post proposes a possible solution in order to structure and compose a pure functional Kotlin application, in order to better manage and decouple modules, get simpler tests and manage the Dependency Injection at compile time.
diff --git a/content/blog/2019-07-05-testing-with-modules.md b/content/blog/2019-07-05-testing-with-modules.md
new file mode 100644
index 00000000..a8dd2d4a
--- /dev/null
+++ b/content/blog/2019-07-05-testing-with-modules.md
@@ -0,0 +1,8 @@
+---
+title: Self-contained example of testing with modules and Arrow FX
+image: https://blog.frankel.ch/assets/resources/imperative-functional-programming/arrow-brand.svg
+category: articles
+tags: [core, fx, articles]
+link: https://www.msec.it/blog/self-contained-example-of-testing-with-modules-and-arrow-fx/
+---
+This post shows a porting with Kotlin and Arrow FX of a self-contained testing example with Scala ZIO
diff --git a/content/blog/2019-07-22-polymorphic-fx.md b/content/blog/2019-07-22-polymorphic-fx.md
new file mode 100644
index 00000000..92f135cd
--- /dev/null
+++ b/content/blog/2019-07-22-polymorphic-fx.md
@@ -0,0 +1,8 @@
+---
+title: Effect polymorphism with Arrow FX
+image: https://blog.frankel.ch/assets/resources/imperative-functional-programming/arrow-brand.svg
+category: articles
+tags: [fx, articles]
+link: https://www.msec.it/blog/effect-polymorphism-with-arrow-fx/
+---
+Wonder how to handle side effects in a very clean way while abstracting the real effect implementation? #Arrow #FX provides an easy way to do this, without the burden of Higher-Kinded Types.
diff --git a/content/blog/2019-08-08-kotlin-and-arrow-the-functional-way.md b/content/blog/2019-08-08-kotlin-and-arrow-the-functional-way.md
new file mode 100644
index 00000000..897f2872
--- /dev/null
+++ b/content/blog/2019-08-08-kotlin-and-arrow-the-functional-way.md
@@ -0,0 +1,11 @@
+---
+title: "Kotlin and Arrow: the functional way"
+image: https://pbs.twimg.com/media/D8xN-4jWkAAceCW.jpg
+category: videos
+tags: [core, videos]
+link: https://thoughtworks.wistia.com/medias/ifra1gzrho
+event: xConf, Barcelona, Spain
+---
+Kotlin is a great language for developing server-side applications; it's an object-oriented language and also a functional one, supporting features such as function types, lambdas or higher order functions. But...is this enough to switch completely from an imperative paradigm to a functional paradigm?
+
+In this talk by Noe Luaces, we'll see how features from Arrow library completes Kotlin in order to follow a pure functional way.
diff --git a/content/blog/2019-10-18-lambda-world-arrow-meta.md b/content/blog/2019-10-18-lambda-world-arrow-meta.md
new file mode 100644
index 00000000..5d82c575
--- /dev/null
+++ b/content/blog/2019-10-18-lambda-world-arrow-meta.md
@@ -0,0 +1,9 @@
+---
+title: Arrow Meta - Enabling Functional Programming in the Kotlin Compiler
+image: https://img.youtube.com/vi/WKR384ZeBgk/maxresdefault.jpg
+category: videos
+tags: [meta, videos]
+link: https://www.youtube.com/watch?v=WKR384ZeBgk
+event: Lambda World, Cádiz, Spain
+---
+Arrow Meta is a library that empowers library and application authors with the ability to write plugins for the Kotlin compiler. Compiler plugins have access to all compiler phases and can intercept and modify the AST, descriptors, and IR intermediate lang for bytecode generation.
diff --git a/content/blog/2019-11-27-functional-jvm-arrow-fx-meta.md b/content/blog/2019-11-27-functional-jvm-arrow-fx-meta.md
new file mode 100644
index 00000000..ef597c29
--- /dev/null
+++ b/content/blog/2019-11-27-functional-jvm-arrow-fx-meta.md
@@ -0,0 +1,10 @@
+---
+title: Arrow Fx & Arrow Meta - Functional Programming for the masses
+image: https://img.youtube.com/vi/DaognWtZCbs/maxresdefault.jpg
+category: videos
+tags: [meta, fx, videos]
+link: https://www.youtube.com/watch?v=DaognWtZCbs
+event: Functional JVM Meetup, Prague
+---
+In this meetup we discuss the new features of Arrow Fx to write “effectful” programs with an emphasis on simple and declarative programming for everyone.
+Additionally, we see how Arrow Meta works and how we can use it to improve the ergonomics of Functional Programming in Kotlin.
diff --git a/content/blog/2019-12-06-kotlinconf-arrow-meta.md b/content/blog/2019-12-06-kotlinconf-arrow-meta.md
new file mode 100644
index 00000000..8e99f852
--- /dev/null
+++ b/content/blog/2019-12-06-kotlinconf-arrow-meta.md
@@ -0,0 +1,9 @@
+---
+title: Keep insisting - Arrow Meta
+image: https://img.youtube.com/vi/n9smQNxUyBI/maxresdefault.jpg
+category: videos
+tags: [meta, videos]
+link: https://youtu.be/n9smQNxUyBI
+event: KotlinConf, Copenhagen
+---
+Arrow Meta is a library that empowers library and application authors with the ability to write plugins for the Kotlin compiler. Compiler plugins have access to all compiler phases and can intercept and modify the AST, descriptors, and IR intermediate lang for bytecode generation.
diff --git a/content/blog/2019-12-12-GOL-using-Kotlin-and-Arrow.md b/content/blog/2019-12-12-GOL-using-Kotlin-and-Arrow.md
new file mode 100644
index 00000000..d8d3dfc8
--- /dev/null
+++ b/content/blog/2019-12-12-GOL-using-Kotlin-and-Arrow.md
@@ -0,0 +1,8 @@
+---
+title: Conway's Game of Life using Kotlin and Arrow
+image: https://www.47deg.com/assets/img/blog/featured_images/2019-12-12-game-of-life-kotlin.jpg
+category: articles
+tags: [core, fx, articles]
+link: https://www.47deg.com/blog/conway-kotlin/
+---
+An article of a series on Functional Programming solutions for the Global Day of Coderetreat challenge. In this case, it shows an approach for it using Kotlin and Functional Programming provided by the Arrow library.
diff --git a/content/blog/2019-12-15-Kotlin-coroutines-with-arrow-fx.md b/content/blog/2019-12-15-Kotlin-coroutines-with-arrow-fx.md
new file mode 100644
index 00000000..a20b5a59
--- /dev/null
+++ b/content/blog/2019-12-15-Kotlin-coroutines-with-arrow-fx.md
@@ -0,0 +1,8 @@
+---
+title: Kotlin coroutines with arrow-fx
+image: https://www.pacoworks.com/content/images/2016/05/banner_v2.png
+category: articles
+tags: [fx, articles]
+link: https://www.pacoworks.com/2019/12/15/kotlin-coroutines-with-arrow-fx/
+---
+The purpose of this article is to summarize the approaches from questions at Slack about the usage of Either, Option and other datatypes and to give a tour of arrow-fx usage and APIs.
diff --git a/content/blog/2020-01-14-Arrow-Comonad-Android-Compose-gameOfLife.md b/content/blog/2020-01-14-Arrow-Comonad-Android-Compose-gameOfLife.md
new file mode 100644
index 00000000..b0db383f
--- /dev/null
+++ b/content/blog/2020-01-14-Arrow-Comonad-Android-Compose-gameOfLife.md
@@ -0,0 +1,8 @@
+---
+title: Arrow Comonad Approach for GameOfLife with Android Compose
+image: https://user-images.githubusercontent.com/39838885/72436632-a95c6380-377f-11ea-8a31-fe0c05d49946.gif
+category: articles
+tags: [fx, articles]
+link: https://github.com/matiaslev/ArrowComposeLifeGame/tree/master
+---
+The purpose of this article is complement the bow + SwifUi solution for the game of live we can find here https://www.47deg.com/blog/conway-swift/ with the arrow + compose version.
diff --git a/content/blog/2020-01-29-cleaner-composition-with-monad-comprehensions-arrow-fx.md b/content/blog/2020-01-29-cleaner-composition-with-monad-comprehensions-arrow-fx.md
new file mode 100644
index 00000000..417846c6
--- /dev/null
+++ b/content/blog/2020-01-29-cleaner-composition-with-monad-comprehensions-arrow-fx.md
@@ -0,0 +1,8 @@
+---
+title: "Kotlin Functional Programming: Cleaner Composition with Monad Comprehensions in Arrow Fx"
+image: https://raw.githubusercontent.com/arrow-kt/arrow-site/master/docs/img/fx/arrow-fx-brand-sidebar.svg?sanitize=true
+category: articles
+tags: [fx, articles]
+link: https://lambda.show/blog/arrow-io-monad-comprehensions-cleaner-monadic-composition
+---
+Learn how to write cleaner monadic composition in Kotlin with Arrow’s monad comprehensions, available in Arrow FX.
diff --git a/content/blog/2020-01-29-monads-and-composition-with-arrow-fx.md b/content/blog/2020-01-29-monads-and-composition-with-arrow-fx.md
new file mode 100644
index 00000000..364bc470
--- /dev/null
+++ b/content/blog/2020-01-29-monads-and-composition-with-arrow-fx.md
@@ -0,0 +1,8 @@
+---
+title: "Kotlin Functional Programming: Monads & Composition with Arrow Fx"
+image: https://raw.githubusercontent.com/arrow-kt/arrow-site/master/docs/img/fx/arrow-fx-brand-sidebar.svg?sanitize=true
+category: articles
+tags: [fx, articles]
+link: https://lambda.show/blog/arrow-io-monad
+---
+Arrow is a library created by folks over at a company called  47 degrees . In a nutshell, Arrow brings a slew of functional programming features to Kotlin. It is heavily inspired by Scala and Haskell, and emphasizes a lot of the concepts that those languages started
diff --git a/content/blog/2020-01-29-parallel-processing-the-functional-way-with-arrow-fx.md b/content/blog/2020-01-29-parallel-processing-the-functional-way-with-arrow-fx.md
new file mode 100644
index 00000000..1a99019b
--- /dev/null
+++ b/content/blog/2020-01-29-parallel-processing-the-functional-way-with-arrow-fx.md
@@ -0,0 +1,8 @@
+---
+title: "Kotlin Functional Programming: Parallel Processing The Functional Way with Arrow Fx"
+image: https://raw.githubusercontent.com/arrow-kt/arrow-site/master/docs/img/fx/arrow-fx-brand-sidebar.svg?sanitize=true
+category: articles
+tags: [fx, articles]
+link: https://lambda.show/blog/arrow-io-parallel
+---
+Learn how to handle parallel processing in Kotlin with Arrow IO monads.
diff --git a/content/blog/2020-02-26-fp-with-kotlin-arrow.md b/content/blog/2020-02-26-fp-with-kotlin-arrow.md
new file mode 100644
index 00000000..aaa1a6b1
--- /dev/null
+++ b/content/blog/2020-02-26-fp-with-kotlin-arrow.md
@@ -0,0 +1,8 @@
+---
+title: "FP with Kotlin/Arrow: Monad Comprehensions & Parallel Processing"
+image: https://img.youtube.com/vi/nAtzuIRryuE/maxresdefault.jpg
+category: videos
+tags: [fx, videos]
+link: https://youtu.be/nAtzuIRryuE
+---
+Arrow has multiple libraries available for functional programming. In this talk we'll focus on Arrow FX and learn how to handle IO in a functional way with an introduction to monadic composition. Then we'll examine how to compose monads in a cleaner fashion with Arrow FX's monad comprehensions. Finally, we'll take a look at how to parallelize IO monads with parallel map strategies.
diff --git a/content/blog/2020-02-26-safer-programming-with-arrow.md b/content/blog/2020-02-26-safer-programming-with-arrow.md
new file mode 100644
index 00000000..407d7da8
--- /dev/null
+++ b/content/blog/2020-02-26-safer-programming-with-arrow.md
@@ -0,0 +1,10 @@
+---
+title: What could possibly go wrong? - A safer programming with Arrow
+image: https://img.youtube.com/vi/C9SmleSSeGk/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/C9SmleSSeGk
+---
+Your Kotlin app grabs data from an API, transforms it and saves the processed data in a database. However, there are so many things that could go wrong at runtime: the API might be inaccessible, the data is not what you expected or the data can't be persisted in the database. You can start adding try catch blocks to your function in your objects, but there is a better way to do it: treat your impure functions as computations with context, pass them around just like other values, and make the necessary unsafe invocation from a single point of your app, your main function.
+
+This talk will walk you through the core functional concepts of Arrow, you will learn how Some, Either and even IO are functor, applicative and monad. You can use the code example from this talk as a starting point for your Arrow-learning, to write safer, simpler and more elegant functional code in Kotlin.
diff --git a/content/blog/2020-03-02-io-integration-kotlinx-coroutines.md b/content/blog/2020-03-02-io-integration-kotlinx-coroutines.md
new file mode 100644
index 00000000..8b2d0141
--- /dev/null
+++ b/content/blog/2020-03-02-io-integration-kotlinx-coroutines.md
@@ -0,0 +1,8 @@
+---
+title: IO integration with kotlinx.coroutines
+image: https://www.47deg.com/assets/img/blog/featured_images/2020-03-26-io-integration-kotlinx-coroutines.jpg
+category: articles
+tags: [fx, articles]
+link: https://www.47deg.com/blog/arrow-kotlinx-integration/
+---
+This article showcases the brand new Arrow integration module for KotlinX Coroutines included in the Arrow 0.10.5 release.
diff --git a/content/blog/2020-04-01-explaining-arrow-android-sample.md b/content/blog/2020-04-01-explaining-arrow-android-sample.md
new file mode 100644
index 00000000..381ea2ad
--- /dev/null
+++ b/content/blog/2020-04-01-explaining-arrow-android-sample.md
@@ -0,0 +1,8 @@
+---
+title: Explaining the Arrow Android sample
+image: https://blog.frankel.ch/assets/resources/imperative-functional-programming/arrow-brand.svg
+category: articles
+tags: [core, articles]
+link: https://medium.com/default-to-open/explaining-the-arrow-android-sample-ee5c8bdfe88a
+---
+Arrow is an exciting development for Kotlin developers interested in functional programming and, more broadly, pushing the limits of the Kotlin compiler.
diff --git a/content/blog/2020-04-06-template-oriented-programming-talk.md b/content/blog/2020-04-06-template-oriented-programming-talk.md
new file mode 100644
index 00000000..45e524eb
--- /dev/null
+++ b/content/blog/2020-04-06-template-oriented-programming-talk.md
@@ -0,0 +1,9 @@
+---
+title: Template-Oriented-Programming to Ship Faster, Part-1
+image: https://img.youtube.com/vi/_QBlKtUY6ac/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/_QBlKtUY6ac
+event: Kotlin User Group, Hyderabad, Online Meetup
+---
+Learn about the magic of Ad-hoc polymorphism using Λrrow typeclasses with simple examples.
diff --git a/content/blog/2020-04-06-template-oriented-programming.md b/content/blog/2020-04-06-template-oriented-programming.md
new file mode 100644
index 00000000..94250f84
--- /dev/null
+++ b/content/blog/2020-04-06-template-oriented-programming.md
@@ -0,0 +1,8 @@
+---
+title: Template-Oriented-Programming to Ship Faster
+image: https://img.youtube.com/vi/_QBlKtUY6ac/maxresdefault.jpg
+category: articles
+tags: [core, articles]
+link: https://overfullstack.github.io/posts/top-with-ad-hoc-polymorphism/
+---
+With a POC using Spring-fu + Kotlin + Arrow, let's Convert Monomorphic code (for common use-cases such as Auth, Validation) to Polymorphic reusable templates, to be reused among heterogeneous services built on different tech-stacks (blocking/non-blocking). This helps accelerate feature development.
diff --git a/content/blog/2020-04-08-writing-compiler-plugin-with-with-arrow-meta.md b/content/blog/2020-04-08-writing-compiler-plugin-with-with-arrow-meta.md
new file mode 100644
index 00000000..1271627e
--- /dev/null
+++ b/content/blog/2020-04-08-writing-compiler-plugin-with-with-arrow-meta.md
@@ -0,0 +1,9 @@
+---
+title: "Writing a Kotlin Compiler Plugin with Arrow Meta"
+image: https://meta.arrow-kt.io/img/demos/hello-world-compiler-plugin.gif
+category: articles
+tags: [meta, articles]
+link: https://medium.com/@heyitsmohit/writing-kotlin-compiler-plugin-with-arrow-meta-cf7b3689aa3e
+---
+
+Learn how to write and test the [debuglog](https://github.com/kevinmost/debuglog) compiler plugin in Arrow Meta. Here is the compiler plugin [debulog-arrow-meta](https://github.com/msya/debuglog-arrow-meta) explained in the article.
diff --git a/content/blog/2020-05-06-android-architectures-arrow-fx.md b/content/blog/2020-05-06-android-architectures-arrow-fx.md
new file mode 100644
index 00000000..66e45ee2
--- /dev/null
+++ b/content/blog/2020-05-06-android-architectures-arrow-fx.md
@@ -0,0 +1,19 @@
+---
+title: "Android architectures with Arrow Fx"
+image: https://img.youtube.com/vi/r4D-oFd6wmY/maxresdefault.jpg
+category: videos
+tags: [fx, videos]
+link: https://youtu.be/r4D-oFd6wmY
+event: May 2020 Online Kotlin Meetup
+---
+May 2020 Online Kotlin Meetup
+
+Daniel Montoya Ramos - Senior Software Engineer @47deg
+Android Jetpack Compose
+
+Dani will show a new way of building UI's in Android using Jetpack Compose, comparing Imperative vs Declarative approaches. He'll look at managing state changes, composing functions as well as some of the gotchas and wishes for the future.
+
+Alberto Ballano - Senior Software Engineer @47deg
+Android architectures with Arrow Fx
+
+Alberto will talk about typical Android architectures, and how can they benefit from Functional Programming techniques available in Arrow.
diff --git a/content/blog/2020-05-27-type-proofs-fp-kotlin-talk.md b/content/blog/2020-05-27-type-proofs-fp-kotlin-talk.md
new file mode 100644
index 00000000..7170f1b1
--- /dev/null
+++ b/content/blog/2020-05-27-type-proofs-fp-kotlin-talk.md
@@ -0,0 +1,13 @@
+---
+title: Type Proofs and FP for the Kotlin Type System
+image: https://img.youtube.com/vi/lK80dPcsNUg/hqdefault.jpg
+category: videos
+tags: [meta, videos]
+link: https://www.youtube.com/watch?v=lK80dPcsNUg&t=353s
+event: Chicago Kotlin User Group Meetup
+---
+Type Proofs is a new compiler plugin built on Arrow Meta enabling new features in the Kotlin type system, such as Type Classes, Union Types, Type Refinements, and many other extensions that make Functional Programming easier in Kotlin.
+
+Type Proofs propositions are expressed as extension functions that unlock new relationships between types ad-hoc whilst remaining fully compatible with subtype polymorphism and the existing inheritance type system.
+
+This talk demonstrates some of the new features the Arrow team is introducing in Arrow at the type level and IDE and how others can benefit from them when building libraries and applications.
diff --git a/content/blog/2020-06-05-functional-domain-modeling-kotlin.md b/content/blog/2020-06-05-functional-domain-modeling-kotlin.md
new file mode 100644
index 00000000..d340b015
--- /dev/null
+++ b/content/blog/2020-06-05-functional-domain-modeling-kotlin.md
@@ -0,0 +1,13 @@
+---
+title: "Arrow Fx: Functional Domain Modeling with Kotlin"
+image: https://img.youtube.com/vi/6sw8GAhUJz0/maxresdefault.jpg
+category: videos
+tags: [fx, videos]
+link: https://youtu.be/6sw8GAhUJz0
+event: Kotliners 2020
+---
+Arrow Fx is a purely functional concurrency framework for Kotlin’s suspend system.
+
+In this talk, we will learn how typed functional programming and functional domain modeling powered by Arrow Optics, Fx, and Meta can be applied to assemble powerful applications and architectures from small and simple building blocks.
+
+Simon and Raul will cover important topics and patterns such as optics, union types, refined types, type classes, automatic task cancellation, safe resource handling, and compare how Arrow Fx differs from KotlinX coroutines.
diff --git a/content/blog/2020-06-11-asynchronisme-et-hexagone-en-kotlin-avec-Arrow.md b/content/blog/2020-06-11-asynchronisme-et-hexagone-en-kotlin-avec-Arrow.md
new file mode 100644
index 00000000..27a597cb
--- /dev/null
+++ b/content/blog/2020-06-11-asynchronisme-et-hexagone-en-kotlin-avec-Arrow.md
@@ -0,0 +1,15 @@
+---
+title: Asynchronisme et hexagone en Kotlin avec ArrowKt
+image: https://img.youtube.com/vi/moJpV-BgezM/hqdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/moJpV-BgezM
+event: Lambda Lille
+---
+J'aime bien le DDD et surtout les architectures hexagonales. Avoir un domaine auto-portant et non couplé à des blocs techniques comme Spring (ou autres) apporte beaucoup dans la testabilité et l'évolutivité de l'application.
+Les modèles d'asynchronismes (programmation réactive, retardée, coroutines...) empêchent la dissociation stricte de notre modèle métier et de notre code infra dans un langage comme Kotlin.
+Obligé d'utiliser une lib de coroutine ou autre programmation reactive.
+Deux solutions s'offrent alors :
+- Définir que les modèles d'asynchronisme sont des invariants de notre domaine et accepter ce couplage
+- Chercher comment modéliser notre domaine comme un ensemble de comportements asynchrones
+Dans ce talk nous allons voir comment réaliser la deuxième solution en utilisant la librairie Arrow et son modèle conceptuel d'asynchronisme pour nous permettre de découpler notre domaine de toute logique d'infrastructure.
diff --git a/content/blog/2020-06-16-type-proofs-fp-kotlin-talk.md b/content/blog/2020-06-16-type-proofs-fp-kotlin-talk.md
new file mode 100644
index 00000000..8de59d74
--- /dev/null
+++ b/content/blog/2020-06-16-type-proofs-fp-kotlin-talk.md
@@ -0,0 +1,13 @@
+---
+title: Type Proofs and FP for the Kotlin Type System
+image: https://img.youtube.com/vi/ETn_6LmMjho/hqdefault.jpg
+category: videos
+tags: [meta, videos]
+link: https://youtu.be/ETn_6LmMjho
+event: KTUG Munich June Meetup
+---
+Type Proofs is a new compiler plugin built on Arrow Meta enabling new features in the Kotlin type system, such as Type Classes, Union Types, Type Refinements, and many other extensions that make Functional Programming easier in Kotlin.
+
+Type Proofs propositions are expressed as extension functions that unlock new relationships between types ad-hoc whilst remaining fully compatible with subtype polymorphism and the existing inheritance type system.
+
+This talk demonstrates some of the new features the Arrow team is introducing in Arrow at the type level and IDE and how others can benefit from them when building libraries and applications.
diff --git a/content/blog/2020-10-08-writing-kotlin-compiler-plugins-talk.md b/content/blog/2020-10-08-writing-kotlin-compiler-plugins-talk.md
new file mode 100644
index 00000000..bf653464
--- /dev/null
+++ b/content/blog/2020-10-08-writing-kotlin-compiler-plugins-talk.md
@@ -0,0 +1,10 @@
+---
+title: "Writing Kotlin Compiler Plugins with Arrow Meta"
+image: https://codingwithmohit.com/assets/images/talks/writing_kotlin_compiler_plugins_with_arrow_meta.jpg
+category: videos
+tags: [meta, videos]
+link: https://www.droidcon.com/media-detail?video=470216591
+event: Droidcon EMEA 2020
+---
+
+Lean how to write and test compiler plugins and IDE plugins with Arrow Meta.
diff --git a/content/blog/2020-10-28-arrow-promoted-to-adopt.md b/content/blog/2020-10-28-arrow-promoted-to-adopt.md
new file mode 100644
index 00000000..977a82f7
--- /dev/null
+++ b/content/blog/2020-10-28-arrow-promoted-to-adopt.md
@@ -0,0 +1,9 @@
+---
+title: "Arrow Promoted to Adopt by Technology Radar"
+image: https://static.thoughtworks.com/images/radar/2020-10/en/tech-radar-card.png
+category: articles
+tags: [core, articles]
+link: https://www.thoughtworks.com/radar/languages-and-frameworks/arrow
+---
+
+Arrow is promoted as the functional companion for Kotlin's standard library. Indeed, the package of ready-to-use higher-level abstractions delivered by Arrow has proven so useful that our teams now consider Arrow a sensible default when working with Kotlin. Recently, in preparation for the 1.0 release, the Arrow team introduced several changes, including the addition of new modules but also some deprecations and removals.
diff --git a/content/blog/2020-10-28-modifying-kotlin-nested-data-classes.md b/content/blog/2020-10-28-modifying-kotlin-nested-data-classes.md
new file mode 100644
index 00000000..1ebd3493
--- /dev/null
+++ b/content/blog/2020-10-28-modifying-kotlin-nested-data-classes.md
@@ -0,0 +1,9 @@
+---
+title: "How to fix the pain of modifying Kotlin nested data classes"
+image: https://i2.wp.com/ivanmorgillo.com/wp-content/uploads/2020/10/pexels-photo-712786.jpeg
+category: articles
+tags: [core, articles]
+link: https://ivanmorgillo.com/2020/10/28/how-to-fix-the-pain-of-modifying-kotlin-nested-data-classes/
+---
+
+Lenses are not part of the Kotlin Standard Library yet, so we will need to use an Open Source library called Arrow-kt. Arrow-kt is a huge community effort to bring some of the missing functional programming features to Kotlin.
diff --git a/content/blog/2020-10-28-technology-radar-promotes-arrow.md b/content/blog/2020-10-28-technology-radar-promotes-arrow.md
new file mode 100644
index 00000000..72fda025
--- /dev/null
+++ b/content/blog/2020-10-28-technology-radar-promotes-arrow.md
@@ -0,0 +1,9 @@
+---
+title: "Technology Radar Promotes Arrow to 'Adopt'"
+image: https://www.47deg.com/assets/img/blog/featured_images/2020-10-28-arrow-promoted-to-adopt.jpg
+category: articles
+tags: [core, articles]
+link: https://www.47deg.com/blog/arrow-promoted-to-adopt/
+---
+
+Arrow has been promoted to “Adopt” by ThoughtWorks’ technology guide *Technology Radar*.
diff --git a/content/blog/2020-11-19-fight-complexity-with-functional-programming.md b/content/blog/2020-11-19-fight-complexity-with-functional-programming.md
new file mode 100644
index 00000000..eafb1336
--- /dev/null
+++ b/content/blog/2020-11-19-fight-complexity-with-functional-programming.md
@@ -0,0 +1,10 @@
+---
+title: "Fight Complexity with Functional Programming"
+image: https://img.youtube.com/vi/Dvr6gx4XaD8/hqdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/Dvr6gx4XaD8
+event: All Things Open 2020
+---
+
+A Metric-driven approach to reduce Cognitive Complexity in a code base, using Functional Programming, demoed hands-on, by solving a complex real-world ubiquitous design challenge - REST API Bulk Request Validation, with an extensible Framework that separates what-to-do (Validations) from how-to-do (Validation Orchestration). Let's do a case study of a successful implementation done by our team in the world's largest SaaS org, Salesforce, using Kotlin and Arrow.
diff --git a/content/blog/2020-12-16-roll-your-own-computation-blocks-kotlin.md b/content/blog/2020-12-16-roll-your-own-computation-blocks-kotlin.md
new file mode 100644
index 00000000..2eb65b6a
--- /dev/null
+++ b/content/blog/2020-12-16-roll-your-own-computation-blocks-kotlin.md
@@ -0,0 +1,10 @@
+---
+title: Roll your own Computation blocks in Kotlin
+image: https://img.youtube.com/vi/0_zatebXMDU/hqdefault.jpg
+category: videos
+tags: [core, fx, videos]
+link: https://youtu.be/0_zatebXMDU
+event: Lambda Lille
+---
+Computation blocks empower library authors and users to build ad-hoc operators and DSLs over any data-type getting rid of API complexity and simplifying composition. In this talk, we will learn how we can build Computation blocks over Kotlin suspend functions & the Arrow Continuations library's `reset` / `shift` capabilities. We will demonstrate the composition of well known JVM data-types and patterns such as lists, futures, streams, and IOs, where callback chains can be simply replaced by a single
+suspended operator. The Kotlin suspension system provides enough capabilities to implement delimited continuations allowing us to ignore methods such as `map` & `flatMap` on your favorite data-type in favor of direct imperative syntax. Leveraging Kotlin suspension & thinking of Continuations as "The Mother of all Monads", we will embark on this journey where we'll build and roll our own computation blocks with Arrow Continuations.
diff --git a/content/blog/2021-01-08-advanced-fp-enterprise-bee-traverse.md b/content/blog/2021-01-08-advanced-fp-enterprise-bee-traverse.md
new file mode 100644
index 00000000..9574d047
--- /dev/null
+++ b/content/blog/2021-01-08-advanced-fp-enterprise-bee-traverse.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Traverse"
+image: https://miro.medium.com/max/700/1*GAhKVPMXbQExcEhYho3XzQ.jpeg
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-traverse-b5e4e8b7b8e4
+---
+
+This first post in a series introduces advanced FP concepts via Kotlin and Arrow. This article takes a deep dive into the Traverse operation.
diff --git a/content/blog/2021-01-13-functional-android.md b/content/blog/2021-01-13-functional-android.md
new file mode 100644
index 00000000..5859e00d
--- /dev/null
+++ b/content/blog/2021-01-13-functional-android.md
@@ -0,0 +1,10 @@
+---
+title: "Functional Android"
+image: https://www.47deg.com/assets/img/events/featured_images/2021-01-13-kotlin-london-meetup.jpg
+category: videos
+tags: [fx, videos]
+link: https://youtu.be/XhijgrEG1tI
+event: Kotlin London
+---
+
+In this talk from the January 13th, 2021 Kotlin London User Group meetup, Jorge Castillo shows how to seamlessly integrate the functional programming paradigm with our Android architecture to get the most out of both worlds.
diff --git a/content/blog/2021-01-15-advanced-fp-enterprise-bee-applicatives.md b/content/blog/2021-01-15-advanced-fp-enterprise-bee-applicatives.md
new file mode 100644
index 00000000..aaf23f8b
--- /dev/null
+++ b/content/blog/2021-01-15-advanced-fp-enterprise-bee-applicatives.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Applicatives"
+image: https://miro.medium.com/max/650/0*M1mKM3l9OCuW5bgC.png
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-applicatives-be76e4b6803c
+---
+
+This second post in a series introduces advanced FP concepts via Kotlin and Arrow. This article takes a deep dive into Applicatives.
diff --git a/content/blog/2021-01-20-fp-concepts-with-arrow.md b/content/blog/2021-01-20-fp-concepts-with-arrow.md
new file mode 100644
index 00000000..b8410b5a
--- /dev/null
+++ b/content/blog/2021-01-20-fp-concepts-with-arrow.md
@@ -0,0 +1,9 @@
+---
+title: FP concepts with Arrow
+image: http://i3.ytimg.com/vi/IZlMQXLySz4/hqdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/IZlMQXLySz4
+event: Belfast KUG
+---
+A video from the Belfast Kotlin User Group with a presentation by Katie Levy and Shelby Cohen covering FP concepts with Arrow.
diff --git a/content/blog/2021-01-22-advanced-fp-enterprise-bee-higher-kinded-types.md b/content/blog/2021-01-22-advanced-fp-enterprise-bee-higher-kinded-types.md
new file mode 100644
index 00000000..e096e01b
--- /dev/null
+++ b/content/blog/2021-01-22-advanced-fp-enterprise-bee-higher-kinded-types.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Higher Kinded Types"
+image: https://miro.medium.com/max/700/0*cXrhKidxYGGJABB1.jpg
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-higher-kinded-types-c6742e24527
+---
+
+This third post in a series introduces advanced FP concepts via Kotlin and Arrow. This article shows the usefulness of Higher Kinded Types.
diff --git a/content/blog/2021-01-29-advanced-fp-enterprise-bee-kleisli.md b/content/blog/2021-01-29-advanced-fp-enterprise-bee-kleisli.md
new file mode 100644
index 00000000..8e51b811
--- /dev/null
+++ b/content/blog/2021-01-29-advanced-fp-enterprise-bee-kleisli.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Kleisli"
+image: https://miro.medium.com/max/397/1*ALuwNIY0UvXaBzk_zaBXTA.png
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-kleisli-1d0de0fa82d9
+---
+
+This fourth post in a series introduces advanced FP concepts via Kotlin and Arrow. This article looks at the Kleisli type.
diff --git a/content/blog/2021-02-05-advanced-fp-enterprise-bee-typeclasses.md b/content/blog/2021-02-05-advanced-fp-enterprise-bee-typeclasses.md
new file mode 100644
index 00000000..850b0135
--- /dev/null
+++ b/content/blog/2021-02-05-advanced-fp-enterprise-bee-typeclasses.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Typeclasses"
+image: https://miro.medium.com/max/700/0*oOFUf_kkNWyHzS8Q.jpg
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-typeclasses-2addc232ae23
+---
+
+This fifth post in a series introduces advanced FP concepts via Kotlin and Arrow. This article introduces Typeclasses, and reviews a practical example of Typeclasses from the Arrow library.
diff --git a/content/blog/2021-02-10-advanced-fp-enterprise-bee-optics.md b/content/blog/2021-02-10-advanced-fp-enterprise-bee-optics.md
new file mode 100644
index 00000000..e782b080
--- /dev/null
+++ b/content/blog/2021-02-10-advanced-fp-enterprise-bee-optics.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Optics"
+image: https://miro.medium.com/max/700/1*7Q3EXosiX4YmLGYQWOllmQ.jpeg
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-optics-2ccc444d409b
+---
+
+This is the sixth post in a series introducing advanced FP concepts via Kotlin and Arrow. This article covers Optics with Kotlin and Arrow. 
diff --git a/content/blog/2021-02-12-hands-on-arrow.md b/content/blog/2021-02-12-hands-on-arrow.md
new file mode 100644
index 00000000..22e65607
--- /dev/null
+++ b/content/blog/2021-02-12-hands-on-arrow.md
@@ -0,0 +1,9 @@
+---
+title: Hands-on Arrow
+image: http://i3.ytimg.com/vi/tkl9EaUMfm8/hqdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/tkl9EaUMfm8?t=2136
+event: GDG Nuremberg
+---
+A video from the meetup of the Google Developer Group based in Nuremberg with a presentation by Karin-Aleksandra Monoid about using Arrow.
diff --git a/content/blog/2021-02-19-advanced-fp-enterprise-bee-state.md b/content/blog/2021-02-19-advanced-fp-enterprise-bee-state.md
new file mode 100644
index 00000000..211c334a
--- /dev/null
+++ b/content/blog/2021-02-19-advanced-fp-enterprise-bee-state.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: State"
+image: https://miro.medium.com/max/460/0*rMk9skNj5L-1E6cs
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-state-4f8fd2d8098b
+---
+
+This is the seventh post in a series written by Garth Gilmour introducing advanced FP concepts via Kotlin and Arrow. This article explores the world of Monads, and, in particular, the State type.
diff --git a/content/blog/2021-02-26-advanced-fp-enterprise-bee-shiny-things.md b/content/blog/2021-02-26-advanced-fp-enterprise-bee-shiny-things.md
new file mode 100644
index 00000000..efa55b8b
--- /dev/null
+++ b/content/blog/2021-02-26-advanced-fp-enterprise-bee-shiny-things.md
@@ -0,0 +1,9 @@
+---
+title: "Advanced FP for the Enterprise Bee: Shiny Things"
+image: https://miro.medium.com/max/675/0*2D7qyemVVsa0Aldp.jpg
+category: articles
+tags: [core, articles]
+link: https://medium.com/google-developer-experts/advanced-fp-for-the-enterprise-bee-shiny-things-770ae9c27472
+---
+
+Garth Gilmour concludes his 8-part series introducing advanced FP concepts via Kotlin and Arrow.
diff --git a/content/blog/2021-04-01-arrow-0-12-0-0-13-1-release.md b/content/blog/2021-04-01-arrow-0-12-0-0-13-1-release.md
new file mode 100644
index 00000000..4d169c9c
--- /dev/null
+++ b/content/blog/2021-04-01-arrow-0-12-0-0-13-1-release.md
@@ -0,0 +1,9 @@
+---
+title: "Arrow 0.12.0 & 0.13.1 are now available"
+image: https://www.47deg.com/assets/img/blog/featured_images/2021-03-30-arrow-0-13-1.jpg
+category: articles
+tags: [core, articles]
+link: https://www.47deg.com/blog/arrow-0.13.0-release/
+---
+
+Arrow 0.12.0 & 0.13.1 are now available, featuring streamlining of the library for 1.0.0.
diff --git a/content/blog/2021-04-11-functional-domain-modeling-kotlin.md b/content/blog/2021-04-11-functional-domain-modeling-kotlin.md
new file mode 100644
index 00000000..ca3162d8
--- /dev/null
+++ b/content/blog/2021-04-11-functional-domain-modeling-kotlin.md
@@ -0,0 +1,9 @@
+---
+title: "Functional Domain Modeling in Kotlin"
+image: https://www.47deg.com/assets/img/blog/featured_images/2021-02-05-functional-domain-modeling-in-kotlin.jpg
+category: articles
+tags: [core, articles]
+link: https://www.47deg.com/blog/functional-domain-modeling/
+---
+
+Learn how to leverage Functional Domain Modeling to fully utilize the Kotlin type system and prevent bugs.
diff --git a/content/blog/2021-04-11-your-own-custom-spring-data-repository.md b/content/blog/2021-04-11-your-own-custom-spring-data-repository.md
new file mode 100644
index 00000000..4a121539
--- /dev/null
+++ b/content/blog/2021-04-11-your-own-custom-spring-data-repository.md
@@ -0,0 +1,9 @@
+---
+title: "Your own custom Spring Data repository"
+image: https://blog.frankel.ch/assets/resources/custom-spring-data-repository/spring-data.svg
+category: articles
+tags: [core, articles]
+link: https://blog.frankel.ch/custom-spring-data-repository/
+---
+
+How to integrate Spring Data Repository with Arrow.
diff --git a/content/blog/2021-04-13-functional-domain-modeling-kotlin-validation.md b/content/blog/2021-04-13-functional-domain-modeling-kotlin-validation.md
new file mode 100644
index 00000000..d738c7c2
--- /dev/null
+++ b/content/blog/2021-04-13-functional-domain-modeling-kotlin-validation.md
@@ -0,0 +1,9 @@
+---
+title: "Functional Domain Modeling in Kotlin - Validation"
+image: https://www.47deg.com/assets/img/blog/featured_images/2021-04-07-functional-domain-modeling-in-kotlin-validation.jpg
+category: articles
+tags: [core, articles]
+link: https://www.47deg.com/blog/functional-domain-modeling-part-2/
+---
+
+In part two of Functional Domain Modeling in Kotlin, Simon Vergauwen shows how to improve a domain with validation.
diff --git a/content/blog/2021-08-12-arrow-of-outrageous-error-handling.md b/content/blog/2021-08-12-arrow-of-outrageous-error-handling.md
new file mode 100644
index 00000000..548dcd4d
--- /dev/null
+++ b/content/blog/2021-08-12-arrow-of-outrageous-error-handling.md
@@ -0,0 +1,9 @@
+---
+title: Arrow of Outrageous Error Handling
+image: http://i3.ytimg.com/vi/OiN79vpPM08/hqdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/OiN79vpPM08
+event: Android Worldwide
+---
+An Android Worldwide talk by David Rawson about error handling on Android using Arrow.
diff --git a/content/blog/2021-11-30-functional-programming-kotlin-exploring-arrow.md b/content/blog/2021-11-30-functional-programming-kotlin-exploring-arrow.md
new file mode 100644
index 00000000..018a8754
--- /dev/null
+++ b/content/blog/2021-11-30-functional-programming-kotlin-exploring-arrow.md
@@ -0,0 +1,9 @@
+---
+title: "Functional programming in Kotlin: Exploring Arrow"
+image: http://i3.ytimg.com/vi/Wojgv2MeMGU/hqdefault.jpg
+category: videos
+tags: [core, optics, videos]
+link: https://youtu.be/Wojgv2MeMGU
+event: Kotlin Dev Day Amsterdam
+---
+A talk by Ties van de Ven explaining how to use the Either monad in practice, and how to use Arrow Optics lenses.
diff --git a/content/blog/2021-12-15-functional-programming-in-kotlin-with-arrow.md b/content/blog/2021-12-15-functional-programming-in-kotlin-with-arrow.md
new file mode 100644
index 00000000..8a72f2f0
--- /dev/null
+++ b/content/blog/2021-12-15-functional-programming-in-kotlin-with-arrow.md
@@ -0,0 +1,8 @@
+---
+title: Functional programming in Kotlin with Arrow
+image: https://img.youtube.com/vi/IDMmmrRhUvQ/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/IDMmmrRhUvQ
+---
+A presentation by Simon Vergauwen and Alejandro Serrano presented on the official Kotlin YouTube channel.
diff --git a/content/blog/2022-02-02-announcing-arrow-analysis.md b/content/blog/2022-02-02-announcing-arrow-analysis.md
new file mode 100644
index 00000000..d3b5af73
--- /dev/null
+++ b/content/blog/2022-02-02-announcing-arrow-analysis.md
@@ -0,0 +1,9 @@
+---
+title: "Announcing Arrow Analysis - a Kotlin compiler plug-in"
+image: https://www.47deg.com/assets/img/blog/featured_images/2022-01-25-arrow-analysis-is-available.jpg
+category: articles
+tags: [meta, articles]
+link: https://www.47deg.com/blog/arrow-analysis-kotlin-compiler-plugin/
+---
+
+Announcing Arrow Analysis - a Kotlin compiler plug-in.
diff --git a/content/blog/2022-02-22-domain-model-validation-in-kotlin-part-1.md b/content/blog/2022-02-22-domain-model-validation-in-kotlin-part-1.md
new file mode 100644
index 00000000..4875982b
--- /dev/null
+++ b/content/blog/2022-02-22-domain-model-validation-in-kotlin-part-1.md
@@ -0,0 +1,9 @@
+---
+title: "Domain Model Validation In Kotlin: Part 1"
+image: https://miro.medium.com/max/1400/1*Xc0B4542z3WHiQ3DvLXcYg.png
+category: articles
+tags: [core, articles]
+link: https://medium.com/@tibtof/domain-model-validation-in-kotlin-part-1-21fa44c60ef3
+---
+In the first article in this series, Tiberiu Tofan describes his team's journey using Kotlin and Arrow for domain model validation, 
+starting by setting the domain model's foundation in a type-safe way.
diff --git a/content/blog/2022-03-03-domain-model-validation-in-kotlin-part-2.md b/content/blog/2022-03-03-domain-model-validation-in-kotlin-part-2.md
new file mode 100644
index 00000000..ce1082df
--- /dev/null
+++ b/content/blog/2022-03-03-domain-model-validation-in-kotlin-part-2.md
@@ -0,0 +1,11 @@
+---
+title: "Domain Model Validation In Kotlin: Part 2"
+image: https://miro.medium.com/max/1400/1*vf0byE6Kp5wGwmDqxRbUOg.png
+category: articles
+tags: [core, articles]
+link: https://medium.com/@tibtof/domain-model-validation-in-kotlin-part-2-fb4726ef8f8d
+---
+In the second article in this series, Tiberiu Tofan writes how Validated type can be 
+used to validate multiple properties, accumulate the errors, apply individual 
+element validations to lists of elements, and create rules that 
+depend on numerous properties.
diff --git a/content/blog/2022-03-10-domain-model-validation-in-kotlin-part-3.md b/content/blog/2022-03-10-domain-model-validation-in-kotlin-part-3.md
new file mode 100644
index 00000000..8dad5afc
--- /dev/null
+++ b/content/blog/2022-03-10-domain-model-validation-in-kotlin-part-3.md
@@ -0,0 +1,9 @@
+---
+title: "Domain Model Validation In Kotlin: Part 3"
+image: https://miro.medium.com/max/1400/1*6RXLldOxvMR3nKi_k_wYTA.png
+category: articles
+tags: [core, articles]
+link: https://tibtof.medium.com/domain-model-validation-in-kotlin-part-3-96c3fd4af342
+---
+In the third part of the series, Tiberiu Tofan explores multiple techniques of using a context when doing validations 
+and how the context can be changed in the tests to simulate success or failure. All using just Kotlin standard library.
diff --git a/content/blog/2022-03-31-domain-model-validation-in-kotlin-part-4.md b/content/blog/2022-03-31-domain-model-validation-in-kotlin-part-4.md
new file mode 100644
index 00000000..04688232
--- /dev/null
+++ b/content/blog/2022-03-31-domain-model-validation-in-kotlin-part-4.md
@@ -0,0 +1,9 @@
+---
+title: "Domain Model Validation In Kotlin: Part 4"
+image: https://miro.medium.com/max/1400/1*3jegLLY4GbGj71nauV2l_Q.png
+category: articles
+tags: [core, articles]
+link: https://tibtof.medium.com/domain-model-validation-in-kotlin-part-4-2462b334ca6c
+---
+In this final part of the series, Tiberiu puts everything together in a small CLI application, using Arrow data types and computation blocks
+to handle validation errors and exceptions in a unitary and composable way.
diff --git a/content/blog/2022-05-18-functional-programming-kotlin-exploring-arrow-ties-van-de-ven.md b/content/blog/2022-05-18-functional-programming-kotlin-exploring-arrow-ties-van-de-ven.md
new file mode 100644
index 00000000..a2df3574
--- /dev/null
+++ b/content/blog/2022-05-18-functional-programming-kotlin-exploring-arrow-ties-van-de-ven.md
@@ -0,0 +1,9 @@
+---
+title: "Functional programming in Kotlin: exploring Arrow by Ties Van de Ven"
+image: http://i3.ytimg.com/vi/eFheAErqJzA/hqdefault.jpg
+category: videos
+tags: [core, optics, videos]
+link: https://youtu.be/eFheAErqJzA
+event: Devoxx UK
+---
+A talk by Ties van de Ven that shows how Arrow helps to unleash the full FP power of Kotlin.
diff --git a/content/blog/2022-05-30-extending-kotlinx-serialization-functionality-arrow-meta.md b/content/blog/2022-05-30-extending-kotlinx-serialization-functionality-arrow-meta.md
new file mode 100644
index 00000000..7c075940
--- /dev/null
+++ b/content/blog/2022-05-30-extending-kotlinx-serialization-functionality-arrow-meta.md
@@ -0,0 +1,9 @@
+---
+title: "Extending kotlinx.serialization functionality with Arrow Meta with Karin-Aleksandra Monoid"
+image: http://i3.ytimg.com/vi/eHSepXJPKZ0/hqdefault.jpg
+category: videos
+tags: [meta, videos]
+link: https://youtu.be/eHSepXJPKZ0
+event: Kotlin Dev Day
+---
+Karin-Aleksandra Monoid provides an overview of Arrow Meta features.
diff --git a/content/blog/2022-05-30-super-charge-build-arrow-analysis.md b/content/blog/2022-05-30-super-charge-build-arrow-analysis.md
new file mode 100644
index 00000000..fdac7119
--- /dev/null
+++ b/content/blog/2022-05-30-super-charge-build-arrow-analysis.md
@@ -0,0 +1,9 @@
+---
+title: "Super-charge your build with Arrow Analysis by Alejandro Serrano Mena"
+image: http://i3.ytimg.com/vi/yCZtnzTnpRA/hqdefault.jpg
+category: videos
+tags: [analysis, videos]
+link: https://youtu.be/yCZtnzTnpRA
+event: Kotlin Dev Day
+---
+Alejandro Serrano presents Arrow Analysis, a Kotlin compiler plug-in that does pre-and post-condition and type invariant checking at compile time.
diff --git a/content/blog/2022-05-31-building-applications-with-kotlin-and-arrow-kt-in-style.md b/content/blog/2022-05-31-building-applications-with-kotlin-and-arrow-kt-in-style.md
new file mode 100644
index 00000000..3751bc9e
--- /dev/null
+++ b/content/blog/2022-05-31-building-applications-with-kotlin-and-arrow-kt-in-style.md
@@ -0,0 +1,8 @@
+---
+title: Building applications with Kotlin and Arrow.kt in style
+image: https://img.youtube.com/vi/g79A6HmbW5M/hqdefault.jpg
+category: videos
+tags: [core, fx, videos]
+link: https://youtu.be/g79A6HmbW5M
+---
+A presentation by Simon Vergauwen presented on the official Kotlin YouTube channel.
\ No newline at end of file
diff --git a/content/blog/2022-06-14-arrow-kotlin-dev-day.md b/content/blog/2022-06-14-arrow-kotlin-dev-day.md
new file mode 100644
index 00000000..dd5ec03b
--- /dev/null
+++ b/content/blog/2022-06-14-arrow-kotlin-dev-day.md
@@ -0,0 +1,8 @@
+---
+title: "Arrow put on a big show at Kotlin Dev Day"
+image: https://www.47deg.com/assets/img/blog/featured_images/2022-06-13-arrow-put-on-big-show-at-kotlin-dev-day.jpg
+category: articles
+tags: [core, fx, articles]
+link: https://www.47deg.com/blog/arrow-put-on-big-show-at-kotlindevday/
+---
+A recap of the attention Arrow received at Kotlin Dev Day.
diff --git a/content/blog/2022-06-28-turbocharging-kotlin-talking-kotlin.md b/content/blog/2022-06-28-turbocharging-kotlin-talking-kotlin.md
new file mode 100644
index 00000000..901788d5
--- /dev/null
+++ b/content/blog/2022-06-28-turbocharging-kotlin-talking-kotlin.md
@@ -0,0 +1,8 @@
+---
+title: "Turbocharging Kotlin: Arrow Analysis, Optics, and Meta"
+image: https://img.youtube.com/vi/tX4nLqcW2JA/maxresdefault.jpg
+category: videos
+tags: [core, meta, optics, analysis, videos]
+link: https://youtu.be/tX4nLqcW2JA
+---
+Raul Raja, Simon Vergauwen, and Alejandro Serrano appeared on Talking Kotlin to chat about Arrow.
diff --git a/content/blog/2022-12-01-actions-as-data.md b/content/blog/2022-12-01-actions-as-data.md
new file mode 100644
index 00000000..ee576cbf
--- /dev/null
+++ b/content/blog/2022-12-01-actions-as-data.md
@@ -0,0 +1,8 @@
+---
+title: Actions as Data
+image: https://img.youtube.com/vi/ujzZITapUwA/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/ujzZITapUwA
+---
+A presentation by Alejandro Serrano at Advanced Kotlin Dev Day 2022.
diff --git a/content/blog/2022-12-01-context-receivers.md b/content/blog/2022-12-01-context-receivers.md
new file mode 100644
index 00000000..b0eba2e8
--- /dev/null
+++ b/content/blog/2022-12-01-context-receivers.md
@@ -0,0 +1,8 @@
+---
+title: "Context Receivers: Kotlin's new secret sauce"
+image: https://img.youtube.com/vi/2oiRCYnqhDs/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/2oiRCYnqhDs
+---
+Alejandro Serrano's presentation from Advanced Kotlin Dev Day 2022 about context receivers.
diff --git a/content/blog/2022-12-01-functional-flowing.md b/content/blog/2022-12-01-functional-flowing.md
new file mode 100644
index 00000000..46c9a1ac
--- /dev/null
+++ b/content/blog/2022-12-01-functional-flowing.md
@@ -0,0 +1,8 @@
+---
+title: Functional Flowing
+image: https://img.youtube.com/vi/Mj9B0rhN1RE/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/Mj9B0rhN1RE
+---
+Simon Vergauwen shows how to leverage KotlinX Flow to describe powerful programs and build pipelines to transform and manipulate data in an efficient streaming way.
diff --git a/content/blog/2022-12-01-grateful-shutdown-structured-concurrency.md b/content/blog/2022-12-01-grateful-shutdown-structured-concurrency.md
new file mode 100644
index 00000000..16518857
--- /dev/null
+++ b/content/blog/2022-12-01-grateful-shutdown-structured-concurrency.md
@@ -0,0 +1,8 @@
+---
+title: Grateful Shutdown with Structured Concurrency
+image: https://img.youtube.com/vi/A69_t_oEP_E/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/A69_t_oEP_E
+---
+A presentation by Simon Vergauwen at Advanced Kotlin Dev Day 2022.
diff --git a/content/blog/2023-01-03-codelytv-interview.md b/content/blog/2023-01-03-codelytv-interview.md
new file mode 100644
index 00000000..6f1ac9e4
--- /dev/null
+++ b/content/blog/2023-01-03-codelytv-interview.md
@@ -0,0 +1,11 @@
+---
+# author: Pepe
+title: CodelyTV Interview with Raul Raja
+image: https://img.youtube.com/vi/8WdprhzmQe4/maxresdefault.jpg
+category: videos
+tags: [core, videos]
+link: https://youtu.be/8WdprhzmQe4
+---
+
+An interview with Arrow maintainer Raúl Raja by Rafa Gómez on CodelyTV.
+
diff --git a/content/blog/2023-02-04-functional-fun-kotlin.md b/content/blog/2023-02-04-functional-fun-kotlin.md
new file mode 100644
index 00000000..216186ae
--- /dev/null
+++ b/content/blog/2023-02-04-functional-fun-kotlin.md
@@ -0,0 +1,12 @@
+---
+title: Functional Fun in Kotlin
+image: https://files.speakerdeck.com/presentations/717144e6f3f54fd7aca2215fff36c2b3/preview_slide_0.jpg
+category: slidedecks
+tags: [core, slidedecks]
+link: https://speakerdeck.com/nomisrev/functional-fun-in-kotlin
+event: FOSDEM
+---
+
+# Functional Fun in Kotlin
+
+[Simon Vergauwen](https://twitter.com/vergauwen_simon) shares why he thinks Kotlin is great language to do modern functional programming, and why he believes it's perhaps the best language to do modern mainstream (hardcore) functional programming.
diff --git a/docusaurus.config.js b/docusaurus.config.js
index d2eeac5f..714666d5 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -62,7 +62,6 @@ const createConfig = async () => {
             blogTagsPostsComponent:
               '@site/src/components/Blog/BlogTagsPostsPage',
             postsPerPage: 8,
-            archiveBasePath: null,
             editUrl: 'https://github.com/arrow-kt/arrow-website/edit/main/',
           },
           theme: {
diff --git a/src/components/Blog/BlogListPage/BlogListPage.tsx b/src/components/Blog/BlogListPage/BlogListPage.tsx
index 9c819954..ebd9147a 100644
--- a/src/components/Blog/BlogListPage/BlogListPage.tsx
+++ b/src/components/Blog/BlogListPage/BlogListPage.tsx
@@ -18,6 +18,9 @@ import { Banner } from '@site/src/components/Banner';
 import data from './blog-list-page.yml';
 import styles from './blog-list-page.module.css';
 
+const formatSubtitle = (name: string | undefined, date: string): string =>
+  name ? `${name}, ${date}` : `${date}`;
+
 function BlogListPageMetadata(props: Props): JSX.Element {
   const { metadata } = props;
   const {
@@ -39,7 +42,10 @@ function BlogListPageContent(props: Props): JSX.Element {
 
   const posts = items.map((item) => ({
     title: item.content.metadata.title,
-    subtitle: `${item.content.metadata.authors[0].name}, ${item.content.metadata.formattedDate}`,
+    subtitle: formatSubtitle(
+      item.content.metadata.authors[0]?.name,
+      item.content.metadata.formattedDate,
+    ),
     image: item.content.frontMatter.image,
     body: item.content.metadata.description,
     href: item.content.metadata.permalink,
diff --git a/src/components/Blog/BlogTagsPostsPage/BlogTagsPostsPage.tsx b/src/components/Blog/BlogTagsPostsPage/BlogTagsPostsPage.tsx
index 42bcd449..b18a2d22 100644
--- a/src/components/Blog/BlogTagsPostsPage/BlogTagsPostsPage.tsx
+++ b/src/components/Blog/BlogTagsPostsPage/BlogTagsPostsPage.tsx
@@ -17,6 +17,9 @@ import { ImageCard, ImageCardProps } from '@site/src/components/ImageCard';
 
 import styles from './blog-tags-posts-page.module.css';
 
+const formatSubtitle = (name: string | undefined, date: string): string =>
+  name ? `${name}, ${date}` : `${date}`;
+
 // Very simple pluralization: probably good enough for now
 function useBlogPostsPlural() {
   const { selectMessage } = usePluralForm();
@@ -68,7 +71,10 @@ function BlogTagsPostsPageContent(props: Props): JSX.Element {
 
   const posts = items.map((item) => ({
     title: item.content.metadata.title,
-    subtitle: `${item.content.metadata.authors[0].name}, ${item.content.metadata.formattedDate}`,
+    subtitle: formatSubtitle(
+      item.content.metadata.authors[0]?.name,
+      item.content.metadata.formattedDate,
+    ),
     image: item.content.frontMatter.image,
     body: item.content.metadata.description,
     href: item.content.metadata.permalink,
diff --git a/src/components/ImageCard/ImageCard.tsx b/src/components/ImageCard/ImageCard.tsx
index 2202ec5b..bf0f1aa6 100644
--- a/src/components/ImageCard/ImageCard.tsx
+++ b/src/components/ImageCard/ImageCard.tsx
@@ -34,15 +34,15 @@ export function ImageCardBase({
         <img
           className={styles.image}
           src={image}
-          alt={`${title} category`}
-          title={`${title} category`}
+          alt={`${title}`}
+          title={`${title}`}
         />
       </div>
       <div className={`card__body ${styles.body}`}>
         <h3 className={styles.title}>{title}</h3>
         <h5 className={styles.subtitle}>{subtitle}</h5>
         <p className={styles.text}>{body}</p>
-        <strong>
+        <strong className={styles.linkContainer}>
           <Link href={href} className={styles.link}>
             Learn more
           </Link>
diff --git a/src/components/ImageCard/image-card.module.css b/src/components/ImageCard/image-card.module.css
index fecdb97b..ed85db46 100644
--- a/src/components/ImageCard/image-card.module.css
+++ b/src/components/ImageCard/image-card.module.css
@@ -1,3 +1,7 @@
+.card {
+  max-height: 25rem;
+}
+
 :local(.card) :global(.card__image) {
   position: relative;
 }
@@ -12,6 +16,7 @@
   left: 0;
   mix-blend-mode: color;
   pointer-events: none;
+  opacity: 0.8;
 }
 
 :local(.card) :global(.card__image)::after {
@@ -27,6 +32,7 @@
     var(--ifm-color-primary-light) 81.52%
   );
   pointer-events: none;
+  opacity: 0.9;
 }
 
 .landscapeMode {
@@ -35,14 +41,11 @@
 
 .imageContainer {
   flex-basis: 40%;
+  height: 40%;
 }
 
-.landscapeMode {
-  flex-direction: row;
-}
-
-.imageContainer {
-  flex-basis: 40%;
+.landscapeMode .imageContainer {
+  height: 100%;
 }
 
 .image {
@@ -53,6 +56,13 @@
 
 .body {
   flex-basis: 60%;
+  height: 60%;
+  display: flex;
+  flex-direction: column;
+}
+
+.landscapeMode .body {
+  height: 100%;
 }
 
 .title {
@@ -74,6 +84,10 @@
   overflow: hidden;
 }
 
+.linkContainer {
+  margin-top: auto;
+}
+
 .link::after {
   content: '';
   border: solid var(--ifm-link-color);
diff --git a/src/theme/BlogPostItem/Header/Author/styles.module.css b/src/theme/BlogPostItem/Header/Author/styles.module.css
index 109c17df..3d6f8570 100644
--- a/src/theme/BlogPostItem/Header/Author/styles.module.css
+++ b/src/theme/BlogPostItem/Header/Author/styles.module.css
@@ -22,6 +22,7 @@
   mix-blend-mode: color;
   border-radius: 100%;
   pointer-events: none;
+  opacity: 0.5;
 }
 
 .imageContainer::after {
@@ -38,4 +39,5 @@
   );
   border-radius: 100%;
   pointer-events: none;
+  opacity: 0.5;
 }
\ No newline at end of file
diff --git a/src/theme/BlogPostItem/Header/Image/index.tsx b/src/theme/BlogPostItem/Header/Image/index.tsx
index 1e7b032f..06c79034 100644
--- a/src/theme/BlogPostItem/Header/Image/index.tsx
+++ b/src/theme/BlogPostItem/Header/Image/index.tsx
@@ -1,10 +1,44 @@
-import React from 'react';
+import React, { ReactNode } from 'react';
 
+import Link from '@docusaurus/Link';
 import { useBaseUrlUtils } from '@docusaurus/useBaseUrl';
 import { useBlogPost } from '@docusaurus/theme-common/internal';
 
 import styles from './styles.module.css';
 
+interface BlogPostFrontMatterExpanded extends BlogPostFrontMatter {
+  link: string;
+}
+
+interface BlogPostItemHeaderImageBaseProps {
+  title: string;
+  image: string;
+}
+
+function LinkWrapper({
+  href,
+  children,
+}: {
+  href: string;
+  children: ReactNode;
+}): JSX.Element {
+  return <Link href={href}>{children}</Link>;
+}
+
+const BlogPostItemHeaderImageBase = ({
+  title,
+  image,
+}: BlogPostItemHeaderImageBaseProps): JSX.Element => (
+  <div className={`${styles.imageContainer} margin-bottom--lg`}>
+    <img
+      className={styles.image}
+      alt={`${title}`}
+      title={`${title}`}
+      src={image}
+    />
+  </div>
+);
+
 /*
  * An additional component to show the image of a post
  */
@@ -13,19 +47,17 @@ export default function BlogPostItemHeaderImage(): JSX.Element | null {
   const { title } = metadata;
   const { withBaseUrl } = useBaseUrlUtils();
   const image = assets.image ?? frontMatter.image;
+  const { link } = frontMatter as BlogPostFrontMatterExpanded;
 
   if (!image) {
     return null;
   }
 
-  return (
-    <div className={styles.imageContainer}>
-      <img
-        className={styles.image}
-        alt={`${title}`}
-        title={`${title}`}
-        src={withBaseUrl(image)}
-      />
-    </div>
+  return link ? (
+    <LinkWrapper href={link}>
+      <BlogPostItemHeaderImageBase image={withBaseUrl(image)} title={title} />
+    </LinkWrapper>
+  ) : (
+    <BlogPostItemHeaderImageBase image={withBaseUrl(image)} title={title} />
   );
 }
diff --git a/src/theme/BlogPostItem/Header/Image/styles.module.css b/src/theme/BlogPostItem/Header/Image/styles.module.css
index f6298d6e..6f1ff306 100644
--- a/src/theme/BlogPostItem/Header/Image/styles.module.css
+++ b/src/theme/BlogPostItem/Header/Image/styles.module.css
@@ -13,6 +13,7 @@
   left: 0;
   mix-blend-mode: color;
   pointer-events: none;
+  opacity: 0.7;
 }
 
 .imageContainer::after {
@@ -28,6 +29,7 @@
     var(--ifm-color-primary-light) 81.52%
   );
   pointer-events: none;
+  opacity: 0.8;
 }
 
 .image {
diff --git a/src/theme/BlogPostItem/Header/Info/index.tsx b/src/theme/BlogPostItem/Header/Info/index.tsx
new file mode 100644
index 00000000..112a5c03
--- /dev/null
+++ b/src/theme/BlogPostItem/Header/Info/index.tsx
@@ -0,0 +1,85 @@
+import React from 'react';
+
+import { translate } from '@docusaurus/Translate';
+import { usePluralForm } from '@docusaurus/theme-common';
+import { useBlogPost } from '@docusaurus/theme-common/internal';
+import type { Props } from '@theme/BlogPostItem/Header/Info';
+
+import styles from './styles.module.css';
+
+interface BlogPostFrontMatterExpanded extends BlogPostFrontMatter {
+  event: string;
+}
+
+// Very simple pluralization: probably good enough for now
+function useReadingTimePlural() {
+  const { selectMessage } = usePluralForm();
+  return (readingTimeFloat: number) => {
+    const readingTime = Math.ceil(readingTimeFloat);
+    return selectMessage(
+      readingTime,
+      translate(
+        {
+          id: 'theme.blog.post.readingTime.plurals',
+          description:
+            'Pluralized label for "{readingTime} min read". Use as much plural forms (separated by "|") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)',
+          message: 'One min read|{readingTime} min read',
+        },
+        { readingTime },
+      ),
+    );
+  };
+}
+
+function ReadingTime({ readingTime }: { readingTime: number }) {
+  const readingTimePlural = useReadingTimePlural();
+  return <>{readingTimePlural(readingTime)}</>;
+}
+
+function Date({
+  date,
+  formattedDate,
+}: {
+  date: string;
+  formattedDate: string;
+}) {
+  return (
+    <time dateTime={date} itemProp="datePublished">
+      {formattedDate}
+    </time>
+  );
+}
+
+function Spacer() {
+  return <>{' · '}</>;
+}
+
+/*
+ * A small variation of the BlogPostItemHeaderInfo. It's done
+ * to include the event info, if available, in this component.
+ */
+export default function BlogPostItemHeaderInfo({
+  className,
+}: Props): JSX.Element {
+  const { frontMatter, metadata } = useBlogPost();
+  const { date, formattedDate, readingTime } = metadata;
+  const { event } = frontMatter as BlogPostFrontMatterExpanded;
+
+  return (
+    <div className={`${styles.container} margin-vert--md ${className}`}>
+      {event && (
+        <>
+          {event}
+          <Spacer />
+        </>
+      )}
+      <Date date={date} formattedDate={formattedDate} />
+      {typeof readingTime !== 'undefined' && (
+        <>
+          <Spacer />
+          <ReadingTime readingTime={readingTime} />
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/src/theme/BlogPostItem/Header/Info/styles.module.css b/src/theme/BlogPostItem/Header/Info/styles.module.css
new file mode 100644
index 00000000..27d569e0
--- /dev/null
+++ b/src/theme/BlogPostItem/Header/Info/styles.module.css
@@ -0,0 +1,3 @@
+.container {
+  font-size: 0.9rem;
+}
diff --git a/src/theme/BlogPostItem/Header/Link/index.tsx b/src/theme/BlogPostItem/Header/Link/index.tsx
new file mode 100644
index 00000000..f888c208
--- /dev/null
+++ b/src/theme/BlogPostItem/Header/Link/index.tsx
@@ -0,0 +1,31 @@
+import React from 'react';
+
+import { BlogPostFrontMatter } from '@docusaurus/plugin-content-blog';
+import { useBlogPost } from '@docusaurus/theme-common/internal';
+import Link from '@docusaurus/Link';
+
+interface BlogPostFrontMatterExpanded extends BlogPostFrontMatter {
+  link: string;
+}
+
+/*
+ * An additional component to show the image of a post
+ */
+export default function BlogPostItemHeaderLink(): JSX.Element | null {
+  const blogPostContextValue = useBlogPost();
+  const { link } =
+    blogPostContextValue.frontMatter as BlogPostFrontMatterExpanded;
+  const { title } = blogPostContextValue.metadata;
+
+  if (!link) {
+    return null;
+  }
+
+  return (
+    <div className="text--bold margin-bottom--md">
+      <Link href={link} title={title}>
+        {title}
+      </Link>
+    </div>
+  );
+}
diff --git a/src/theme/BlogPostItem/Header/index.tsx b/src/theme/BlogPostItem/Header/index.tsx
index 26e3147b..53e08add 100644
--- a/src/theme/BlogPostItem/Header/index.tsx
+++ b/src/theme/BlogPostItem/Header/index.tsx
@@ -6,15 +6,17 @@ import BlogPostItemHeaderAuthors from '@theme/BlogPostItem/Header/Authors';
 // Additional components imports, set here for convenience
 import BlogPostItemHeaderTags from '@theme/BlogPostItem/Header/Tags';
 import BlogPostItemHeaderImage from '@theme/BlogPostItem/Header/Image';
+import BlogPostItemHeaderLink from '@theme/BlogPostItem/Header/Link';
 
 export default function BlogPostItemHeader(): JSX.Element {
   return (
-    <header className="text--center margin-bottom--lg">
+    <header className="text--center margin-bottom--md">
       <BlogPostItemHeaderTitle />
       <BlogPostItemHeaderAuthors />
       <BlogPostItemHeaderInfo />
       <BlogPostItemHeaderTags />
       <BlogPostItemHeaderImage />
+      <BlogPostItemHeaderLink />
     </header>
   );
 }