answered May 9 '13 at 15:29 alexander farkas

markdown-it is the result of the decision of the authors who contributed to 99% of the Remarkable code to move to a project with the same authorship but new leadership (Vitaly and Alex). It's not a fork.

Open source code library for building innovative e-learning that is accessible, usable, interoperable, mobile-friendly and multilingual. Based on the Web Experience Toolkit (WET) and bootstrap. This collaborative open source project is led by the Canada School of Public Service, Government of Canada.

Posting an issue on the discussion boards for a three year old game, yesterday, I wasn't holding my breath for a reply. Earlier, this morning, a dev. responded, stating they'd look at fixing it, and it was just a few hours before it were sorted!

You really don't need underscore/lodash for this ... nowadays anyways

Run the complete unit with a certain input set, and test the side-effects. This differs to the Rails Way™ testing style, where smaller units of code, such as a specific validation or a callback, are tested in complete isolation. While that might look tempting and clean, it will create a test environment that is not identical to what happens in production.

Using ::delegates works exactly like the Forwardable module in Ruby, with one bonus: It creates the accessors in a module, allowing you to override and call super in a user module or class.

Having an understanding of higher level abstractions, such as tasks, activities and the historical code path taken, its debugging trace is much closer to how you, as an engineer, think about your code.

Admittedly, both the signature and the return values of invoke feel a bit clumsy. That’s becaus we’re currently working with the low-level interfaces.

Additionally, you may add debugging steps, error handler or rewire the conditions dynamically without touching the original snippet.

The circuit interface is a bit more clumsy but it gives you unlimited power over the way the activity will be run.

CHILD DEVELOPMENT PERSPECTIVES

Cytokine storms also can be indicated by liver enzyme abnormalities.

Luckily, the tests to diagnose cytokine storms are often cheap and readily available in hospitals.

Eh, that's just sales. Humans are dumb, panicky animals: just look at how J.C. Penny's "Fair and Square" initiative went.Short version: they went full-on no bullshit: no limited time sales, no fake prices discounted, things cost what they cost, no more FOMO, no waiting for deals.It tanked. Horribly.

Why do companies insist on making deals a gamble? Is it basically just to capture FOMO sales?Both rhetorical questions.Edit: I'm talking about how you can pay one price for a deal and then a couple months later it's even cheaper.

Devoted to Trump, and committed to his fictions about the election, Republicans are doing everything they can to keep voters from holding them and their leaders accountable. They will restrict the vote. They will continue to gerrymander themselves into near-permanent majorities. A Republican in Arizona has even proposed a legislative veto over the popular vote in presidential elections

naked attempt to change the rules of American politics to benefit one party”

— and not to lose the next presidential election the way they lost the last one. To that end, they have introduced bills to restrict the vote, to make the race for the Electoral College — a

You’re free to test this activity in a separate unit test.

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.

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

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.

identity theft

Please note that this is a higher-level debugging tool that does not confront you with a 200-lines stack trace the way Ruby does it, but pinpoints the exceptional code and locates the problem on a task level. This is possible due to you structuring code into higher abstractions, tasks and activities.

They are an abstraction that will save code and bugs, and introduce strong conventions.

Nonviolent direct action seeks to create such a crisis and foster such a tension that a community which has constantly refused to negotiate is forced to confront the issue.

That’s it. If you have a previous “precompile” array, in your app config, it will continue to work. For continuity sake I recommend moving over those declarations to your manifest.js file so that it will be consistent.

Instead of having this confusing maze of lambdas, regexes, and strings, we could, in theory, introduce a single entry point of configuration for Sprockets to use, and in that file declare all assets we wanted to compile. Well, that’s exactly what the manifest.js file is.

For example, what if your site has a customer interface and an “admin” interface? If the two have totally different designs and features, then it might be considerable overhead to ship the entirety of the admin interface to every customer on the regular site.

Literally, everything in this example can go wrong. Here’s an incomplete list of all possible errors that might occur: Your network might be down, so request won’t happen at all The server might be down The server might be too busy and you will face a timeout The server might require an authentication API endpoint might not exist The user might not exist You might not have enough permissions to view it The server might fail with an internal error while processing your request The server might return an invalid or corrupted response The server might return invalid json, so the parsing will fail And the list goes on and on! There are so maybe potential problems with these three lines of code, that it is easier to say that it only accidentally works. And normally it fails with the exception.

Now you can easily spot them! The rule is: if you see a Result it means that this function can throw an exception. And you even know its type in advance.

Almost everything in python can fail with different types of exceptions: division, function calls, int, str, generators, iterables in for loops, attribute access, key access, even raise something() itself may fail. I am not even covering IO operations here. And checked exceptions won’t be supported in the nearest future.

