When changes occur in the program's environment, particularly changes which the designer of the program did not anticipate, the software may no longer operate as originally intended.

This is not a physical phenomenon: the software does not actually decay, but rather suffers from a lack of being responsive and updated with respect to the changing environment in which it resides.

PyPy aims to provide a common translation and support framework for producing implementations of dynamic languages, emphasizing a clean separation between language specification and implementation aspects.

As of May 24, 2016, antimicro has moved from https://github.com/Ryochan7/antimicro to https://github.com/AntiMicro/antimicro. Additionally, project management has passed from Travis (Ryochan7) to the AntiMicro organization due to Travis having other interests and priorities.

D3 4.0 is modular. Instead of one library, D3 is now many small libraries that are designed to work together. You can pick and choose which parts to use as you see fit.

To the consternation of some users, 3.x employed Unicode variable names such as λ, φ, τ and π for a concise representation of mathematical operations. A downside of this approach was that a SyntaxError would occur if you loaded the non-minified D3 using ISO-8859-1 instead of UTF-8. 3.x also used Unicode string literals, such as the SI-prefix µ for 1e-6. 4.0 uses only ASCII variable names and ASCII string literals (see rollup-plugin-ascii), avoiding encoding problems.

D3 now passes events directly to listeners, replacing the d3.event global and bringing D3 inline with vanilla JavaScript and most other frameworks.

This allows those other dependencies to share the same module instance.

Occasionally, like with search engines, #2 occurs because the incumbents gain massive economies of scale (classic Microeconomics), where by virtue of their being large, the cost to produce each incremental good or service at scale becomes much lower.

Inevitably, most of these new entrants get wiped out over a decade or two and their market share goes down into the single digits (often zero). The end result is that the market often resembles one of two possible situations:

I'd suggest there ought to be config to disable source maps specifically, and specifically for either CSS or JS (not alwasy both), without turning off debug mode. As you note, debug mode does all sorts of different things that you might want with or without source maps.

Meh... as I said earlier, I think using Webpack is the recommended way now. Another issue is there is no way to generate source maps in production.

I'm not sure about all consequences of my change and this is very complex.

I agree about lack of maintenance. It's probably because people use more and more Webpack.

And no need to walk backwards through all these strings which is surprisingly inefficient in Ruby.

There's not a way to do it at the moment without enabling all debug features.

I totally understand that there may be a majority still considering this a bad practice and thus keeping it disabled by default in production seem ok. But there could at least be an option to enable it for people who want to, no?

It seems I'm in the minority, and Sprockets seems to already pretty far along in the beta process, so at most we should add a configuration option to enable it for static compilation.

Closing this because it's obviously not going to get fixed and it's cluttering my open issues

Right now major changes require a deep and broad understanding of the codebase and how things get done.

If a company really wanted to invest, I would prefer they dedicated an employee for X hours a week for Y months than money.

Money could be good if it is spent to provide some of the above things. Money on it's own is hard because then it means I would have to spend time book-keeping and managing instead of programming.

As well as the discussion about what is really meant by a ‘domain of one’s own‘

But we're definitely sticking with the source map idea rather than the current (Rails 3/4) behavior of including all JS and CSS files separately while in development?

OpenFaaS® makes it easy for developers to deploy event-driven functions and microservices to Kubernetes without repetitive, boiler-plate coding.

One day last August 2018, I stumbled upon an online petition that sparked my curiosity - We Want Serverless Ruby. At that time, none of the major cloud providers had first-class support for Ruby in their serverless products. There were ~1400 devs signing that petition, and I wondered if there was something about Ruby that made it unsuitable for FaaS. I decided to roll the sleeves and start building what would be the first PoC of faastRuby.

Before a bug can be fixed, it has to be understood and reproduced. For every issue, a maintainer gets, they have to decipher what was supposed to happen and then spend minutes or hours piecing together their reproduction. Usually, they can’t get it right, so they have to ask for clarification. This back-and-forth process takes lots of energy and wastes everyone’s time. Instead, it’s better to provide an example app from the beginning. At the end of the day, would you rather maintainers spend their time making example apps or fixing issues?

I think that over time the distinction is lost. My math teacher, 35 years ago stated "formulas are used in chemistry, in math we have equations". To this day, the word 'formula' in math seems wrong, but I'd accept it's used commonly.

An equation is meant to be solved, that is, there are some unknowns. A formula is meant to be evaluated, that is, you replace all variables in it with values and get the value of the formula.

Rails still encourages you to dump all validation errors at the top of a form, which is lulzy in this age of touchy UX

Fits the ideal behind HTML HTML stands for "HyperText Markup Language"; its purpose is to mark up, or label, your content. The more accurately you mark it up, the better. New elements are being introduced in HTML5 to more accurately label common web page parts, such as headers and footers.

[...document.querySelectorAll("*")].filter(e => e.childNodes && [...e.childNodes].find(n => n.nodeValue?.match("❤")))

Super modern one-line approach with optional chaining operator

Fibar bi jàngal na taawan bu góor ni ñuy dagge reeni aloom.

Fexeel ba kër gi bañ ñàkk alkol.

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.