41554 blogs · [ { "id": "01a0e4b4-286f-7111-a3e2-523786477142", "title": "I’m a Refugee", "url": "https://bartoszmilewski.com/2017/02/01/im-a-refugee/", "published_at": "2017-02-01T17:30:03+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523786eda2f4", "title": "Comonads", "url": "https://bartoszmilewski.com/2017/01/02/comonads/", "published_at": "2017-01-02T21:15:10+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523786f2973d", "title": "Monads Categorically", "url": "https://bartoszmilewski.com/2016/12/27/monads-categorically/", "published_at": "2016-12-27T18:49:38+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523787ae3639", "title": "Monads and Effects", "url": "https://bartoszmilewski.com/2016/11/30/monads-and-effects/", "published_at": "2016-11-30T21:21:23+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523787db118f", "title": "Monads: Programmer’s Definition", "url": "https://bartoszmilewski.com/2016/11/21/monads-programmers-definition/", "published_at": "2016-11-22T07:29:28+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523787edd0b3", "title": "Lenses: Yoneda with Adjunctions", "url": "https://bartoszmilewski.com/2016/09/06/lenses-yoneda-with-adjunctions/", "published_at": "2016-09-06T16:03:04+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-52378867b914", "title": "Profunctor Polymorphism", "url": "https://bartoszmilewski.com/2016/08/16/profunctor-polymorphism/", "published_at": "2016-08-17T03:25:19+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523788d41de3", "title": "Impoverished Categories", "url": "https://bartoszmilewski.com/2016/07/27/impoverished-categories/", "published_at": "2016-07-28T04:52:51+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-5237896b8f65", "title": "Profunctors as Relations", "url": "https://bartoszmilewski.com/2016/07/25/profunctors-as-relations/", "published_at": "2016-07-25T19:45:35+00:00" }, { "id": "01a0e4b4-286f-7111-a3e2-523789bb83de", "title": "Free/Forgetful Adjunctions", "url": "https://bartoszmilewski.com/2016/06/15/freeforgetful-adjunctions/", "published_at": "2016-06-15T14:39:26+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c7306752", "title": "Adjunctions", "url": "https://bartoszmilewski.com/2016/04/18/adjunctions/", "published_at": "2016-04-18T19:51:16+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c776e1f3", "title": "The New JDI! Language", "url": "https://bartoszmilewski.com/2016/04/01/the-new-jdi-language/", "published_at": "2016-04-01T22:35:08+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c864024c", "title": "Tambara Modules", "url": "https://bartoszmilewski.com/2016/01/21/tambara-modules/", "published_at": "2016-01-21T17:58:03+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c893c232", "title": "It’s All About Morphisms", "url": "https://bartoszmilewski.com/2015/11/17/its-all-about-morphisms/", "published_at": "2015-11-17T17:47:56+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c8c419b5", "title": "Yoneda Embedding", "url": "https://bartoszmilewski.com/2015/10/28/yoneda-embedding/", "published_at": "2015-10-28T18:57:06+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c9688c3c", "title": "Operads, Type Level Nats, and Tic-Tac-Toe", "url": "https://bartoszmilewski.com/2015/10/07/operads-type-level-nats-and-tic-tac-toe/", "published_at": "2015-10-07T09:43:59+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c9acf59d", "title": "The Yoneda Lemma", "url": "https://bartoszmilewski.com/2015/09/01/the-yoneda-lemma/", "published_at": "2015-09-01T17:45:38+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855c9f79e45", "title": "Representable Functors", "url": "https://bartoszmilewski.com/2015/07/29/representable-functors/", "published_at": "2015-07-29T13:09:25+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855ca9d9d58", "title": "Free Monoids", "url": "https://bartoszmilewski.com/2015/07/21/free-monoids/", "published_at": "2015-07-21T13:08:08+00:00" }, { "id": "01a0e4c3-2c78-7280-ae9e-9855cad153a0", "title": "From Lenses to Yoneda Embedding", "url": "https://bartoszmilewski.com/2015/07/13/from-lenses-to-yoneda-embedding/", "published_at": "2015-07-13T14:55:25+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95ad29f81", "title": "Using Monads in C++ to Solve Constraints: 4. Refactoring", "url": "https://bartoszmilewski.com/2015/05/25/using-monads-in-c-to-solve-constraints-4-refactoring/", "published_at": "2015-05-25T10:01:18+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95bc973b8", "title": "Using Monads in C++ to Solve Constraints: 3. The Tale of Two Monads", "url": "https://bartoszmilewski.com/2015/05/18/using-monads-in-c-to-solve-constraints-3-the-tale-of-two-monads/", "published_at": "2015-05-18T14:09:34+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95c0dfb2e", "title": "Using Monads in C++ to Solve Constraints: 2. The State Monad", "url": "https://bartoszmilewski.com/2015/05/14/using-monads-in-c-to-solve-constraints-2-the-state-monad/", "published_at": "2015-05-14T14:54:01+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95cd93efe", "title": "Using Monads in C++ to Solve Constraints: 1. The List Monad", "url": "https://bartoszmilewski.com/2015/05/11/using-monads-in-c-to-solve-constraints-1-the-list-monad/", "published_at": "2015-05-11T16:09:09+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95d0a3516", "title": "Category Theory and Declarative Programming", "url": "https://bartoszmilewski.com/2015/04/15/category-theory-and-declarative-programming/", "published_at": "2015-04-15T11:55:26+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95d7693ab", "title": "Limits and Colimits", "url": "https://bartoszmilewski.com/2015/04/15/limits-and-colimits/", "published_at": "2015-04-15T06:46:49+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95e09159c", "title": "Natural Transformations", "url": "https://bartoszmilewski.com/2015/04/07/natural-transformations/", "published_at": "2015-04-07T15:50:30+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95e56b2f0", "title": "Orange Mazurka", "url": "https://bartoszmilewski.com/2015/04/04/orange-mazurka/", "published_at": "2015-04-04T13:53:45+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95f569a5d", "title": "Function Types", "url": "https://bartoszmilewski.com/2015/03/13/function-types/", "published_at": "2015-03-13T12:08:01+00:00" }, { "id": "01a0e4ce-ac76-7133-8918-60d95f8f5e3f", "title": "Functoriality", "url": "https://bartoszmilewski.com/2015/02/03/functoriality/", "published_at": "2015-02-03T16:39:01+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a62365428cf7", "title": "Functors", "url": "https://bartoszmilewski.com/2015/01/20/functors/", "published_at": "2015-01-20T16:44:00+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a6236577d6b7", "title": "Simple Algebraic Data Types", "url": "https://bartoszmilewski.com/2015/01/13/simple-algebraic-data-types/", "published_at": "2015-01-13T16:48:54+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a6236586396f", "title": "Products and Coproducts", "url": "https://bartoszmilewski.com/2015/01/07/products-and-coproducts/", "published_at": "2015-01-07T15:21:03+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a623665f4cd2", "title": "Kleisli Categories", "url": "https://bartoszmilewski.com/2014/12/23/kleisli-categories/", "published_at": "2014-12-23T17:49:09+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a62366dc029e", "title": "Categories Great and Small", "url": "https://bartoszmilewski.com/2014/12/05/categories-great-and-small/", "published_at": "2014-12-05T12:36:02+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a623675b68a6", "title": "Types and Functions", "url": "https://bartoszmilewski.com/2014/11/24/types-and-functions/", "published_at": "2014-11-24T16:50:54+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a62367e03c9f", "title": "Formula 1: Go Functional!", "url": "https://bartoszmilewski.com/2014/11/12/formula-1-go-functional/", "published_at": "2014-11-12T16:55:53+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a623681a706b", "title": "Category: The Essence of Composition", "url": "https://bartoszmilewski.com/2014/11/04/category-the-essence-of-composition/", "published_at": "2014-11-04T16:25:05+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a62368904f47", "title": "Category Theory for Programmers: The Preface", "url": "https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/", "published_at": "2014-10-28T14:57:50+00:00" }, { "id": "01a0e4dc-c2bb-7203-94ce-a62368e9b2d7", "title": "Dealing with Benign Data Races the C++ Way", "url": "https://bartoszmilewski.com/2014/10/25/dealing-with-benign-data-races-the-c-way/", "published_at": "2014-10-25T14:53:14+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a0e2a915", "title": "C++ Ranges are Pure Monadic Goodness", "url": "https://bartoszmilewski.com/2014/10/17/c-ranges-are-pure-monadic-goodness/", "published_at": "2014-10-17T13:18:46+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a1d0eed7", "title": "Benign Data Races", "url": "https://bartoszmilewski.com/2014/10/01/benign-data-races-2/", "published_at": "2014-10-01T14:54:38+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a1e3d65c", "title": "How to Get Enriched over Magmas and Monoids", "url": "https://bartoszmilewski.com/2014/09/29/how-to-get-enriched-over-magmas-and-monoids/", "published_at": "2014-09-29T09:53:49+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a22f865f", "title": "Parametricity: Money for Nothing and Theorems for Free", "url": "https://bartoszmilewski.com/2014/09/22/parametricity-money-for-nothing-and-theorems-for-free/", "published_at": "2014-09-22T07:11:40+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a2d70818", "title": "Natural Transformations and Ends", "url": "https://bartoszmilewski.com/2014/07/15/natural-transformations-and-ends/", "published_at": "2014-07-15T19:18:51+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a3cf64a4", "title": "Exponentials, Currying, and Universal Constructions", "url": "https://bartoszmilewski.com/2014/06/17/exponentials-currying-and-universal-constructions/", "published_at": "2014-06-17T18:27:15+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a4b4984b", "title": "The Functional Revolution in C++", "url": "https://bartoszmilewski.com/2014/06/09/the-functional-revolution-in-c/", "published_at": "2014-06-09T17:36:34+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a5965ce0", "title": "Understanding Limits", "url": "https://bartoszmilewski.com/2014/05/08/understanding-limits-2/", "published_at": "2014-05-08T19:46:43+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a61427a8", "title": "Understanding Products and Universal Constructions", "url": "https://bartoszmilewski.com/2014/05/05/understanding-products-and-universal-constructions/", "published_at": "2014-05-05T18:21:21+00:00" }, { "id": "01a0e4ee-4f05-7019-9a12-bb06a6e7e7f7", "title": "Getting Lazy with C++", "url": "https://bartoszmilewski.com/2014/04/21/getting-lazy-with-c/", "published_at": "2014-04-21T18:32:30+00:00" }, { "id": "01a0e503-791b-70da-8880-abf490e895d8", "title": "C++17: I See a Monad in Your Future!", "url": "https://bartoszmilewski.com/2014/02/26/c17-i-see-a-monad-in-your-future/", "published_at": "2014-02-26T18:59:29+00:00" }, { "id": "01a0e503-791b-70da-8880-abf491b3bb9e", "title": "You Can’t Make an Algebra without Breaking a Few Eggs", "url": "https://bartoszmilewski.com/2014/01/28/you-cant-make-an-algebra-without-breaking-a-few-eggs/", "published_at": "2014-01-28T19:06:11+00:00" }, { "id": "01a0e503-791b-70da-8880-abf4927fd238", "title": "Functional Data Structures in C++: Leftist Heaps", "url": "https://bartoszmilewski.com/2014/01/21/functional-data-structures-in-c-leftist-heaps/", "published_at": "2014-01-21T17:55:14+00:00" }, { "id": "01a0e503-791b-70da-8880-abf49289c7bf", "title": "Functors are Containers", "url": "https://bartoszmilewski.com/2014/01/14/functors-are-containers/", "published_at": "2014-01-14T17:40:27+00:00" }, { "id": "01a0e503-791b-70da-8880-abf492a8ee79", "title": "2013 in review", "url": "https://bartoszmilewski.com/2013/12/31/2013-in-review/", "published_at": "2013-12-31T18:34:47+00:00" }, { "id": "01a0e503-791b-70da-8880-abf49310101f", "title": "Understanding Free Monoids and Universal Constructions", "url": "https://bartoszmilewski.com/2013/12/21/understanding-free-monoids-and-universal-constructions/", "published_at": "2013-12-21T17:58:10+00:00" }, { "id": "01a0e503-791b-70da-8880-abf49334983a", "title": "Functional Data Structures and Concurrency in C++", "url": "https://bartoszmilewski.com/2013/12/10/functional-data-structures-and-concurrency-in-c/", "published_at": "2013-12-10T17:36:04+00:00" }, { "id": "01a0e503-791b-70da-8880-abf49404b4da", "title": "Functional Data Structures in C++: Trees", "url": "https://bartoszmilewski.com/2013/11/25/functional-data-structures-in-c-trees/", "published_at": "2013-11-25T17:47:06+00:00" }, { "id": "01a0e503-791b-70da-8880-abf4944e68d5", "title": "Functional Data Structures in C++: Lists", "url": "https://bartoszmilewski.com/2013/11/13/functional-data-structures-in-c-lists/", "published_at": "2013-11-13T19:14:58+00:00" }, { "id": "01a0e503-791b-70da-8880-abf494eae4ba", "title": "Lenses, Stores, and Yoneda", "url": "https://bartoszmilewski.com/2013/10/08/lenses-stores-and-yoneda/", "published_at": "2013-10-08T18:58:23+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba7387eeff29", "title": "Edward C++Hands", "url": "https://bartoszmilewski.com/2013/09/19/edward-chands/", "published_at": "2013-09-19T19:41:46+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738801df9b", "title": "Quantum Homotopy Computer", "url": "https://bartoszmilewski.com/2013/07/29/quantum-homotopy-computer/", "published_at": "2013-07-29T22:05:21+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba73884bc498", "title": "Basics of Haskell", "url": "https://bartoszmilewski.com/2013/06/19/basics-of-haskell/", "published_at": "2013-06-19T21:14:42+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba7388b0ad3d", "title": "Understanding F-Algebras", "url": "https://bartoszmilewski.com/2013/06/10/understanding-f-algebras/", "published_at": "2013-06-10T21:15:15+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba7389597e31", "title": "Understanding Yoneda", "url": "https://bartoszmilewski.com/2013/05/15/understanding-yoneda/", "published_at": "2013-05-15T20:04:55+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738a1036a3", "title": "Beautiful Concurrency", "url": "https://bartoszmilewski.com/2013/04/03/beautiful-concurrency/", "published_at": "2013-04-03T22:50:12+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738a350347", "title": "The Tao of Monad", "url": "https://bartoszmilewski.com/2013/03/07/the-tao-of-monad/", "published_at": "2013-03-07T19:42:21+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738a86660f", "title": "School of Haskell", "url": "https://bartoszmilewski.com/2013/01/31/school-of-haskell/", "published_at": "2013-01-31T22:48:59+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738b096b75", "title": "The Year of Haskell", "url": "https://bartoszmilewski.com/2013/01/03/the-year-of-haskell/", "published_at": "2013-01-03T21:49:00+00:00" }, { "id": "01a0e518-3344-7088-a8d9-ba738be4b2a5", "title": "Designing the Haskell IDE", "url": "https://bartoszmilewski.com/2012/11/19/designing-the-haskell-ide/", "published_at": "2012-11-19T19:00:36+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f2a0b2de", "title": "New Approach to Web Programming", "url": "https://bartoszmilewski.com/2012/10/04/new-approach-to-web-programming/", "published_at": "2012-10-04T18:40:53+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f35497cb", "title": "Ten Things You Should Know About Haskell Syntax", "url": "https://bartoszmilewski.com/2012/09/05/ten-things-you-should-know-about-haskell-syntax/", "published_at": "2012-09-05T18:55:26+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f3839dac", "title": "The Functor Pattern in C++", "url": "https://bartoszmilewski.com/2012/07/16/the-functor-pattern-in-c/", "published_at": "2012-07-16T17:12:26+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f39eb138", "title": "See my new blog…", "url": "https://bartoszmilewski.com/2012/06/20/see-my-new-blog/", "published_at": "2012-06-20T09:46:21+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f4559dde", "title": "The Future of C++ Concurrency and Parallelism", "url": "https://bartoszmilewski.com/2012/05/11/the-future-of-c-concurrency-and-parallelism/", "published_at": "2012-05-11T19:48:39+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f4b25c05", "title": "The Downfall of Imperative Programming", "url": "https://bartoszmilewski.com/2012/04/09/the-downfall-of-imperative-programming/", "published_at": "2012-04-09T20:31:20+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f5b1b500", "title": "Lang.NEXT Trip Report", "url": "https://bartoszmilewski.com/2012/04/06/lang-next-trip-report/", "published_at": "2012-04-06T18:49:54+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f68a6e19", "title": "Badass Hawking", "url": "https://bartoszmilewski.com/2012/04/05/badass-hawking/", "published_at": "2012-04-06T00:04:50+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f6d5f48a", "title": "Call Your Headhunter!", "url": "https://bartoszmilewski.com/2012/02/06/call-your-headhunter/", "published_at": "2012-02-06T18:36:53+00:00" }, { "id": "01a0e527-0883-726c-940a-8dd5f772927c", "title": "The Day the LOLcats Laughed", "url": "https://bartoszmilewski.com/2012/01/23/the-day-the-lolcats-laughed/", "published_at": "2012-01-23T17:51:58+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff13761f3", "title": "Virtual Machines: The Traps and The Thin Hypervisor", "url": "https://bartoszmilewski.com/2012/01/03/virtual-machines-the-traps-and-the-thin-hypervisor/", "published_at": "2012-01-04T06:00:47+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff21ed703", "title": "2011 in review", "url": "https://bartoszmilewski.com/2011/12/31/2011-in-review/", "published_at": "2012-01-01T02:31:33+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff21f232a", "title": "Virtual Machines: Virtualizing Virtual Memory", "url": "https://bartoszmilewski.com/2011/12/05/virtual-machines-virtualizing-virtual-memory/", "published_at": "2011-12-05T19:00:18+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff282b65e", "title": "Virtual Memory", "url": "https://bartoszmilewski.com/2011/11/28/virtual-memory/", "published_at": "2011-11-28T19:19:02+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff3337b3c", "title": "Supercomputing: An Industry in Need of a Revolution", "url": "https://bartoszmilewski.com/2011/11/21/supercomputing-an-industry-in-need-of-a-revolution/", "published_at": "2011-11-21T18:16:00+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff3cdd451", "title": "C++11 Concurrency Series: 9. Condition Variables", "url": "https://bartoszmilewski.com/2011/11/13/c11-concurrency-series-9-condition-variables/", "published_at": "2011-11-14T01:40:02+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff476b588", "title": "Supercomputing in Seattle", "url": "https://bartoszmilewski.com/2011/11/07/supercomputing-in-seattle/", "published_at": "2011-11-07T17:30:58+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff49618a3", "title": "C++11 Concurrency Series: 8. Data Races", "url": "https://bartoszmilewski.com/2011/10/31/c11-concurrency-series-8-data-races/", "published_at": "2011-10-31T17:47:51+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff4e3c42a", "title": "C++11 Concurrency Tutorial: 7. Mutex, Lock, and Monitor", "url": "https://bartoszmilewski.com/2011/10/24/c11-concurrency-tutorial-7-mutex-lock-and-monitor/", "published_at": "2011-10-24T18:06:14+00:00" }, { "id": "01a0e53c-4ccb-701a-b89a-8c3ff57283b3", "title": "C++11 Concurrency Series: 6. Map Reduce", "url": "https://bartoszmilewski.com/2011/10/17/c11-concurrency-series-6-map-reduce/", "published_at": "2011-10-17T18:02:05+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45ce3aa8a2", "title": "Async Tasks in C++11: Not Quite There Yet", "url": "https://bartoszmilewski.com/2011/10/10/async-tasks-in-c11-not-quite-there-yet/", "published_at": "2011-10-10T20:29:18+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45cf22b6f4", "title": "C++11 Concurrency Tutorial: 5. Tasks", "url": "https://bartoszmilewski.com/2011/10/03/c11-concurrency-tutorial-5-tasks/", "published_at": "2011-10-03T18:15:24+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45cf53b2ac", "title": "C++11 Concurrency Tutorial: Part 4", "url": "https://bartoszmilewski.com/2011/09/26/c11-concurrency-tutorial-part-4/", "published_at": "2011-09-26T18:27:50+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45cf8cded6", "title": "C++11 Concurrency Tutorial: 3. Sharing", "url": "https://bartoszmilewski.com/2011/09/12/c11-concurrency-tutorial-3-sharing/", "published_at": "2011-09-12T17:28:51+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45cfa87adc", "title": "C++11 Concurrency Tutorial: Part 2", "url": "https://bartoszmilewski.com/2011/09/06/c11-concurrency-tutorial-part-2/", "published_at": "2011-09-06T18:56:22+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45d00df6eb", "title": "C++11 Concurrency Tutorial", "url": "https://bartoszmilewski.com/2011/08/29/c11-concurrency-tutorial/", "published_at": "2011-08-29T16:51:31+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45d044aee4", "title": "Data Races at the Processor Level", "url": "https://bartoszmilewski.com/2011/08/15/data-races-at-the-processor-level/", "published_at": "2011-08-15T19:19:59+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45d09cbb8f", "title": "Boostcon Haskell C++ Videos", "url": "https://bartoszmilewski.com/2011/07/25/boostcon-haskell-c-videos/", "published_at": "2011-07-25T17:20:27+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45d14644e5", "title": "Monads in C++", "url": "https://bartoszmilewski.com/2011/07/11/monads-in-c/", "published_at": "2011-07-11T20:11:41+00:00" }, { "id": "01a0e554-8494-7173-8210-0c45d169451b", "title": "The Language of Concurrency Video", "url": "https://bartoszmilewski.com/2011/06/27/the-language-of-concurrency-video/", "published_at": "2011-06-27T18:18:41+00:00" } ] posts Claim your blog