You still need to have a solid experience to spot these potential problems in a perfectly readable and typed code.

Examples

Make your functions return something meaningful, typed, and safe!

let's be honest, print-and-play is A LOT of work (printing, cutting, laminating, sleeving, etc) and it is not everyone's cup of tea.

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

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:

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

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

And they are not the only way to handle errors.

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.

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 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

Any time a change is needed, rather than creating new ads and groups, business data can be updated seamlessly, trickling the change to ad copy without triggering an ad Quality Score review.

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.

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

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.

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

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 fail to recognize the value of an initial investment of time in future productivity.

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

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!

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 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.

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.

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.

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.

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:

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.

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.

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

bird counts across the United States have fallen a staggering 29 percent in the last 50 years

Simply try to do something about a problem, and many people will think you are responsible for the problem’s existence.4

This is in fact where I started, but this gives me all processes, which is exactly what I don't want.

Fifth, is the idea of the ledger of things. We're already seeing applications of this new Internet of devices and things. Soon though, most transactions will happen between devices and not between people. Consider the smart home, homeowners are adding smart devices such as thermostats and solar panels. Soon potentially, trillions of devices will be connected to the Internet. Doing everything from driving us around to keeping our house lit to managing our affairs and managing our health information. These devices need to be resistant to hacking. They need to be able to communicate value such as money or assets like electricity, peer-to-peer. Consider electricity, if you imagine that your neighbor's home is generating energy from a solar panel and you've got a device that needs to buy that electricity, then those two devices need away to be able to contract, bargain, and execute a payment peer-to-peer. It's not going to happen through the Visa network. It can only happen on the blockchain.

Grouped inputs It can be convenient to apply the same options to a bunch of inputs. One common use case is making many inputs optional. Instead of setting default: nil on each one of them, you can use with_options to reduce duplication.

# User fields
string :name
integer :age
date :birthday, default: nil

# Food preferences
array :pizza_toppings
boolean :wants_cake, default: nil

# Fields that are required
string :name
integer :age
array :pizza_toppings

# Fields that are optional
with_options default: nil do
  date :birthday
  boolean :wants_cake
end

In this simple example, the destroy interaction doesn't do much. It's not clear that you gain anything by putting it in an interaction.

ActiveInteraction plays nicely with Rails. You can use interactions to handle your business logic instead of models or controllers.

Since we're using an interaction, we don't need strong parameters. The interaction will ignore any inputs that weren't defined by filters. So you can forget about params.require and params.permit because interactions handle that for you.

This probably looks a little different than you're used to. Rails commonly handles this with a before_filter that sets the @account instance variable.

It's an implementation of the command pattern in Ruby.

In Ruby 3 we now have a “rightward assignment” operator. This flips the script and lets you write an expression before assigning it to a variable. So instead of x = :y, you can write :y => x

we’re going to look how improved pattern matching and rightward assignment make it possible to “destructure” hashes and arrays in Ruby 3—much like how you’d accomplish it in, say, JavaScript

Amid awful suffering and deteriorating conditions, Texas Republicans decided to fight a culture war.

Establish structured daily check-ins: Many successful remote managers establish a daily call with their remote employees.

jargon comes so naturally

Recognize that all people are both located in systems and also uniquely individual

Some people "get" the idea of systemic privilege and ask "But what can I do?" My answer is, you can use unearned advantage to weaken systems of unearned advantage. I see white privilege as a bank account that I did not ask for, but that I can choose to spend. People with privilege have far more power than we have been taught to realize, within the myth of meritocracy. Participants can brainstorm about how to use unearned assets to share power; these may include time, money, energy, literacy, mobility, leisure, connections, spaces, housing, travel opportunities. Using these assets may lead to key changes in other behaviors as well, such as paying attention, making associations, intervening, speaking up, asserting and deferring, being alert, taking initiative, doing ally and advocacy work, lobbying, campaigning, protesting, organizing, and recognizing and acting against both the external and internalized forms of oppression and privilege.

Think about why U.S. people, especially White people, have trouble seeing systemically. Explain the myth of meritocracy: that the unit of society is the individual and that whatever one ends up with must be whatever that individual wanted, worked for, earned, and deserved. Why do you think this myth survives so successfully, suppressing knowledge of systemic oppression and especially of its "up-side,"systemic privilege?

I repeatedly forgot each of the realizations on this list until I wrote it down. For me, white privilege has turned out to be an elusive and fugitive subject. The pressure to avoid it is great, for in facing it I must give up the myth of meritocracy.

