Prepare to transition away from Google Sync Google Sync doesn’t support OAuth authentication, 2-factor authentication, or security keys, which leaves your organization’s data less secure.

“Various people asked to do various things with it, and they referred them to this guy who didn't respond,” Brand says. “And so it was just frustrating for decades.”

Autoloading in Rails was based on const_missing up to Rails 5. That callback lacks fundamental information like the nesting or the resolution algorithm being used. Because of that, Rails autoloading was not able to match Ruby's semantics, and that introduced a series of issues. Zeitwerk is based on a different technique and fixed Rails autoloading starting with Rails 6.

ActiveRecord::Base.normalizes declares an attribute normalization. The normalization is applied when the attribute is assigned or updated, and the normalized value will be persisted to the database. The normalization is also applied to the corresponding keyword argument of query methods, allowing records to be queried using unnormalized values.

(9 years later:)Both provided answers would fail on files without a newline at the end, this will effectively skip the last line, produce no errors, would lead to disaster (learned hard way:).

Recent work has revealed several new and significant aspects of the dynamics of theory change. First, statistical information, information about the probabilistic contingencies between events, plays a particularly important role in theory-formation both in science and in childhood. In the last fifteen years we’ve discovered the power of early statistical learning.

I think we have a responsibility not only to ourselves, but also to each other, to our community, not to use Ruby only in the ways that are either implicitly or explicitly promoted to us, but to explore the fringes, and wrestle with new and experimental features and techniques, so that as many different perspectives as possible inform on the question of “is this good or not”.

If you’ll forgive the pun, there are no constants in programming – the opinions that Rails enshrines, even for great benefit, will change, and even the principles of O-O design are only principles, not immutable laws that should be blindly followed for the rest of time. There will be other ways of doing things. Change is inevitable.

Shared links offer a new way for users to share their ChatGPT conversations, replacing the old and burdensome method of sharing screenshots.

I think we 00:30:23 do need to get better at humaning

deleting user files without being asked for is by far an "unsafe in nonzero scenarios" decision, no program should do it. The sane option is to refuse working and/or display a visible warning explaining why.

Our API v3 uses the terminology from the previous version of GetResponse. Campaigns and lists are the same resource under a different name. For now, please refer to lists as campaigns. Our API v4 will use the updated terminology.

With Mailgun, you'll need to upgrade to a dedicated IP or "managed email service" and pay extra for "better deliverability." At Postmark, great deliverability isn't an up-charge. It's simply included, and we share live delivery data so you can judge for yourself.

Imagine what happens when subscribers change activities, interests, or focus. As a result, they may no longer be interested in the products and services you offer. The emails they receive from you are now either ‘marked as read’ in their inbox or simply ignored. They neither click the spam reporting button nor attempt to find the unsubscribe link in the text. They are no longer your customers, but you don’t know it.

This was originally disallowed because #5907 was opened asking for different behavior in this situation that we didn't want to allow, and so we decided to make it a compiler error rather than have confusing behavior in that situation.

Yes, it was right, but nowadays Dockerfiles are not specific to Docker. Dockerfiles also work with Buildah & Podman (and there might be other ones in the future) and they have generalized the naming: “Containerfile.”

I just spent a day dismantling a model, trying to find the cause of the silent rollback - taking out every association, every validation, every callback, whittling down all the code in the transaction, only to finally discover that it was return true that was the cause of it all. Or yes, an exception!

The bash manual contains the statement For almost every purpose, aliases are superseded by shell functions.

A better message, clarifying the true purpose of the cop, which I guess is to differentiate empty Hash literals and blocks.

If anyone can completely refactor the JSON Schema description for OpenAPI v3.0 to accurately describe the schema in all its glory, without using this new keyword, then please do so, but I would kindly ask you to test the theory first.

This is a distillation of the results of 230+ comments on #515, not to mention the 300+ comments spread across several other older issues that fed into that one. I know it's long. Please don't complain unless you can offer a shorter write-up. :-)

the AST version of the code is vastly superior IMHO. The knowledge about what constitutes an access modifier is already encoded in the system so it makes more sense to just call the method to test the type of node. The regexp solution may be expedient, but it's not as resilient to change -- if new access modifiers are added in the future it's very likely this code won't be updated, which will be the source of a bug.

Interestingly, Rails doesn't see this in their test suite because they set this value during setup:

Does the average person today have a better life than a medieval king?AnswerFollow·91RequestAll related (30)

The more educated are more likely to say life is better

Poverty is relational and not an absolute measure

How our fantasy world of the past has become everyday reality.

No option is perfect here, but a warning seems like a decent compromise unless there's a whole bunch of other plugins that break

There is something nice about aligning with the platform. But it risks being a straitjacket, and I think we can provide better ergonomics when it comes to streaming.