Back to Bartosz Milewski

Blog · corpus.blog/blogs/bartoszmilewski.com/posts

Bartosz Milewski

bartoszmilewski.com

2017

I’m a Refugee original ↗

1 Feb 2017

Comonads original ↗

2 Jan 2017

2016

Monads Categorically original ↗

27 Dec 2016

Monads and Effects original ↗

30 Nov 2016

Monads: Programmer’s Definition original ↗

22 Nov 2016

Lenses: Yoneda with Adjunctions original ↗

6 Sept 2016

Profunctor Polymorphism original ↗

17 Aug 2016

Impoverished Categories original ↗

28 Jul 2016

Profunctors as Relations original ↗

25 Jul 2016

Free/Forgetful Adjunctions original ↗

15 Jun 2016

Adjunctions original ↗

18 Apr 2016

The New JDI! Language original ↗

1 Apr 2016

Tambara Modules original ↗

21 Jan 2016

2015

It’s All About Morphisms original ↗

17 Nov 2015

Yoneda Embedding original ↗

28 Oct 2015

Operads, Type Level Nats, and Tic-Tac-Toe original ↗

7 Oct 2015

The Yoneda Lemma original ↗

1 Sept 2015

Representable Functors original ↗

29 Jul 2015

Free Monoids original ↗

