This functionality is used by LSync for performing backup rotation (i.e. deleting old backups).

gems.rb

platform built on top of Utopia and Relaxo.

xnode view layer

Utopia is a content-centric web application platform. It leverages the file-system to provide a mapping between logical resources and files on disk.

Designed for both content-based websites and applications. Does not depend on a database.

Utopia is a website generation framework which provides a robust set of tools to build highly complex dynamic websites. It uses the filesystem heavily for content and provides functions for interacting with files and directories as structure representing the website.

My long term vision for Falcon is to make a web application platform which trivializes server deployment. Ideally, a web application can fully describe all its components: HTTP servers, databases, periodic jobs, background jobs, remote management, etc. Currently, it is not uncommon for all these facets to be handled independently in platform specific ways. This can make it difficult to set up new instances as well as make changes to underlying infrastructure. I hope Falcon can address some of these issues in a platform agnostic way.

As web development is something I'm passionate about, having a server like Falcon is empowering.

Relaxo is a transactional database built on top of git.

Relaxo uses the git persistent data structure for storing documents. This data structure exposes a file-system like interface, which stores any kind of data.

In practice, forks and threads are at odds with each other. If you try to fork while there are active threads, you will very likely run into bugs. Even if you didn't create the thread, some other library might have, so it can be very tricky in practice.

The small prefixes were also added, even without such a driver, in order to maintain symmetry.

Multithreading is a widespread programming and execution model that allows multiple threads to exist within the context of one process. These threads share the process's resources, but are able to execute independently.

mailer

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

:

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!

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.