Without using the included NGINX: sudo docker compose -f docker-compose.yml -f docker-compose.without-nginx.yml up -d

“Discipling” someone is, to use a more recognizable term, mentoring someone in how to follow Christ and share the good news that people can have a relationship with God.

Did anyone else notice this question is basically how different notions of "approximate equality" are only approximately equal?

The affinity to using meta-programming in Ruby is going to vary a lot between different development teams and it’s a very important factor in deciding whether to adopt gradual typing as the two work against each other.

On most real life projects, the speed of development is easily worth an occasional corner case bug with an unexpected nil value … except when it isn’t.

If I decide to add it, which solution should I pick, battle tested Sorbet or core team endorsed RBS?

Will gradual typing be supported long term or is it a fad? Will this be an abandoned investment?

confabulation

But that label has grown controversial as the topic becomes mainstream because some people feel it anthropomorphizes AI models (suggesting they have human-like features) or gives them agency (suggesting they can make their own choices) in situations where that should not be implied.

“There are a lot of people who mistakenly think intelligibility is the standard. ‘Oh, you knew what I was saying.’ Well, that’s not the standard. That’s a really bottom-of-the-barrel standard,” he says. “People who are concerned with English usage usually want to have their words taken seriously, either as writers or as speakers. And if you don’t use the language very well, then it hard to have people take your ideas seriously. That’s just the reality.”

Some linguists would argue that there’s no point fighting against slips like that—that language is forever unfixed and deviations should simply be observed and even appreciated—or that it’s silliness to tell people to follow rules that are as arbitrary as the meaning assigned to a certain jumble of letters. But Garner is not one of them.

Then again that makes little sense when trying to account for why people use the less-standard preventative instead of preventive or irregardless instead of regardless, he notes.

These days someone might even try to correct you if, in an attempt to note someone was being (overly) humble, you said they were self-depreciating.

But the corruption has become so common that using the original today might not only stop a conversation in its tracks but cause unpleasant face-scrunching. Per Garner, spitting image is now 23 times more commonly used than its precursor.

Have you ever said you felt nauseous? In the traditional sense that would mean you felt like you were capable of causing others to woof cookies, not that you were feeling sick to your own stomach—much along the lines of how poisonous and poisoned work.

Young people today, he says, are now dropping the “from” and simply saying they “graduated college,”

I logged in to my social media accounts.

At the same time, computer scientists and engineers need to deliver the technological burden of proof that decentralized personal data networks can scale globally, and that they can provide people with a better experience than centralized platforms.

This unprecedented openness has inspired large-scale permissionless innovation and unbounded creativity

Fortunately, we do not have to agree on everything. Linked Data enables layered agreements, in which a few rules need to be adopted by many, and sets of additional rules are agreed upon by smaller groups as required.

Freedom of course always comes at a cost: what constitutes a victory for personal rights and freedom of speech also facilitates the spread of illegal messages, since decentralized networks make it harder to control what information is exchanged. Legality is of course a tricky matter, as some countries instate laws that prevent their citizens from voicing opinions that would be legal elsewhere.

Usernames will need to be unique and have two numbers appended to the end of them, which Signal states was done in order to help keep usernames "egalitarian and to minimize spoofing."

before after (current behavior) after (expected behavior)

That. Is the coolest. Shortcut. Ever. 💥 🚀

I am just surprised that there is no clear official name for such a popular and well known convention.  Internet searching seems to indicate that the common term used is "Red Squiggly Line", but it seems like a term quickly made-up just to describe something for which we know no name.  There's a technical name for the dot on an "i" for goodness sake (tittle).

The seeming luxury of having multiple words to choose from is not sufficient to offset the lingering fear that no matter which word you pick it will be the wrong one, causing people to silently laugh at you and judge both you and your grammar school teachers

The word people is best not used with words of number, in place of persons. If of ‘six people’ five went away, how many ‘people’ would be left? Answer: one people.

@user = GlobalID::Locator.locate_signed params[:id]

Is that a false negative

Documentation

Enhances ActionMailer to support the :cache delivery method, which behaves like :test, except that the deliveries are marshalled to a temporary cache file, thus making them available to other processes.

I control my emails. I can grep them, migrate them, back them up however I want, I can choose who gets through the spam filter. And this is my most sensitive data - password resets, personal emails, personal info - honestly I'm surprised more selfhosters don't do it.

Todoist for quick notes and todo lists. I'm also using my own TodoistToTxt (available on github) script running every minute to generate a todo.txt file out of Todoist inbox, which is rendered on PC with Rainmeter.

There are two things that I enjoy: a test framework written in my own Domain Specific Language (DSL) that is easily understood by all those on a project and the ability for all participants to easily read, search, and view the tests.

I was continually pushing out the documents to those interested

