Functional architecture - The pits of success - Mark Seemann

His videos about functional programming are amazing (Mark Seemann). "Pit of success" is one of the best. ▶ this video

in “Habits of Expert Software Designers (2019)” · View on HN

I spend a lot of time thinking about these sorts of topics (actually, I just taught a 4 hour session yesterday that used most of the terms in this article), working with newer, less experienced developers, and trying to figure how to distill the essence of "architecture" down to something simple that everyone can start with. This is what I’ve started telling people: Use mostly functions, try to make most of them pure. I think that can get people (even new devs) 80% of the benefits (testability, composability, loose coupling, and the ability to reason about code) of more complicated, prescriptive architectures (Hexagonal, Onion, Ports & Adapters, Clean, etc) with a minimal amount of ramp up. Of course, this isn't the solution to every problem (it obviously depends on the domain you are working in, for me its webDev and backends), but I think maybe its a good way for people to start. Edit: Here is a great talk demonstrating that by following a simple functional approach, your code can naturally fall into a “pit of success”: ▶ this video

in “A Theory of Software Architecture” · View on HN

"pit of success" from the previous comment might refer to this video, which is long but good especially to adjust to a different mindset ▶ this video

in “Why F#?” · View on HN

Mark Seemann has a good talk on this called the "functional pits of success" -> ▶ this video Of all the languages I've used nothing is quite as fun as refactoring an F# app down to nothing. Expressive power is king in F# with the whole .NET ecosystem behind it.

in “F# Good and Bad” · View on HN

> So while FP is just another tool, it's also a framework for thinking that helps people make better choices I’ve been getting more into functional programming this past year (via Clojure, though my day-job is mostly JavaScript/TypeScript) and this is the big takeaway for me. Type theory and monads may have their place, but thinking about separating logic from side-effects is, I think, the most valuable aspect of functional programming. That is a thought process that you can apply in pretty much any language that will give you the biggest bang for your buck. Edit: Here’s some great examples of the benefits of functional thinking without going off the deep end. 1. Boundaries by Gary Bernhardt - [link] 2. Pits of Success by Mark Seemann - ▶ this video 3. Grokking Simplicity by Eric Normand - [link]

in “Software engineering topics I changed my mind on” · View on HN

The goal is that everything in the core is pure data types and functions. Now, depending on your problem domain, your core can be small or huge compared to the shell. Your question was all about IO/effects. They are impure and belong to the shell. If what you work on does mostly IO then you will have a lot of impure code lying around by definition. Still, the idea is that you should keep the amount of time spent in impure land minimal, ie. drop into pure structures/computation as soon as possible during program execution and only dip out of on occasions when you have to do IO. Here is a good talk about these ideas: ▶ this video

in “Functional core, imperative shell (2012)” · View on HN