21 Jul 2015

From Lenses to Yoneda Embedding original ↗

13 Jul 2015

Using Monads in C++ to Solve Constraints: 4. Refactoring original ↗

25 May 2015

Using Monads in C++ to Solve Constraints: 3. The Tale of Two Monads original ↗

18 May 2015

Using Monads in C++ to Solve Constraints: 2. The State Monad original ↗

14 May 2015

Using Monads in C++ to Solve Constraints: 1. The List Monad original ↗

11 May 2015

Category Theory and Declarative Programming original ↗

15 Apr 2015

Limits and Colimits original ↗

15 Apr 2015

Natural Transformations original ↗

7 Apr 2015

Orange Mazurka original ↗

4 Apr 2015

Function Types original ↗

13 Mar 2015

Functoriality original ↗

3 Feb 2015

Functors original ↗

20 Jan 2015

Simple Algebraic Data Types original ↗

13 Jan 2015

Products and Coproducts original ↗

7 Jan 2015

2014

Kleisli Categories original ↗

23 Dec 2014

Categories Great and Small original ↗

5 Dec 2014

Types and Functions original ↗

24 Nov 2014

Formula 1: Go Functional!original ↗

12 Nov 2014

Category: The Essence of Composition original ↗

4 Nov 2014

Category Theory for Programmers: The Preface original ↗

