handling potential undefined values (with the Maybe monad)

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.

Trailblazer goes further and provides an approach to model entire life-cycles of business objects, such as "a song" or "the root user" using workflow (pro feature). Also, you don't have to use the DSL but can use the editor instead (cool for more complex, long-running flows).

Their high degree of encapsulation makes them a replacement for test factories, too.

Operations completely replace the need for leaky factories.

In Trailblazer, models are completely empty. They solely contain associations and finders. No business logic is allowed in models.

Operations don't know about HTTP or the environment. You could use an operation in Rails, Hanami, or Roda, it wouldn't know.

Operations encapsulate business logic and are the heart of a Trailblazer architecture.

The bare bones operation without any Trailblazery is implemented in the trailblazer-operation gem and can be used without our stack.

An operation is not just a monolithic replacement for your business code. It's a simple orchestrator between the form objects, models, your business code and all other layers needed to get the job done.

Operations define the flow of their logic using the DSL and implement the particular steps with pure Ruby.

Trailblazer extends the conventional MVC stack in Rails. Keep in mind that adding layers doesn't necessarily mean adding more code and complexity. The opposite is the case: Controller, view and model become lean endpoints for HTTP, rendering and persistence. Redundant code gets eliminated by putting very little application code into the right layer.

Trailblazer offers you a new, more intuitive file layout in applications.

Instead of grouping by technology, classes and views are structured by concept, and then by technology. A concept can relate to a model, or can be a completely abstract concern such as invoicing.

Concepts over Technology

While Trailblazer offers you abstraction layers for all aspects of Ruby On Rails, it does not missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.

Only use what you like.

Trailblazer is no "complex web of objects and indirection". It solves many problems that have been around for years with a cleanly layered architecture.

you can pick which layers you want. Trailblazer doesn't impose technical implementations

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.

And yes, at TRB GmbH, we do pay people to work on OSS

Using a terminus to indicate a certain outcome - in turn - allows for much stronger interfaces across nested activities and less guessing! For example, in the new endpoint gem, the not_found terminus is then wired to a special “404 track” that handles the case of “model not found”. The beautiful thing here is: there is no guessing by inspecting ctx[:model] or the like - the not_found end has only one meaning!

termini (or “ends” as we used to call them).

A major improvement here is the ability to maintain more than two explicit termini. In 2.0, you had the success and the failure termini (or “ends” as we used to call them). Now, additional ends such as not_found can be leveraged to communicate a non-binary outcome of your activity or operation.

Yes, Trailblazer is adding new abstractions and concepts and they are different to the 90s-Ruby, but now, at the latest, it becomes obvious how this improves the developing process. We’re no longer talking in two-dimensional method stack traces or byebug hoops, the language and conception is changing to the actual higher level code flow, to activities sitting in activities structured into smaller step units.

To tell you the truth, the new tracing feature was the original reason why I decided to write 2.1 and make you sit and wait in agony for years. Nevertheless, tracing is simply blowing my mind. I can’t count how many hours and angering rushs of adrenaline I’ve saved since the introduction of the wtf? method and its helpful higher-level stack trace.

The new 2.1 version comes with a few necessary but reasonable changes in method signatures. As painful as that might sound to your Rails-spoiled ears, we preferred to fix design mistakes now before dragging them on forever.

The new call API is much more consistent and takes away another thing we kept explaining to new users - an indicator for a flawed API.

We try to keep the “information architecture” - a word I wouldn’t have learned without the inspiring Alex Coles - as simple as possible: so far, we got a handful of pages accessible through the top navigation, and then the documentation behind the DOCS link. Here, the right sidebar helps you to navigate within the chapter.

To make it short: we returned to the Rails Way™, lowering our heads in shame, and adhere to the Rails file and class naming structure for operations.

I feel how needed those new abstractions are. Yes, you can write everything with your own code, you don’t need abstractions for flow control and automatic error handling, which makes me wonder why you’re not programming in assembler since Ruby is also an “unnecessary abstraction” on top of a processor. We need abstractions, unless you want to program like we did 30 years ago.

Also, the more I use Trailblazer in projects or even in Trailblazer itself, I feel how needed those new abstractions are.

ather, data is passed around from operation to operation, from step to step. We use OOP and inheritance solely for compile-time configuration. You define classes, steps, tracks and flows, inherit those, customize them using Ruby’s built-in mechanics, but this all happens at compile-time. At runtime, no structures are changed anymore, your code is executed dynamically but only the ctx (formerly options) and its objects are mutated. This massively improves the code quality and with it, the runtime stability

It’s so simple that I sometimes wonder why it took years to develop it!

There is nothing wrong with building your own “service layer”, and many companies have left the Traiblazer track in the past years due to problems they had and that we think we now fixed.

The work put into Trailblazer 2.1 has been tremendous, it could easily have been TRB 3.0, or even TRB III, since Roman version numbering turns out to be quite a fancy thing to do. However, as much as the internals have been improved, as little has changed on the public APIs of Trailblazer, so we decided to go with a minor release.

We removed the trailblazer-loader gem just like Apple removed the headphone jack from the iPhone 6. This brings you faster startup and consistency with Rails autoloading.

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

Software architecture choices include specific structural options from possibilities in the design of the software.

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.