This is a breaking change so it'll have to go into a major release. I was working on a v4 release but it's too much. I think I'm going to pair it back and we can add this to the new v4. When I have that ready, I'll rebase the merge onto that branch.

Agents are usually understood to be human, although some paradigms, such as actor-network theory, maintain that non-humans are also endowed with agency.

actor-network theory

In Translation Studies (TS), the notion of agent has received various definitions. For Juan Sager (quoted in Milton & Bandia 2009: 1), an agent is anyone in an intermediary position (i.e. a commissioner, a reviser, an editor, etc.) between a translator and an end user of a translation whereas for Milton & Bandia (2009) an agent of translation is any entity (a person, an institution, or even a journal) involved in a process of cultural innovation and exchange. A third avenue was suggested by Simeoni (1995) who defined the agent as “the ‘subject,’ but socialized.

No one has requested it before so it's certainly not something we're planning to add.

To give a little more context, structures like this often come up in my work when dealing with NoSQL datastores, especially ones that rely heavily on JSON, like Firebase, where a records unique ID isn't part of the record itself, just a key that points to it. I think most Ruby/Rails projects tend towards use cases where these sort of datastores aren't appropriate/necessary, so it makes sense that this wouldn't come up as quickly as other structures.

I don't think seeing it in Rails PRs naturally means we should do it blankly. Put it another way, what's the justification in those PRs for doing it?

The rationale is that it's actually clearer to eager initialize. You don't need to worry about timing/concurrency that way. Lazy init is inherently more complex than eager init, so there should be a reason to choose lazy over eager rather than the other way around.

class FormsController < ApplicationController class SearchForm < ActiveModel::Form

The press release also quoted a UA assistant provost for institutional research who explained that while the swipes of student ID cards were not used in the current student retention analytics, about 800 other data points were

The researcher noted that the data she had used had been anonymized before she was given access to it—however, she added that if/when her research might inform the ongoing efforts to improve student retention, the student’s personal details would be “shared” with the students' academic advisers.

She then used that data to create large networks mapping which students interacted with one another and how often.

On the university’s website, a press release

At the University of Arizona, for example, a researcher analyzed the swipes of student ID cards at locations across campus, “to see what they reveal about students' routines and relationships, and what that means for their likelihood of returning to campus after their freshman year.”

The assert method is used by all the other assertions. It pushes the second parameter to the list of errors if the first parameter evaluates to false or nil.

Read about the motivation to understand why this separation of concerns is important.

Code of Ethics

As a result, dry-types, dry-struct and dry-schema were born. These projects should be considered as virtus' successors, with better separation of concerns and better features.

Take 3, Previously attempted in 2012 (#8189) and 2015 (#19709). This new version uses ActiveModel Attributes API.

If you don't understand both sides of an issue, you cannot make an intelligent choice; in fact, if you don't understand all the ramifications of your actions, you're not designing at all. You're stumbling in the dark.

This article explains why you shouldn't use getters and setters (and when you can use them) and suggests a design methodology that will help you break out of the getter/setter mentality.

which have recently become umbrella terms referring to any piece of quickly-consumed comedic or relatable content

The Chicago Manual of Style and the Associated Press (AP) both revised their formerly capitalized stylization of the word to lowercase "internet" in 2016.[3] The New York Times, which followed suit in adopting the lowercase style, said that such a change is common practice when "newly coined or unfamiliar terms" become part of the lexicon.

The spelling "internet" has become often used, as the word almost always refers to the global network; the generic sense of the word has become rare in non-technical writings.

My understanding of "programming to an interface" is different than what the question or the other answers suggest. Which is not to say that my understanding is correct, or that the things in the other answers aren't good ideas, just that they're not what I think of when I hear that term.

I think maybe the terms we're using are a bit confusing.

I agree that validation is a process that determines the property of validity of a certain object

As with other software patterns, MVC expresses the "core of the solution" to a problem while allowing it to be adapted for each system.

This is done to separate internal representations of information from the ways information is presented to and accepted from the user.

Any representation of information such as a chart, diagram or table. Multiple views of the same information are possible, such as a bar chart for management and a tabular view for accountants.

However, sometimes actions can't be rolled back and it is unfortunately unavoidable. For example, consider when we send emails during the call to process. If we send before saving a record and that record fails to save what do we do? We can't unsend that email.

I typically save everything I can first, and then call the side-effects afterwards. If the side-effects fail I can handle them elsewhere and retry when necessary.

The basic classification of a form object is a class that contains writable attributes, validations and logic to persist the attributes to ActiveRecord objects. These forms can also include other side-effects like background job triggers, emails, and push-notifications etc. The simplest way to understand the concept is to think of them as a representation of a controller action where all of the business logic that happens in that controller action is abstracted into a form object.