Better control over flow of our application: more ways to add branching

bind applies unwrapped Success value to the block, which should return a Result object. No-op on Failure

It allows us to reuse steps

The Result object that we pass around keeps accumulating data and becomes enormous, so we have to use **rest in our function signatures

The DSL has a weaker control over the program’s flow — we can’t have conditions unless we add a special step

However, you don’t need to have an extensive knowledge of monads to use ROP in your code.

Railway Oriented Programming comes from functional programming, so it is tightly related to the usual FP concepts like monads, composition, and many others.

I want to emphasize that Result is just an alternative name for the Either monad.

One can say this code is opaque compared to the previous example but keep in mind that in real code it often happens to call methods returning Maybe values.

this implies direct work with nil-able values which may end up with errors.

To get the final value you can use value_or which is a safe way to unwrap a nil-able value.

In other words, once you've used Maybe you cannot hit nil with a missing method. This is remarkable because even &. doesn't save you from omitting || "No state" at the end of the computation. Basically, that's what they call "Type Safety".

Writing code in this style is tedious and error-prone.

Another solution is using the Safe Navigation Operator &. introduced in Ruby 2.3 which is a bit better because this is a language feature rather than an opinionated runtime environment pollution

However, some people think these solutions are hacks and the problem reveals a missing abstraction.

It's hard to say why people think so because you certainly don't need to know category theory for using them, just like you don't need it for, say, using functions.

The gem was inspired by the Kleisli gem.

Monads provide an elegant way of handling errors, exceptions and chaining functions so that the code is much more understandable and has all the error handling, without all the ifs and elses.

built using nullary type constructors

Also, in non-functional programming, a function without arguments can be meaningful and not necessarily constant (due to side effects).

The latter are important examples which usually also exist in "purely" functional programming languages.

Often, such functions have in fact some hidden input which might be global variables, including the whole state of the system (time, free memory, …).

Though rarer in computer science, one can use category theory directly, which defines a monad as a functor with two additional natural transformations. So to begin, a structure requires a higher-order function (or "functional") named map to qualify as a functor:

For historical reasons, this map is instead called fmap in Haskell.

can transform monadic values m a applying f to the unwrapped value a

In fact, the Product comonad is just the dual of the Writer monad and effectively the same as the Reader monad (both discussed below)

procedure to wrap values of any basic type within the monad (yielding a monadic value)

A combinator, typically called bind (as in binding a variable) and represented with an infix operator >>=, that unwraps a monadic variable, then inserts it into a monadic function/expression, resulting in a new monadic value:(mx >>= f) : (M T, T → M U) → M U

A type constructor M that builds up a monadic type M T

A type converter, often called unit or return, that embeds an object x in the monad:.mw-parser-output .block-indent{padding-left:3em;padding-right:0;overflow:hidden}unit(x) : T → M T

allows monads to simplify a wide range of problems

another to compose functions that output monadic values (called monadic functions)

Monads achieve this by providing their own data type (a particular type for each type of monad), which represents a specific form of computation

In functional programming, a monad is an abstraction that allows structuring programs generically

Supporting languages may use monads to abstract away boilerplate code needed by the program logic.

Whatever language or default programming paradigm a developer uses, following the monad pattern brings many of the benefits of purely functional programming.

By reifying a specific kind of computation, a monad not only encapsulates the tedious details of that computational pattern, but it does so in a declarative way, improving the code's clarity.

category of functors (from values to computations)

To emphasize how Just acts on the underlying value by wrapping it, it can be redefined as a function too, called eta for now

With >>= available, add can now be redefined as something much more compact:

these two functions >>= and eta were designed to simplify add, but they clearly do not depend on the specifics of add in any way, just the Maybe type

While other monads will embody different logical processes, and some may have extra properties, all of them will have three similar components (directly or indirectly) that follow the basic outline of this example.

Maybe T can be understood as a "wrapping" type, wrapping the type T into a new type with built-in exception handling

This is done to avoid confusion by differentiating between cases where a variable carries a defined value and those where it does not.

Undefined values or operations are one particular problem that robust software should prepare for and handle gracefully.

Since monads make semantics explicit for a kind of computation, they can also be used to implement convenient language features.

Research beginning in the late 1980s and early 1990s established that monads could bring seemingly disparate computer-science problems under a unified, functional model.

handling potential undefined values (with the Maybe monad)

The exception can be avoided by using ? operator on the nullable value instead:

The @ ? annotation can be used to denote a nullable value.

It reminds us that rather than asking an object for data and acting on that data, we should instead tell an object what to do.

It’s definitely better than littering our code with endless if-statements.

As you can see, we end up with a lot of boilerplate if-statements. The code is more verbose. And it’s difficult to follow the main logic.