28 Oct 2014

Dealing with Benign Data Races the C++ Way original ↗

25 Oct 2014

C++ Ranges are Pure Monadic Goodness original ↗

17 Oct 2014

Benign Data Races original ↗

1 Oct 2014

How to Get Enriched over Magmas and Monoids original ↗

29 Sept 2014

Parametricity: Money for Nothing and Theorems for Free original ↗

22 Sept 2014

Natural Transformations and Ends original ↗

15 Jul 2014

Exponentials, Currying, and Universal Constructions original ↗

17 Jun 2014

The Functional Revolution in C++original ↗

9 Jun 2014

Understanding Limits original ↗

8 May 2014

Understanding Products and Universal Constructions original ↗

5 May 2014

Getting Lazy with C++original ↗

21 Apr 2014

C++17: I See a Monad in Your Future!original ↗

26 Feb 2014

You Can’t Make an Algebra without Breaking a Few Eggs original ↗

28 Jan 2014

Functional Data Structures in C++: Leftist Heaps original ↗

21 Jan 2014

Functors are Containers original ↗

14 Jan 2014

2013

2013 in review original ↗

31 Dec 2013

Understanding Free Monoids and Universal Constructions original ↗

21 Dec 2013

Functional Data Structures and Concurrency in C++original ↗

