:

after_commit on: :create do OnboardingDripper.subscribe!(self) end

drip engine for managing, creating, and performing scheduled messages sequences

What's wrong with this?

You're checking state in a mailer

It's going to be so fun to scale when you finally want to add more unsubscribe links for different types of sequences

If you have anything like this is your codebase, you need Caffeinate:

Is this thing dead? No! Not at all! There's not a lot of activity here because it's stable and working!

This looks at Caffeinate::Mailing records where send_at has past, skipped_at is nil, and the associated Caffeinate::CampaignSubscription is has empty ended_at and unsubscribed_at values.

AbandonedCartDripper

For example, if you are Netflix and have a Subscription and a WatchHistory object. If a user does not finish watching a video, you may want to remind them that they can finish watching it. If their subscription lapses, you may want to also remind them in a separate campaign.

It has two relations that are similar, but different: subscriber, and user. The concept here is that a User may have many objects that are relevant to warrant their own Campaign. For this reason, we include this as a default. For example, if you are Netflix and have a Subscription and a WatchHistory object. If a user does not finish watching a video, you may want to remind them that they can finish watching it. If their subscription lapses, you may want to also remind them in a separate campaign. So, you'd have separate Caffeinate::CampaignSubscription objects where the subscriber is the relevant Subscription object or the WatchHistory object, and the user is the User.

the terms allowance and tolerance are used inaccurately and are improperly interchanged

“Accuracy” indicates the closeness of a measurement to the true value but it cannot be quantified because it is not possible to know the true value.

Updated

Sure, it is not needed, we can always write things in a different way. As a matter of fact, with such an argument, hardly any improvement should be accepted.

In practice when people use ||, they do mean ?? (whatever its spelling). It just so happens that most of the time, it does what you want, because you happen to not be dealing with Booleans. But the semantics you mean to express is not about "truthness", but about "nilness". And occasionally you get bitten because false does exist, and behaves differently.

Here's example code which works around the lack of a ??= operator in the wild:

In comparison, Perl/Python/Javascript, which also have the latter property, have other false-like values (0 and empty string), which make || differ from a null-coalescing operator in many more cases (numbers and strings being two of the most frequently used data types). This is what led Perl/Python/Javascript to add a separate operator while Ruby hasn't.

Examples by languages

the first operand evaluated to a value likened to logically false, in other words, a falsy value

f that operand evaluates to a value likened to logically true (according to a language-dependent convention, in other words, a truthy value)

And, of course, I'm grateful to be reunited with my long lost friend, false.

However, this idiom is only an approximation, and introduces subtle bugs when we try to allow false values:

Ruby, as a community, unfairly discriminates against false, and it needs to stop.

false is a perfectly non-nil object, and you're excluding it out of convenience!

Decimals are commonly used to approximate real numbers. By increasing the number of digits after the decimal separator, one can make the approximation errors as small as one wants, when one has a method for computing the new digits.

For example, the bathroom scale may convert a measured extension of a spring into an estimate of the measurand, the mass of the person on the scale. The particular relationship between extension and mass is determined by the calibration of the scale.

The resolution is related to the precision with which the measurement is made, but they are not the same thing. A sensor's accuracy may be considerably worse than its resolution.

with stating it as the implied uncertainty (to prevent readers from recognizing it as the measurement uncertainty)

Round half to even, which rounds to the nearest even number. With this method, 1.25 is rounded down to 1.2. If this method applies to 1.35, then it is rounded up to 1.4. This is the method preferred by many scientific disciplines, because, for example, it avoids skewing the average value of a long list of values upwards.

For example, if the length of a road is reported as 45600 m without information about the reporting or measurement resolution, then it is not clear if the road length is precisely measured as 45600 m or if it is a rough estimate.

That right there almost works. It'd be incredible if it did because I love the way that reads.

The snag is that when the top-level match grabs the published_at value and applies it to the be_within(...), it is working with a string representation of the timestamp. We first need to parse that into a date object and there is no affordance for that here.

RSpec gives us the tools to make custom matchers so that we can preserve all the expressiveness while adding specialized or even domain-specific matchers.

If you'd like another method to do the waiting for you, e.g. Kernel.select, you can use Timers::Group#wait_interval to obtain the amount of time to wait. When a timeout is encountered, you can fire all pending timers with Timers::Group#fire