In JavaScript, we have a built-in language feature for dealing with exceptions. We wrap problematic code in a try…catch statement. This lets us write the ‘happy path’ in the try section, and then deal with any exceptions in the catch section. And this is not a bad thing. It allows us to focus on the task at hand, without having to think about every possible error that might occur.

And they are not the only way to handle errors.

In this article, we’ll take a look at using the ‘Either monad’ as an alternative to try...catch.

The .chain() method allows us to switch over to the left track if an error occurs. Note that the switches only go one way.

This stuff is intoxicating once you get into it.

Don’t worry if you get confused at first. Everyone does. I’ve listed some other references at the end that may help. But don’t give up.

And a word of warning. If you haven’t come across things like monads before, they might seem really… different. Working with tools like these takes a mind shift. And that can be hard work to start with.

polymorphic method inside shape class, its possible to discriminate them. without if’s.

Since an inverse is the contrapositive of the converse, inverse and converse are logically equivalent to each other.

In logic and mathematics, statements p {\displaystyle p} and q {\displaystyle q} are said to be logically equivalent if they are provable from each other under a set of axioms,[1] or have the same truth value in every model.

So every program starts in the IO monad. From here you can get any input you need, call into relatively "pure" code with the inputs, and then output the result in some way. The reverse does not work. You cannot call into IO code from pure code like you can call into a Maybe function from pure code.

The IO monad wraps computations in the following context: "This computation can read information from or write information to the terminal, file system, operating system, and/or network". If you want to get user input, print a message to the user, read information from a file, or make a network call, you'll need to do so within the IO Monad. These are "side effects". We cannot perform them from "pure" Haskell code.

A Monad wraps a value or a computation with a particular context. A monad must define both a means of wrapping normal values in the context, and a way of combining computations within the context.

So if you don't yet understand functors or applicative functors, check out part 1 and part 2 of this series!

Each of the programming language generations aims to provide a higher level of abstraction of the internal computer hardware details, making the language more programmer-friendly, powerful, and versatile.

It turns out that, given a set of constraints defining a particular problem, deriving an efficient algorithm to solve it is a very difficult problem in itself. This crucial step cannot yet be automated and still requires the insight of a human programmer.

Purely functional programming may also be defined by forbidding state changes and mutable data.

purely functional programming usually designates a programming paradigm—a style of building the structure and elements of computer programs—that treats all computation as the evaluation of mathematical functions.

Purely functional data structures are persistent. Persistency is required for functional programming; without it, the same computation could return different results.

Most C++ template idioms will carry over to D without alteration, but D adds some additional functionality

it is inconvenient to write specific implementations for each datatype contained, especially if the code for each datatype is virtually identical. For example, in C++, this duplication of code can be circumvented by defining a class template

Comparison to imperative languages

In mathematics, a structure is a set endowed with some additional features on the set (e.g. an operation, relation, metric, or topology)

This is a useful approach to error handling, but please don’t take it to extremes! See my post on “Against Railway-Oriented Programming”.

Modelling the flow of a program where chunks of code are executed in a certain order, with a successful “happy path” and an “error-out” path is called a Railway. It popped up in functional languages

Intuitively, you understand the flow just by looking at the BPMN diagram. And, heck, we haven’t even discussed BPMN or any terminology, yet!

If anything here did fail in “validate omniauth”, all other steps in the chain would be skipped as the flow would follow the path leading to the failure terminus.

Things could go wrong in two places here. First, the validation could fail if Github sends us data we don’t understand. Second, we might not know the user signing in, meaning the “find user” logic has to error-out

Whatever data from the outside is needed in the activity has to be passed explicitely into the activity’s call method.

In other words: the controllers usually contain only routing and rendering code and dispatch instantly to a particular operation/activity class.

At this stage, routing, controllers, etc is irrelevant. Just imagine a Rails controller action, a Sinatra router or a Hanami action as follows.

They help streamlining the control flow, and take away control code while providing you with an incredibly cool developer experience.

Activities are a necessary abstraction on top of Ruby.

provide interfaces so you don’t have to think about them

You’re allowed to blame us for a terrible developer experience in Trailblazer 2.0. It’s been quite painful to find out which step caused an exception. However, don’t look back in anger! We’ve spent a lot of time on working out a beautiful way for both tracing and debugging Trailblazer activities in 2.1.

An activity is a high-level concept to structure code flow

Trailblazer is an architectural pattern that comes with Ruby libraries to implement that pattern.

Whether this is the life-cycle of a <user> entity or just a sign-up function, it has to be defined and coded somewhere.

Trailblazer strikes when it comes to organizing business code.

Back to what railway oriented programming really is. Below is a visual representation of what this looks like:

One thing I really like about this style is the elegance and readability it provides to your codebase.

This style of error handling uses monadic behavior — a substitute way of handling errors.

