I'm still against frozen-string-literal by default. It is arguable if the string creation limits performance so much in real-world programs. We need to first measure how much Ruby can be faster by frozen-string-literal. If it is not significant, Ruby should prefer dynamics and flexibility.

Note: This repo does not publish or maintain a latest tag. Please declare a specific tag when pulling or referencing images from this repo.

That is, instead of properly reaping adopted processes, it's probably expecting another init process to do that job, and rightly so.

The RuboCop way is to offer an opinion in the way of a good default, but to accommodate all reasonable style choices.

If we ever moved a file to a different location or renamed it, all its previous history is lost in git log, unless we specifically use git log --follow. I think usually, the expected behavior is that we'd like to see the past history too, not "cut off" after the rename or move, so is there a reason why git log doesn't default to using the --follow flag?

Note: Git 2.6+ (Q3 2015) will propose that in command line: see "Why does git log not default to git log --follow?" Note: Git 2.6.0 has been released and includes this feature. Following path changes in the log command can be enabled by setting the log.follow config option to true as in: git config log.follow true

New functionality is typically implemented with first class objects that import behavior from issues via shared concerns.

Thus my docs recommendation of public function beforeFilter(Event $event) // do not render out the now inconsistent one for is(json) if (!$this->request->is('jsonapi')) { throw new NotFoundException('Invalid access, use application/vnd.api+json for Content-Type and Accept.'); } } to specifically only whitelist the desired jsonapi for the general use case.

A default baked app has all those included. Thats why I am saying this - it is by default an issue we should and need to address :)

You don’t need microsecond timing on a freaking website – except maybe in graphics and sound, and such functionality could be wrapped and secured in an API. So think that browser makers deserve a bigger slice of blame for making their users so vulnerable. User safety needs to become important again.

Runs headless by default, but you can configure it to run in a headful mode.

The most important guideline to give is the following: Write clean unit tests if there is actual value in testing a complex piece of logic in isolation to prevent it from breaking in the future Otherwise, try to write your specs as close to the user’s flow as possible

If an access modifier is not specified it is implicitly public as that matches the convenient nature of JavaScript 🌹.

Are you also tired and fed up with the bulkiness of jQuery, but also don't want to have to type document.querySelector("div").appendChild(document.createTextNode("hello")); just to add some text to an element?

They cause completely different behavior for auto margins. If you have a fixed element for example with top/bottom/left/right set to zero and you stick an image in it you want to center wrapped in a div, then in order to center that div with auto margins, you MUST specify a CSS width/height, because specifying an HTML attribute width/height has no effect and the margins remain zero. I have no idea why the difference exists.

Whether to specify in html or css is best judged on individual circumstances. A large number of images of the same size would probably be best served with css, a single image with html. That said, if you are specifying other styles for the image (border colour, style or radius, float etc) it would make sense to add width & height to the css.

plausible

Svelte is different in that by default most of your code is only going to run once; a console.log('foo') line in a component will only run when that component is first rendered.

If you call ./configure --enable-gui=auto, the build process will automatically build against whichever GUI libraries are available. A cursory glance suggests that gtk2 will be prioritised over gnome2.

deskbar should probably detect their extension and execute the relevant command as opposed to opening the file for editing.

But I believe the core philosophy of tiny modules is actually sound and easier to maintain than giant frameworks.

The default bundle combines about thirty of these microlibraries.

Of course user expectations for titles are the most important thing. You don’t want to sell a tiny game at AAA price, because you won’t sell many copies and you’ll make your gamers feel ripped off.

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?

Your expectations are reasonable considering the property name, but

Knowing what your elements are lets browsers use sensible defaults for how they should look and behave. This means you have less customization work to do and are more likely to get consistent results in different browsers.

They cannot accept any less than 100 percent of their expectations being met.

Record filters allow you to require an instance of a particular class (or one of its subclasses) or a value that can be used to locate an instance of the object. If the value does not match, it will call find on the class of the record. This is particularly useful when working with ActiveRecord objects.

def initialize(attributes=nil) self.assign_attributes(attributes) end

If no end line value is declared, the item will span 1 track by default.

premailer-rails processes all outgoing emails by default. If you wish to skip premailer for a certain email, simply set the :skip_premailer header:

I'd instinctively associate a this.cache() inside preload with the preloaded data only -- meaning no matter what crazy thing I did inside preload, the returned data would be cached locally, where local means either the client or server.

logInfoToStdOut (boolean) (default=false) This is important if you read from stdout or stderr and for proper error handling. The default value ensures that you can read from stdout e.g. via pipes or you use webpack -j to generate json output.

Furthermore, how come there's a PR open since 3 months, at what seems to be the authoritative repo for Svelte?

You will be disrupted by this first issue. It is natural to expect relative references to be resolved against the .sass/.scss file in which they are specified (like in regular .css files).