I agree about documenting everything. But for me docs are a last resort (the actual text, anything beyond skimming through code examples) when things already went wrong and I need to figure out why. But we can do much better. During dev when we see _method and methodOverride is disabled we can tell the developer that it needs to be enabled. Same if we see _method with something other than POST. Same for all other cases that are currently silently ignored. If the method is not in allowedMethods arguable it should even return a 400 in production. Or at the very least during dev it should tell you. We have the knowledge, let's not make the user run into unexpected behavior (e.g. silently ignoring _method for GET). Instead let's fail as loud as possible so they don't need to open their browser to actually read the docs or search though /issues. Let them stay in the zone and be like "oh, I need to set enabled: true, gotcha, thanks friendly error message".

All known use cases of require_dependency have been eliminated with Zeitwerk. You should grep the project and delete them.

Rails 7.0 will aim to give you a default setup based on import maps, and leave the Webpacker approach as an optional alternative.

The reason for the new name is that the "dist-upgrade" name was itself extremely confusing for many users: while it was named that because it was something you needed when upgrading between distribution releases, it sounded too much as though it was only for use in that circumstance, whereas in fact it's much more broadly applicable.

Dispatch a custom event. This differs from Svelte's component event system, because these events require a DOM element as a target, can bubble (and do by default), and are cancelable with event.preventDefault(). All SMUI events are dispatched with this instead of Svelte's createEventDispatcher.

the old paradigms of critical pessimism ultimately lead to political paralysis and fatalism, another way of seeing technological expansion as inevitable and irreversible. Critical pessimism offers us few models of viable change, focusing only on the strength of entrenched power and the failure of all strategies of resistance. At its most reductive, critical pessimism scapegoats the media for all the faults of the current social order rather than recognizing that digital media might offer new technical potentials for responding to the fragmentation of contemporary social life or the domestic isolation of our children, housewives, and the elderly. Digital theory matters politically because of its ability to envision alternatives, to imagine a better future. Cyberspace provides a place to experiment with alternative structures of government, new forms of social relations, which may, at least on the most grassroots of levels, allow us to temporarily escape, if not fully transform, unacceptable social conditions in our everyday lives.

I am firmly convinced that asserting on the state of the interface is in every way superior to asserting on the state of your model objects in a full-stack test.

Object.hasOwn() is recommended over hasOwnProperty(), in browsers where it is supported.

While lacking a mandate to actually rule Lebanon, Hezbollah has successfully occupied the shell of an almost completely failed state. Sanctions have created a vicious feedback loop, in which attempts to curb Hezbollah’s influence just deteriorate the Lebanese state, which allows Hezbollah to fill the vacuum of state function. The Lebanese military is desperately trying to hold the center as the only legitimate state institution. But the military lacks the capacity to hold on to power, and Hezbollah has proved that a mandate is easier to build than capacity. Hezbollah also has a powerful ally in the victorious Assad government in Syria, both of which now have an interest in repatriating as many Syrian refugees as possible to undermine Sunni influence in Lebanon. Repatriation prevents the Sunnis from growing their base in Lebanon, and protects Hezbollah’s Shiite base from the internal threat of Sunni influence.

The strike was likely authorized by Paris and Washington, both of which have warned several times against Hezbollah circumventing the state to provide a solution to the fuel crisis themselves.

There will be three billion gamers by next year, according to a Newzoo study. And as Loftus puts it: “People are going to need to wear something.”

Saying that web devs used to be fine with relative imports is like saying that human beings used to be fine living without refrigerators. Sure we did. But was it better than it is now? No. No, it wasn't.

Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

Webpacker used to configure Webpack indirectly, which lead to a complicated secondary configuration process. This was done in order to provide default configurations for the most popular frameworks, but ended up creating more complexity than it cured. So now Webpacker delegates all configuration directly to Webpack's default configuration setup.

If you can suppress the urge to retch long enough to give it a chance, I really think you'll wonder how you ever worked with CSS any other way.

This is no different from other popular libraries or frameworks making huge architectural changes (think React 16.8 with hooks or Python 3). The longer you wait to make the switch, the more painful it will be for your project when you finally do. And in the meantime, you’ll be missing out on valuable improvements to a fundamental part of the workflow of every single project you work on.

target="_blank" which opens the anchor in a new window(which has been redirected to tabs by browser settings usually)

This attribute is considered a legacy attribute and redefined as allow="fullscreen".

This will obviate the need for a helper function of any kind.

If you forget to define x in the object you pass as the second argument, or if there's some similar bug or confusion, you won't get an error -- just unexpected results.

However instead of using array.length for latter items; e.g. array[array.length-1] for the last item, you can call array.at(-1)

you can use the new delegation syntax (...) that is introduced in Ruby 2.7. def foo(...) target(...) end

When an endpoint is to interpret a byte stream as UTF-8 but finds that the byte stream is not, in fact, a valid UTF-8 stream, that endpoint MUST _Fail the WebSocket Connection_. This rule applies both during the opening handshake and during subsequent data exchange.

You particular circumstances may or may not warrant a way different from what lhunath (and other users) deem "best practices".

I hate mentee. The word is protégé.