on one of the most popular websites of F #

This is the most popular article “railway oriented programming” on one of the most popular websites of F #.

No contribution is too small Even if you find a single-character typo, we're happy to take the change! Although the codebase can feel daunting for beginners, we and other contributors are happy to help you along.

An operation has two invocation styles. This is the only difference to an Activity.

Operations are often confused as god objects that do “everything”. However, operations are nothing but orchestrators.

Here comes a sample screenshot.

The activity gem is an extraction from Trailblazer 2.0, where we only had operations. Operations expose a linear flow which goes into one direction, only. While this was a massive improvement over messily nested code, we soon decided it’s cool being able to model non-linear flows. This is why activities are the major concept since Trailblazer 2.1.

Feel free to pick and choose what you need for your applications.

I started Trailblazer GmbH 4 years ago with my relocation from Australia back to Europe. One of our consulting clients is the central police department of a German state that has kept me busy for more than three years now.

In addition to the organically formed core team

Endpoint is the missing link between your routing (Rails, Hanami, …) and the “operation” to be called. It provides standard behavior for all cases 404, 401, 403, etc and lets you hook in your own logic like Devise or Tyrant authentication, again, using TRB activity mechanics.

TRAILBLAZER-WORKFLOW is another dream ‘o mine come true. It allows creating long-term processes (or state machines) based on BPMN diagrams that can be modeled using our editor.

Not only does it help to structure myself,

TRAILBLAZER-TEST The official stable release is only weeks away bringing you a bunch of new assertions that drastically reduce coding effort for tests! Of course, Minitest and RSpec will both be supported. TRAILBLAZER-STORY will follow as it turned out to be inevitable for setting up application state for tests. Instead of fumbling around with factories and traits in your tests, you “tell a story” about what to create in which order, easily customizable, and all written using activities. Currently, I’m working on designing the interfaces and it’s real fun!

In the past 1 ½ years something weird happened: a real core team formed around the Trailblazer gems. I say “real” because in the past 15 years of OSS, I’ve had people come and go, being of great help but never staying and taking over long-term responsibilities - which I found to be the pivotal element of a core team. Eventually, those kids convinced me to start the Trailblazer organization on Github and move over all “apotonick gems”. Over the course of time, I saw myself giving away that aforementioned responsibility with a smile on my face, adding owners and collaborators to gems, yes, even giving away entire gems, letting people work on documentation and just trusting someone and their skills. I have no words to describe how good that feels!

I work with crazy geniuses who share many of my opinions (not all, and that’s good).

For me, a dream has come true. I work with crazy geniuses who share many of my opinions

Messages like “don’t worry, I’ll do it” combined with a pull requests minutes later - things I literally dreamed of a few years ago, are now part of my daily routine.

I learned to “let go” and simply trust others to maintain certain gem suites.

Around 2 years ago I decided to end the experiment of “TRB PRO” as I felt I didn’t provide enough value to paying users. In the end, we had around 150 companies and individuals signed up, which was epic and a great funding source for more development.

The legendary cfp-app will become a Rails-to-TRB refactoring tutorial.

We decided against paid documentation, so all will be freely available on our shiny new website.

What this means is: I better refrain from writing a new book and we rather focus on more and better docs.

We’re now relaunching PRO, but instead of a paid chat and (never existing) paid documentation, your team gets access to paid gems, our visual editor for workflows, and a commercial license.

There are two definitions of ‘Enterprise’ 1 - Enterprise as a business. In fact, in French, ‘enterprise’ literally means ‘business’ 2- Enterprise as a large business. This is the most common use of the term in business, differentiating between small, medium, and large businesses. In this context, there is no official rule, however it is generally accepted for enterprise to mean companies with over 1,000 employees and/or $1B in revenue

This would be the taxonomy:

Our company reinvests our funds straight back into developing all Trailblazer gems, better documentation and support, plus building up a nice team of fantastic people to help you with Trailblazer.

would love to hear from you if you’re excited about our gems, high-level abstractions and improving our documentation

We’re actively looking to grow this team and would love to hear from you

And: we will never stop innovating.

which entails computer programming (process of writing and maintaining the source code), but also encompasses a planned and structured process from the conception of the desired software to its final manifestation

Software architecture is about making fundamental structural choices that are costly to change once implemented.

Software architecture refers to the fundamental structures of a software system

The adapter is where authentication, policy checks, and eventually your domain logic happen. All termini of the protocol’s activity are standardized end events - that’s how protocol and adapter communicate.

An endpoint links your routing with your business code. The idea is that your controllers are pure HTTP routers, calling the respective endpoint for each action. From there, the endpoint takes over, handles authentication, policies, executing the domain code, interpreting the result, and providing hooks to render a response.