We use a subset of BPMN for the visual language in the editor, but added our own set of restrictions and semantics to it.

note that TRB source code modifications are not proprietary

Why is TRB licensed under LGPL, not MIT?

The LGPL allows users to use and integrate LGPL software components into their own software without being required to release the source code of their own software components. However, if users modify LGPL software components (“derivative work”), they are required to make the modified software component available under the same LGPL license. To avoid the latter with TRB, users have to comply with para. 5 LGPLv2.1: A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a “work that uses the Library”. Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. In other words: if you use the TRB libraries in your commercial applications or Open-Source projects, you’re not creating a derivative work of Trailblazer. Your software can be distributed under any terms.

Trailblazer (TRB) is an Open-Source project. Since we want to keep it that way, we decided to raise awareness for the “cost” of our work - providing new versions and features is incredibly time-consuming for us, but we love what we do.

This creates a win-win situation, you as the user have your peace of mind, and we can continue working with your funds.

Business Process Model and Notation (BPMN) is a standard for business process modeling that provides a graphical notation for specifying business processes in a Business Process Diagram (BPD),[3] based on a flowcharting technique very similar to activity diagrams from Unified Modeling Language (UML).

ActiveModel provides a powerful framework for defining callbacks. ActiveInteraction hooks into that framework to allow hooking into various parts of an interaction's lifecycle.

People who buy this buy for a reason, bonsai and some gaming experience. I'm disappointed from what I saw. I'd love to turn back and give another chance after it's completed. For now what I can say is it really amazes me how people here tend to glorify things easily while writing reviews.

I was aware of the mixed reviews but "mixed" to me could be a game that's perfectly suitable for one person's taste and detestable to the next.

Note: This question has been edited since it was asked. The original title was "Test whether a glob has any matches in bash". The specific shell, 'bash', was dropped from the question after I published my answer. The editing of the question's title makes my answer appear to be in error. I hope someone can amend or at least address this change.

# catch multi-char special key sequences read -sN1 -t 0.0001 k1 read -sN1 -t 0.0001 k2 read -sN1 -t 0.0001 k3 key+=${k1}${k2}${k3}

for term in vt100 linux screen xterm { echo "$term:" infocmp -L1 $term|egrep 'key_(left|right|up|down|home|end)' }

For example, on the terminal I'm using, the right arrow outputs ^[[C. You can see what sequence your terminal outputs by pressing Ctrl-V Right Arrow. The same is true for other cursor-control keys such as Page Up and End.

If you kill ffmpeg process it will exit with code 255 (easily reproducible in the terminal)

sig_handler() { exit_status=$? # Eg 130 for SIGINT, 128 + (2 == SIGINT) echo "Doing signal-specific up" exit "$exit_status" }

Example (in bash, but my question shouldn't be considered bash-specific):

Now this probably won't make difference in the real world (e.g. because the exit codes are not portable and on top of that not always unambiguous as discussed in Default exit code when process is terminated?)

However, because so many shells follow that convention of having 128 + signal_number, programs know to avoid using those values above 128 for their exit code (or when they do exit(130), it's to report the death of a child that dies of a signal 2 like some shells do under some circumstances).

So if you get a number of 130, there's an ambiguity in that you don't know whether the process dies of a signal 2 or just did an exit(130).

man ps has all the answers, under the "PROCESS STATE CODES" heading:

non-interactive shells (actually when job control is not enabled)

In any case signal handling in shells is one of the least reliable and portable aspects. You'll find behaviours vary greatly between shells and often between different versions of a same shell. Be prepared for some serious hair pulling and head scratching if you're going to try to do anything non-trivial.

Here, you could use zsh instead of sh which doesn't have either of those annoying "features" (at least in current versions).

for sig in $(kill -l) ; do trap "echo parent:$sig" $sig done

while : # This is the same as "while true".

Both kill with a job specifier and terminal signals send to the entire process group, so both the shell and sleep.

As usual with almost any command, if you want a normal argument that starts with a - to not be interpreted as a switch, precede it with --

rkill command from pslist package sends given signal (or SIGTERM by default) to specified process and all its descendants:

Typically, a process associated with a controlling terminal is foreground process and its process group is called foreground process group. When you start a process from the command line, it's a foreground process:

Most users make mistakes while typing, so a backspace key is often useful. This could of course be implemented by the applications themselves, but in accordance with the UNIX design philosophy, applications should be kept as simple as possible. So as a convenience, the operating system provides an editing buffer and some rudimentary editing commands (backspace, erase word, clear line, reprint), which are enabled by default inside the line discipline.

Beware, though: What you are about to see is not particularly elegant. In fact, the TTY subsystem — while quite functional from a user's point of view — is a twisty little mess of special cases. To understand how this came to be, we have to go back in time.

Why then sending the SIGINT manually to the shell doesn't kill the child, e.g. 'kill -2 <shell-pid>' doesn't do anything to a child process while Ctrl-C kills it?

-Wpedantic

The shell process itself is in yet another process group all of its own and so doesn't receive the signal when one of those process groups is in the foreground. It's that simple.

Switching "jobs" between foreground and background is (some details aside) a matter of the shell telling the terminal which process group is now the foreground one.