Fail loudly and helpfully if any environment variables are missing.

A system test is often better than an integration test that is stubbing a lot of internals.

GitLab is transitioning from controller specs to request specs.

If you don't need to support IE9 or lower, you can use flexbox freely, and don't need to use floated layouts.

The field/element/path extraction operators return NULL, rather than failing, if the JSON input does not have the right structure to match the request; for example if no such key or array element exists.

I would argue though that crashing is better than quietly providing unexpected behavior.

Your brain is a leaky bucket. If you're dedicated to filling it with knowledge, you should be equally dedicated to sealing the leak. Here's how.

CommonJS has served us well for many years, but ESM comes with many benefits, like language-level syntax, browser support, defaults to strict mode, async loading, top-level await, improved static analysis & tree-shaking, and more.

MJML has been designed with responsiveness in mind. The abstraction it offers guarantee you to always be up-to-date with the industry practices and responsive. Email clients update their specs and requirements regularly, but we geek about that stuff - we’ll stay on top of it so you can spend less time reading up on latest email client updates and more time designing beautiful email.

The main difference is in the flow of how messages are ultimately sent to devices for output. The standard library Logger logic converts the log entries to strings and then sends the string to the device to be written to a stream. Lumberjack, on the other hand, sends structured data in the form of a Lumberjack::LogEntry to the device and lets the device worry about how to format it. The reason for this flip is to better support structured data logging. Devices (even ones that write to streams) can format the entire payload including non-string objects and tags however they need to.

There is a similar feature in the standard library Logger class, but the implementation here is safe to use with multiple processes writing to the same log file.

Lumberjack 1.0 had a concept of a unit of work id that could be used to tie log messages together. This has been replaced by tags. There is still an implementation of Lumberjack.unit_of_work, but it is just a wrapper on the tag implementation.

What you want is not to detect if stdin is a pipe, but if stdin/stdout is a terminal.

stdin can be a pipe or redirected from a file. Better to check if it is interactive than to check if it is not.

Addendum: seven years later, Windows finally supports pseudoconsoles. If you are running on Windows 10 v1809 or later, this new API should solve your problem.

In some cases empty can be the simplest replacement for TCL/expect or other similar programming tools because empty:

unbuffer works with piping to less. That may be an easier syntax than what you've got.

Factory FunNER is the sequel and a very solid improvement to Factory Fun. It uses hexes instead of squares to allow more creative building, and some subtle improvements to scoring, length, and machine placement rules really improve things.

The Windows Console was extended to have a PTY interface called ConPTY in 2018.

For path names with newlines it is better to quote each pathname.

But we can use a two characters delimiter: / (space slash) That pair of characters could only exist at the beginning of a new (absolute) path:

Now that we’ve gotten newer layout features — again, like grid and flexbox — floats, too, have sort of fallen by the wayside, perhaps either because there are better ways to accomplish what they do

Your validation functions should also treat undefined and '' as the same. This is not too difficult since both undefined and '' are falsy in javascript. So a "required" validation rule would just be error = value ? undefined : 'Required'.

As to why both is_a? and kind_of? exist: I suppose it's part of Ruby's design philosophy. Python would say there should only be one way to do something; Ruby often has synonymous methods so you can use the one that sounds better. It's a matter of preference.

definitely less rough to work with than Devise

Optimization in this case is nothing crazy, just something I neglected while designing the framework.

Most “legacy” operations don’t have this output, yet. However, the Model() macro now supports this terminus.

non-regression testing

Clearly JS and NPM have done a lot RIGHT, judging by success and programmer satisfaction. How do we keep that right and fix the wrong?

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

I don't even know how to tell if they're working 100%, I'm getting mixed signals ..

Should it only contain link* calls?

When should I use link, vs dir, vs. tree?

but I still have no idea if I'm writing this new file correctly.

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

signal.to_h[:semantic]

In combination with [Track()], the :magnetic_to option allows for a neat way to spawn custom tracks outside of the conventional Railway or FastTrack schema.

  DefTrack do :paypal do
    step :charge_paypal
  end

  paypal_track = RailwayTrack do :paypal do
    step :charge_paypal
  end

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.

Since we're not passing any inputs to ListAccounts, it makes sense to use .run! instead of .run. If it failed, that would mean we probably messed up writing the interaction.

compose(Add, x: x, y: 3)

Add.run(x: x, y: 3)

account.first_name = first_name if first_name.present? account.last_name = last_name if last_name.present?

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.

Why is all this interaction code better? Two reasons: One, you can reuse the FindAccount interaction in other places, like your API controller or a Resque task. And two, if you want to change how accounts are found, you only have to change one place.

As a workaround, I guess I'll have to disable my strict CSP in development, but I'd prefer to keep it strict in development as well so that I ran into any CSP issues sooner...

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.

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.

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.

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.

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.

The new call API is much more consistent and takes away another thing we kept explaining to new users - an indicator for a flawed API.

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.

It makes me happy to see people actually think about things and not just accept a shitty API.