This tools bridges the gap of having feature files found in your source code and true documentation that your team, product owners and stakeholders can use.

As you all noticed I haven't given too much attention to this project in recent years, which I regret, but realistically I probably won't be the best maintainer given I haven't been using Ruby for years now, lost the contact with the ecosystem whatsoever.

The fact that many here are maintainers of Ruby implementations also has a biased effect on new features, as they might represent a burden on them. I'm not saying this is a bad thing, I love the diversity of points of view that this brings! OTOH, it's fair that people that do take time to discuss things here have a bigger influence on the direction that Ruby follows.

I frequently call for name compromises (let's stop on one name and move forward instead of five more years of discussion).

https://www.npmjs.com/package/open-in-editor-connect

"astronaut" beautifully translates to "star sailor."

true roots of "helicopter" are "helix" (meaning spiral, as in double helix) and "pteron" (meaning wing, as in pterodactyl, wing finger). So, "helicopter" literally means "spiral wing" – how perfect!

Built in the open Concourse's RFC process and governance model invite anyone to become a contributor, developing the project roadmap by collaborating in the open.

This is a bit awkward since TypeScript already defines its own thing called Iterator purely for type-checking. So due to this unfortunate name clash, TypeScript needs to introduce a separate type to describe these native/built-in iterable iterators.

The extension runs a command using your shell’s interactive mode, so that version managers configured in files such as ~/.zshrc are picked up automatically. The command then exports the environment information into JSON, so that we can inject it into the NodeJS process and appropriately set the Ruby version and gem installation paths.

in-box

Daily Wire held screenings at universities across the US, but some of those efforts were hindered when Eventbrite took down listings for screenings due to violations of its community guidelines. Article continues after ad “We do not permit events, content, or creators that promote or encourage hate, violence, or harassment towards others and/or oneself,” the company said.

personal knowledge management

This method allows individuals to manage and interlink their information more effectively by creating interconnected nodes, known as knowledge graphs.

GPL "infects" other parts of a system to combat a work-around which was used to violate the software freedom of the user, by firewalling sections of GPL'ed code from the rest of the system.

The point of GPL licenses is to protect the user of the software, not the developer. If you want "protection" as a developer, use MIT (disclaimer of warranty). GPL "infects" other parts of a system to combat a work-around which was used to violate the software freedom of the user, by firewalling sections of GPL'ed code from the rest of the system. If you don't care about your users' software freedom in the first place, then (L)GPL is the wrong choice.

In practice, tracking all authors in all copyright notices is quite cumbersome. Instead, often only the original author is credited here even when copyright is shared with additional contributors. A more reasonable approach is to credit all authors collectively, e.g. as “the FooProject contributors” or “Original Author and others”. However, I am not sure whether that results in a valid copyright notice as the copyright holders must be clearly recognizable.

The other reason to update these notices is if there are new authors. Typically, this is done by adding a new copyright line for each set of authors, with the most recent on top. For example: Copyright 2016–2018 George Copyright 1999, 2007–2016 Fred Adding a new line is sensible since many open-source licenses require that existing copyright notices are kept intact – so you must not update them in any way. And in the above example, adding George to Fred's copyright notice would be misleading since George did not publish any of their work in 1999 and Fred didn't publish in 2018.

freedom to make and distribute copies of your modified versions

A free program allows you to tinker with it to make it do what you want (or cease to do something you dislike). Tinkering with software may sound ridiculous if you are accustomed to proprietary software as a sealed box, but in the Free World it's a common thing to do, and a good way to learn programming. Even the traditional American pastime of tinkering with cars is obstructed because cars now contain nonfree software.

If the users don't control the program, the program controls the users.

Other kinds of works are also used for practical activities, including recipes for cooking, educational works such as textbooks, reference works such as dictionaries and encyclopedias, fonts for displaying paragraphs of text, circuit diagrams for hardware for people to build, and patterns for making useful (not merely decorative) objects with a 3D printer. Since these are not software, the free software movement strictly speaking doesn't cover them; but the same reasoning applies and leads to the same conclusion: these works should carry the four freedoms.

If any of them is missing or inadequate, the program is proprietary (nonfree)

With all four freedoms, the users fully control the program.

With the other two freedoms, any group of users can together exercise collective control over the program.

The freedom to make and distribute exact copies when you wish.

Users' control over the program requires four essential freedoms.

freedom to study the program's “source code,” and change it, so the program does your computing as you wish

freedom to run the program as you wish, for whatever purpose.

The first two freedoms mean each user can exercise individual control over the program

Either way, they give the program's developer power over the users, power that no one should have.

When a program respects users' freedom and community, we call it “free software.”

computer users' freedom—for users to control the software they use, rather than vice versa

(in its practitioners' perverse terminology) as “secure boot”

The computer will run, without prejudice, whatever software you install in it, and let that software do whatever its code says to do.

This means that computer does not impose one particular service rather than another, or one protocol rather than another. It does not require the user to get anyone else's permission to communicate via a certain protocol.

The computer will communicate, without prejudice, through whatever protocol your installed software implements, with whatever users and whatever other networked computers you direct it to communicate with.

Any software that can be replaced by someone else, the user must be empowered to replace.

However, the presence of nonfree software in the computer is an obstacle to verifying that the computer is loyal, or making sure it remains so.

For instance, the AMT functionality in recent Intel processors runs nonfree software that can talk to Intel remotely. Unless disabled, this makes the system disloyal.

The computer always permits you to analyze the operation of a program that is running.

This entails that the computer rejects remote attestation, that is, that it does not permit other computers to determine over the network whether your computer is running one particular software load. Remote attestation gives web sites the power to compel you to connect to them only through an application with DRM that you can't break, denying you effective control over the software you use to communicate with them.

When the computer communicates using any given protocol, it will support doing so, without prejudice, via whatever code you choose (assuming the code implements the intended protocol), and it will do nothing to help any other part of the Internet to distinguish which code you are using or what changes you may have made in it, or to discriminate based on your choice.

Free/Open Licenses Non-free Licenses

Free and open-source licenses use these existing legal structures for an inverse purpose

Creative Commons NonCommercial licenses (by-nc-*) do not support the OD 1.1#8., “No Discrimination Against Fields of Endeavor”, as they exclude usage in commercial activities.

Broadly speaking, an open license is one which grants permission to access, re-use and redistribute a work with few or no restrictions.

Opponents often state that this technology will be used primarily to enforce digital rights management policies (imposed restrictions to the owner) and not to increase computer security.

TC is controversial as the hardware is not only secured for its owner, but also against its owner, leading opponents of the technology like free software activist Richard Stallman to deride it as "treacherous computing"

The law in many countries allows users certain rights over data whose copyright they do not own (including text, images, and other media), often under headings such as fair use or public interest. Depending on jurisdiction, these may cover issues such as whistleblowing, production of evidence in court, quoting or other small-scale usage, backups of owned media, and making a copy of owned material for personal use on other owned devices or systems. The steps implicit in trusted computing have the practical effect of preventing users exercising these legal rights.

"please" and "thanks"

Provide a complete description of the issue. If it works on A but not on B and others have to ask you: "so what is different between A and B" you are wasting everyone's time.

Introduction of a lockfile: true/filename mechanism to prevent multiple schedulers from executing

So you need help. People can help you, but first help them help you, and don't waste their time.

I avoid running -d in development mode and bother about daemonizing only for production deployment.

There is the handy rails server -d that starts a development Rails as a daemon. The annoying thing is that the scheduler as seen above is started in the main process that then gets forked and daemonized. The rufus-scheduler thread (and any other thread) gets lost, no scheduling happens.

Using rufus-scheduler with Passenger or Unicorn requires a bit more knowledge and tuning, gently provided by a bit of googling and reading

I don't know what this Ruby thing is, where are my Rails? I'll drive you right to the tracks.

Go read how to report bugs effectively, twice. Update: help_help.md might help help you.

similar gems

Rufus-scheduler (out of the box) is an in-process, in-memory scheduler. It uses threads. It does not persist your schedules. When the process is gone and the scheduler instance with it, the schedules are gone.

Log to stdout. Shut down on TERM/INT. Reload config on HUP. Provide the necessary config file for your favorite init system to control your daemon.

Your application code should not be dealing with PID files, log redirection or other low-level concerns.

Let your operating system handle daemons, respawning and logging while you focus on your application features and users.

This makes developing a modern daemon much easier. The init config file is what you use to configure logging, run as a user, and many other things you previous did in code. You tweak a few init config settings; your code focuses less on housekeeping and more on functionality.

For years developers have followed the same arcane dozen steps to create a long-lived daemon process on Unix-based systems. These steps were state of the art in 2000 but they are no longer best practice today.

Less system administration, easier debugging, simpler code, all because you leveraged the init system to do the work for you!

The beauty of runit is its brevity and simplicity

Unfortunately newer init systems like systemd have become increasingly complex to handle more desktop-focused requirements. Here’s a list of systemd APIs: does having 100s of public API functions and commands inspire confidence in its reliability?

I can firmly recommend runit if you want a server-focused, reliable init system based on the traditional Unix philosophy.

Reliability of the init system is paramount so simplicity is a key attribute.

But fork does not copy the parent process's threads. Thus locks (in memory) that in the parent process were held by other threads are stuck in the child without owning threads to unlock them, ready to cause a deadlock when code tries to acquire any of them. Also any native library with forked threads will be in a broken state.

So fork is fast, unsafe, and maybe bloated.