10 Dec 2013

Functional Data Structures in C++: Trees original ↗

25 Nov 2013

Functional Data Structures in C++: Lists original ↗

13 Nov 2013

Lenses, Stores, and Yoneda original ↗

8 Oct 2013

Edward C++Hands original ↗

19 Sept 2013

Quantum Homotopy Computer original ↗

29 Jul 2013

Basics of Haskell original ↗

19 Jun 2013

Understanding F-Algebras original ↗

10 Jun 2013

Understanding Yoneda original ↗

15 May 2013

Beautiful Concurrency original ↗

3 Apr 2013

The Tao of Monad original ↗

7 Mar 2013

School of Haskell original ↗

31 Jan 2013

The Year of Haskell original ↗

3 Jan 2013

2012

Designing the Haskell IDE original ↗

19 Nov 2012

New Approach to Web Programming original ↗

4 Oct 2012

Ten Things You Should Know About Haskell Syntax original ↗

5 Sept 2012

The Functor Pattern in C++original ↗

16 Jul 2012

See my new blog…original ↗

20 Jun 2012

The Future of C++ Concurrency and Parallelism original ↗

11 May 2012

The Downfall of Imperative Programming original ↗

9 Apr 2012

Lang.NEXT Trip Report original ↗

6 Apr 2012