You can also schedule a block to run immediately and periodically with Timers::Group#now_and_every

I'm a company

I'm a developer

The Starfish and the Spider: The Unstoppable Power of Leaderless Organizations Ori Brafman, Rod A. Beckstrom How do you build teams and organizations that are sustainable over time? How can you be the most adaptable? Forget everything you know about leadership and organization, be completely transformed. A must for anyone wanting results.

A concurrent system is one where a computation can advance without waiting for all other computations to complete.

Envfile

# booleans # simple: providing any value for ENV['FORCE_SSL'] means `true`: force_ssl = !!ENV['FORCE_SSL'] # more advanced: # only when we provide 'true' will `force_ssl` become true. force_ssl = ('true' == ENV['FORCE_SSL'])

variable :FORCE_SSL, :boolean, default: '1'

You can define a coercion to some type via definition

fiels :tags, Array, of: String

But nothing of them supports all features I need for:

I've explored these projects: Reform Mutations Interactor dry-rb

But you're able to remove (usually inherited) fields by: class ChildForm < ParentForm remove_field :field_from_parent end

Fields and nested forms are filling in order of their definition. But sometimes you want to change this order, for example, if you have a nested forms in ancestors which depends on data in children forms. For such cases you can use :depends_on option, which accepts fields and nested forms names as Symbol or Array of symbols. They will be filled (and initialized) before dependent.

And if I need for simple service object without validation? You can use Formalism::Action, a parent of Formalism::Form.

memoize :call, condition: -> { environment == 'production' }

Such gems like Memoist override methods. So, if you want to memoize a method in a child class with the same named memoized method in a parent class — you have to use something like awkward identifier: argument. This gem allows you to just memoize methods when you want to.

It's a fork of Memery gem. Original Memery uses prepend Module.new with memoized methods, not touching original ones. This approach has advantages, but also has problems, see discussion here: tycooon#1

but PR is not updated somewhy

Unfortunately, $ method_name -s doesn't work in Pry, but I hope that some day it will get fixed. Just a ref to issue: pry/pry#1756

You can require plugins for Filewatcher, which extends core functionality.

If you have questions, problems or suggestions about plugins system — please, don't hesitate to create a new issue.

Lightweight file watcher weighing about 300 LOC. No runtime dependencies and no platform specific code. Works everywhere.

Monitors changes in the file system by polling.

while true; do waitforsave assignment.ly; lily assignment.ly; say "done"; done

mount IndexController do # all methods will be mounted automatically, it's just an example of refinement get '/hello', :hello_world end

.time {|timer = Timer.new.start| ... } ⇒ Object Takes a block and returns the total time it took to execute.

you may want to implement a fan-out or map-reduce.

Unless you need fan-out, map-reduce style concurrency, you can actually use a slightly more efficient Kernel#Sync execution model.

When should I use Async? ¶ You should use Async when you desire explicit concurrency in your program. That means you want to run multiple tasks at the same time, and you want to be able to wait for the results of those tasks.

A programming model is an execution model coupled to an API or a particular pattern of code.

Modern parallel languages have much easier to use execution models. The thread model was one of the original parallel execution models, which may account for why it has persisted despite being difficult to use.

The complication comes from the fact that the execution model does not have any means for the execution of "give up ownership of the lock" to have any influence over which execution of "gain ownership of the lock" in some other timeline (thread) follows. Very often, only certain handoffs give valid results. Thus, the programmer must think of all possible combinations of one thread giving up a lock and another thread getting it next, and make sure their code only allows valid combinations.

a common synchronization construct is the lock

The execution model is the definition of the behavior, so all implementations, whether in-order or out-of-order or interpreted or JIT'd etc.. must all give the exact same result, and that result is defined by the execution model.

A task can be in one of the following states

A change in the minor component signifies a non-breaking change, and that the consumer can safely use the new version without breaking, although the consumer might need to be updated to use its new functionality. For example, adding a non-mandatory feature column with a default value to the model is a minor bump, because when a value for the added column is not passed, inference still works.

Using semantic versioning facilitates model deployment, by communicating which if a new version can be deployed without changes to the application:

When a user asks Claude to generate content like code snippets, text documents, or website designs, these Artifacts appear in a dedicated window alongside their conversation. This creates a dynamic workspace where they can see, edit, and build upon Claude’s creations in real-time, seamlessly integrating AI-generated content into their projects and workflows.