We all know that real business logic does not belong in the presentation layer, but what about simple presentation-oriented things like coloring alternate rows in table or marking the selected option in a <select> dropdown? It seems equally wrong to ask the controller/business logic code to compute these down to simple booleans in order to reduce the logic in the presentation template. This route just lead to polluting the business layer code with presentation-oriented logic.

This is linux. Ouput first, formatting second. systemctl --no-pager -l should be the default.

Why doesn't it do this by itself, by default?

Right, and if most uses of an FTP service use new FtpService() the one that sets an alternate port will stand out (service.SetPort(12345))

The concept of Convention over Configuration is impossible without sensible default values. The key word here is "sensible". The default values have to make sense for at least 80% (if not more) of all the uses of a library/service/framework.

The natural assumption is that this is because a) it is the best package manager, and b) the JavaScript community is the most energetic and productive.

When the message say function was called outside component initialization first will look at my code and last at my configuration.

What I believe should happen is the Svelte compiler should, when a promise is passed to onMount, realise that a promise has been passed, and await the result of the function to be used as the onDestroy function. i.e, it should behave the exact same way for an async function as it does for a non-async function (if this is possible)

Also, I'm starting to wonder if maybe it's okay to have multiple spreads? If the alternative to <Foo {...a} {...b} {...c} d={42}> is that people will write <Foo {...Object.assign({}, a, b, c)} d={42}> anyway, then do we gain anything with the constraint?

The fears of breaking one of Svelte's core tenets seem overblown to me. Style encapsulation by default is great, but that doesn't mean we should contort the framework around it.

The second situation occurs when a person says unpleasant things about another when he or she ought to have known they are false. A reasonable person generally refrains from sharing negative information about others if he or she has reason to doubt its veracity.

warn iff not seen before can be an acceptable option.

So what Python currently does in issue depreciation warnings in the main program, but not in libraries and similar code. That may also be a reasonable way to limit the number of warnings while making sure deprecations don't go unnoticed (because that makes them useless).

However, a ActiveRecord::Rollback within the nested transaction will be caught by the block of the nested transaction, but will be ignored by the outer transaction, and not cause a roll back! To avoid this unexpected behaviour, you have to explicitly tell rails for each transaction to indeed use proper nesting: CopyActiveRecord::Base.transaction(joinable: false, requires_new: true) do # inner code end This is a safer default for working with custom transactions.

There will be limits placed on what will and will not be masked. This will include accounting for enough entropy to make sense (e.g. don't mask a variable that is just set to a word.) and are not multi-line.

AFAICT the outcome you want is for your webRequest-added CSP header to be applied after document.write resets the page. This seems to me a reasonable thing to expect and I'm surprised it didn't work right away. Consider opening a ticket on crbug.com.

The most controversial issue in RAND licensing is whether the "reasonable" license price should include the value contributed by the standard-setting organization's decision to adopt the standard. A technology is often more valuable after it has been widely adopted than when it is one alternative among many; there is a good argument that a license price that captures that additional value is not "reasonable" because it does not reflect the intrinsic value of the technology being licensed. On the other hand, the adoption of the standard may signal that the adopted technology is valuable, and the patent holder should be rewarded accordingly. That is particularly relevant when the value of the patent is not clearly known before the adoption of the standard.

The court's decision, which exonerated Hush-A-Phone and prohibited further interference by AT&T toward Hush-A-Phone users, stated that AT&T's prohibition of the device was not "just, fair, and reasonable," as required under the Communications Act of 1934, as the device "does not physically impair any of the facilities of the telephone companies," nor did it "affect more than the conversation of the user."

For all of the above reasons, this DPA is of the opinion that publishers may not be required to include, on the home page of their websites, also the notices relating to the cookies installed by third parties via the publishers’ websites.

In general, the directive does not specifically require that you list and name individual third-party cookies, however, you are required to clearly state their categories and purpose. This decision by the Authority is likely deliberate as to require such would mean that individual website/app owners would bear the burden of constantly watching over every single third-party cookie, looking for changes that are outside of their control; this would be largely unreasonable, inefficient and likely unhelpful to users.

If these asset owners regarded the “robots” as having the same status as guide dogs, blind people or default human citizens, they would undoubtedly stop imposing CAPTCHA tests and just offer APIs with reasonable limits applied.

Setting up Nginx properly requires quite a bit of work. Using websockets or using Rails streaming? Make sure you disable response buffering for the relevant URIs, otherwise they won’t work correctly. Phusion Passenger 5’s builtin reverse proxy does the right thing by default, without any configuration. In other words: it’s all about making things simple.

Yes, absolutely, no two projects are alike. This step is moving towards a direction where we have a set of best practices for webpack isolated in a bundled package and can be maintained in isolation without impacting upgrades or end-user experience. If you have seen next.js or create-react-app they sort of do they same thing for ease and maintainability. Rails is a great example for this - there are some built-in best practices, opinionated defaults and gems that are hidden behind the scene plus power to do advance things where needed.

Let your reasonableness[d] be known to everyone.