Badass Hawking original ↗

6 Apr 2012

Call Your Headhunter!original ↗

6 Feb 2012

The Day the LOLcats Laughed original ↗

23 Jan 2012

Virtual Machines: The Traps and The Thin Hypervisor original ↗

4 Jan 2012

2011 in review original ↗

1 Jan 2012

2011

Virtual Machines: Virtualizing Virtual Memory original ↗

5 Dec 2011

Virtual Memory original ↗

28 Nov 2011

Supercomputing: An Industry in Need of a Revolution original ↗

21 Nov 2011

C++11 Concurrency Series: 9. Condition Variables original ↗

14 Nov 2011

Supercomputing in Seattle original ↗

7 Nov 2011

C++11 Concurrency Series: 8. Data Races original ↗

31 Oct 2011

C++11 Concurrency Tutorial: 7. Mutex, Lock, and Monitor original ↗

24 Oct 2011

C++11 Concurrency Series: 6. Map Reduce original ↗

17 Oct 2011

Async Tasks in C++11: Not Quite There Yet original ↗

10 Oct 2011

C++11 Concurrency Tutorial: 5. Tasks original ↗

3 Oct 2011

C++11 Concurrency Tutorial: Part 4 original ↗

26 Sept 2011

C++11 Concurrency Tutorial: 3. Sharing original ↗

12 Sept 2011

C++11 Concurrency Tutorial: Part 2 original ↗

6 Sept 2011

C++11 Concurrency Tutorial original ↗

29 Aug 2011

Data Races at the Processor Level original ↗

15 Aug 2011

Boostcon Haskell C++ Videos original ↗

25 Jul 2011

Monads in C++original ↗

11 Jul 2011

The Language of Concurrency Video original ↗

27 Jun 2011