The architecture covers both easy unsubscribe options, mailto and URL. This is because not all mailbox providers support the List-Unsubscribe-Post header.

Offering an easy unsubscribe method allows recipients to indicate which type of email they would like to receive and not receive based on topic or category.

Amazon SES unsubscribe method: The Amazon SES subscription management feature, which provides subscription management via the List-Unsubscribe header and ListManagementOptions footer links.

Unsubscribe method header: A hyperlink that is rendered by the mailbox provider based on the List-Unsubscribe email header. Recipients can use this link to unsubscribe from that sender.

Unsubscribe method footer: An unsubscribe link in the email footer, which redirects recipients to a landing page, where they can unsubscribe or edit their communication preferences.

Custom-built unsubscribe method: A custom-built unsubscribe link in the email footer and manually added List-Unsubscribe header.

This is the most simulative version of a controller. It will try and mimic real user behaviour. It's the recommended version to use when the goal of the load-test is finding out how many concurrently active users the target instance supports.

I'm often asked to describe the “advantages” of free software. But the word “advantages” is too weak when it comes to freedom. Life without freedom is oppression, and that applies to computing as well as every other activity in our lives.

A proprietary program puts its developer or owner in a position of power over its users. This power is in itself an injustice.

Of course, the developer usually does not do this out of malice, but rather to profit more at the users' expense. That does not make it any less nasty or more legitimate.

Power corrupts; the proprietary program's developer is tempted to design the program to mistreat its users.

Yielding to that temptation has become ever more frequent; nowadays it is standard practice. Modern proprietary software is typically an opportunity to be tricked, harmed, bullied or swindled.

Software designed to function in a way that mistreats the user is called malware.

Microsoft is using malware tactics to get users to switch to their web browser, Microsoft Edge, and their search engine, Microsoft Bing. When users launch the Google Chrome browser Microsoft injects a pop up advertisement in the corner of the screen advising users to switch to Bing. Microsoft also imported users Chrome browsing data without their knowledge or consent.

The commercial license prohibits reverse engineering and tampering with our license key mechanism unlocking paid features so that we can run a compliant and fair commercial business.

ELECT DISTINCT ON (customer) id, customer, total FROM purchases ORDER BY customer, total DESC, id;

The perfect index for the above query would be a multi-column index spanning all three columns in matching sequence and with matching sort order:

WITH recursive temp (n, fact) AS ( SELECT 0, 1 -- Initial Subquery UNION ALL SELECT n+1, (n+1)*fact FROM temp WHERE n < 9 -- Recursive Subquery ) SELECT * FROM temp;

GROUP BY 1

Monopoly is not played on a cartesian plane. It's played on a directed circular graph. Therefore, it is inappropriate to use the Euclidean distance metric to compare the distances between places on the board. We must instead use minimum path lengths. Example: If we used Euclidean distance, then you would have to agree that the distance between, say, Go and Jail is equal to the distance between the Short Line and the Pennsylvania Railroad. Clearly, this is not the intention. In your example, the "nearest railroad" would be the railroad square having the shortest path from wherever you stand. With the game board representing a directed graph, there are no "backwards" paths. Thus, the distance from the pink Chance square to the Reading railroad is not 2. It's 38.

However, in order to tell InheritedResources that it really failed, you need to add errors to your model.

it really depends on how the organization's legal counsel interprets the laws and how risk-averse they are. Some organizations might say only Germany requires double opt-in, while others also include Austria and Switzerland. Some organizations might say the US operates under "everyone is opted in until they opt out" while others might say everyone needs to opt in, regardless of country.

It’s also worth pointing out that an unfriendly unsubscribe experience is also a major driver of spam complaints. Half of U.S. consumers say they’ve reported a brand’s emails as spam because they couldn’t easily opt out, according to our Adapting to Consumers’ New Definition of Spam report. So putting up opt-out barriers not only jeopardizes your legal compliance but can also hurt your deliverability as well.

ensure you’re following unsubscribe best practices:Don’t charge a fee.Don’t require any other information beyond an email address.Don’t require subscribers to log in.Don’t ask subscribers to visit more than one page to submit their request.