The endpoint gem is the missing link between your routing framework and your business code. It acts like a mix of before_filters and “responder” that handles authentication and authorization, invoking your actual logic, and rendering a response.

Instead of dealing with a mix of before_filters, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.

providing best practices for both HTML-rendering controllers and APIs.

While routing and redirecting/rendering still happens in Rails, all remaining steps are handled in the endpoint.

their main intent is to reduce fuzzy controller code

Tyrant "Freedom choked in dread we live, since tyrant was enthroned."

The trailblazer-workflow gem is currently a paid feature.

They do not maintain a to-do list (mentally or physically).

I am a delegation junkie. Whenever possible, I assign tasks and responsibilities originally assigned to me onto others.

In the classroom, I delegate responsibilities to my students at a rate that astounds people. There is almost nothing that I will not allow my students to do, including teaching my lessons whenever possible. My students take full and complete ownership of the classroom, whether they like it or not, and as a result, they possess great ownership of their learning.

If you ask my former students, they will tell you that as a teacher, my goal is to do nothing. I dream of the day when I can sit at my desk, feet propped up, reading a book, while the classroom bursts with activity and learning around me.

They cannot accept any less than 100 percent of their expectations being met.

They fail to recognize the value of an initial investment of time in future productivity.

They fail to understand the importance of autonomy when delegating responsibilities.

They lack faith in the capacity of others.

They possess an unwavering belief in “one right way.”

I admit, I was a bit cynical -- I mean, how much can what I scribble on the back of a used envelope really change my life?

’ve had Paula Rizzo’s book, Listful Thinking: Using Lists to be More Productive, Highly Successful and Less Stressed, on my to-read list (see what I did there?)

Self-referential statements are sometimes paradoxical, and can also be considered recursive.

This text wound up founding the discipline which we today call "metaphysics", and one way to describe what this subject encompasses is that it covers things at a level of abstraction above physics.

a documentary is a meta movie, no question about it

Any "rising above" is meta. When works do it about themselves, that of course is meta as well: the specific kind of meta which is self-referential (what Hostadter calls a Strange Loop. BTW, do you know what Hofstadter's motto is? "I'm So Meta, Even This Acronym")

One of the most difficult transitions for leaders to make is the shift from doing to leading.

The upper limit of what’s possible will increase only with each collaborator you empower to contribute their best work to your shared priorities.

In the short term you may have the stamina to get up earlier, stay later, and out-work the demands you face. But the inverse equation of shrinking resources and increasing demands will eventually catch up to you, and at that point how you involve others sets the ceiling of your leadership impact.

One of the main reasons to work with components is re-usability and portability, but also a delegation of responsibilities. Adding a component should be as easy as simply adding the component without having to know the inner workings (or markup) of this component. A consumer should only be aware of the properties, methods and events of a component. In order to style a child component one has to be aware of the markup as well, which violates this 'delegation of responsibility'-principle.

"Open access" refers to toll-free or gratis access to content

Open access refers to online research outputs that are free of all restrictions on access (e.g. access tolls) and free of many restrictions on use (e.g. certain copyright and license restrictions).

A free cultural work (free content) is, according to the definition of Free Cultural Works, one that has no significant legal restriction on people's freedom to: use the content and benefit from using it, study the content and apply what is learned, make and distribute copies of the content, change and improve the content and distribute these derivative works.

Free content encompasses all works in the public domain and also those copyrighted works whose licenses honor and uphold the freedoms mentioned above.

Because the Berne Convention in most countries by default grants copyright holders monopolistic control over their creations, copyright content must be explicitly declared free, usually by the referencing or inclusion of licensing statements from within the work.

A free cultural work (free content) is, according to the definition of Free Cultural Works, one that has no significant legal restriction on people's freedom to:

A free content, libre content, or free information, is any kind of functional work, work of art, or other creative content that meets the definition of a free cultural work.

The Definition of Free Cultural Works is a definition of free content from 2006. The project evaluates and recommends compatible free content licenses.

In this continuum of community participation covered by CBD, new-generation CDD projects are located at the extreme right

However, CDD projects fit on the empowerment end of CBD by actively engaging beneficiaries in the design, management and implementation of projects

a framework containing the basic assumptions, ways of thinking, and methodology that are commonly accepted by members of a scientific community. such a cognitive framework shared by members of any discipline or group:

A freemium model is sometimes used to build a consumer base when the marginal cost of producing extra units is low.

In the telecommunications industry, on a conceptual level, value-added services add value to the standard service offering, spurring subscribers to use their phone more and allowing the operator to drive up their average revenue per user.

For mobile phones, technologies like SMS, MMS and data access were historically usually considered value-added services, but in recent years SMS, MMS and data access have more and more become core services, and VAS therefore has begun to exclude those services.

A distinction may also be made between standard (peer-to-peer) content and premium-charged content.