Keep a clear record of how you obtained consent from your current subscribers When, how, and why (what for) you obtained their data – timestamp, wording, source.

I've just experienced the same issue with confirmation links being executed in a sent email before the user has received them and invalidating the link. I got around the issue by modifying the page the URL links to. I've added a Confirm button on the page which the user has to click to confirm their email and this works nicely.

I've seen the same issue. The links in emails opened in outlook seem to be crawled immediately by the 'BingPreview' bot.

If the link you are trying to send is just some kind of harmless confirmation link (e.g. subscribe/unsubscribe from a newsletter), then at least use a form inside the web page to do the actual confirmation through a POST request (possibly also using a CSRF token), otherwise you will unequivocally end up with false positives.

"this is a bug of the mail provider" Seriously, Drupal community bring less and less value. Unfollow this issue, but I perhaps time for me to delete my D.O. account. It's a critical issue that can lead to the impossibility for user to log-in. In the real world, nobody care if Microsft server "should" act differently.

Drupal use a HTTP GET to change data witch is not how HTTP protocol is supposed to be work. A HTTP POST request should be used to change an account from blocked to active. It's a bug and a ugly one.

Especially users working with Microsoft Office 365 and therefore Outlook noticed very often that login is not possible. Upon closer analysis, it was found that the MS/Bing crawlers are particularly persistent and repeatedly call the reset links, regardless of server configuration or the like. For this reason, a text field was implemented in the backend via the Drupal State API, in which selected user agents (always one per line) can be entered. These are checked by 'Shy One Time', in case of a hit a redirect to the LogIn form with a 302 status code occurs, the reset link is not invalidated.

Another suggestion some senders are trying is to set up a “stealth” link, that human readers won’t see or click on but that parsing software might. Clicks on that link are a sign that the click was not done by the recipient.

Confirmations are a little more difficult, as senders really do want to keep the transaction as low friction as possible. Adding a confirm button may result in people abandoning the confirmation process.

This behaviour may affect one-click unsubscribe links. If clicking the link in an email automatically processes the unsubscribe, then Barracuda may unsubscribe users without their knowledge.

This behaviour may affect opt-in confirmation links.

I’ve implemented a form on the landings page that auto-submits (on DOMContentLoaded) and posts the token to the next page. Passwordless login is now working for my client despite their mail scanner.

In June 2021 I can confirm Microsoft seem to be running a product that completes client side activities, like automatically submitting a form. I guess they are running a headless browser to do the scanning.

Really appreciatie your suggestion. We hesitated between this solution and the one where the landing page auto-redirects/posts to the next page. I think both are good solutions. Yours a bit more secure. The other less clicks and less friction for the user.

If you want to be (relatively) sure that any action is triggered only by a (specific) human user, then use URLs in emails or other kind of messages over the internet only to lead them to a website where they confirm an action to be taken via a form, using method=POST

Links (GETs) aren't supposed to "do" anything, only a POST is. For example, your "unsubscribe me" link in your email should not directly unsubscribe th subscriber. It should "GET" a page the subscriber can then post from.

The purpose of distinguishing between safe and unsafe methods is to allow automated retrieval processes (spiders) and cache performance optimization (pre-fetching) to work without fear of causing harm.

Request methods are considered "safe" if their defined semantics are essentially read-only; i.e., the client does not request, and does not expect, any state change on the origin server as a result of applying a safe method to a target resource.

For example, most servers append request information to access log files at the completion of every response, regardless of the method, and that is considered safe even though the log storage might become full and cause the server to fail. Likewise, a safe request initiated by selecting an advertisement on the Web will often have the side effect of charging an advertising account.

For some reason, Microsoft decided to use the MS Word HTML rendering engine in Outlook 2007 to 2013 (desktop version) – this was even worse than the IE5/IE6 rendering engine which I believe was used in Outlook 2000, 2002 and 2003! As most large corporate businesses force their staff to use a version of desktop Outlook that hasn’t been updated in years, email is stuck in this hell of being held back in worse-than-IE6 web.

We want users to unsubscribe to messages they don’t want; we don’t want them to mark them as spam and hurt the reputation of the sender. We have seen by implementing this unsubscribe affordance in the UI that spam marks go down and in some cases are being reduced by 30 to 40%.

The table below lists the general categories of bodies and objects by their location or structure.