Presently, convention dictates that 100% of fossil carbon is counted but only a third of LULUCF carbon is counted

If this seems arbitrary and confusing, we understand! It’s a convention, just like how most programmers need to learn zero-based array indexing and then at some point it becomes second nature.

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

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).

we strive to heed upstream's recommendations on how they intend for their software to be consumed.

Please use $needle in a $haystack idiom in your example. It's much easier to read and understand.

This follows on a fairly widespread practice in various programming languages to use a leading underscore to indicate that a function or variable is in some way internal to a library and not intended for the end-user (or end-programmer).

We have embodied our relinquish-ment of biological and chemical weapons in the 1972 BiologicalWeapons Convention (BWC) and the 1993 Chemical Weapons Con-vention (CWC).

when I was CTO of a company and someone joined, the first thing they had to do was to spend two weeks reading AWDwR from cover to cover. Once you know the framework, there is no magic, only defaults that act as a catalizer and let you fly.

Constitutional Convention was called in 1875

Convention

Constitutional Convention in 1875

# Due to lack of "expressivity" in Compose, we define our own couple of service # "pseudo-types": # # - image-only services (name: *-image) # # The only goal of these is to build images. No other services build images. # # These have entrypoint overridden to exit immediately. # # - base services (name: *-base) # # These contain common configuration and are intended to be extended. # # Their command (not entrypoint, to keep the original one) is overridden to # exit immediately. Service must support a command to exit immediately. # # - task services (name: *-task) # # These are intended for running one-off commands. # # Their default command is overridden to exit immediately. Service must # support a command to exit immediately. # # - "real" services # # These are actual services that stay up and running.

I'm rather concerned about adding svelte.config.js support to things that already have well established mechanisms for configuration.

it does not have a fixed glyph, though fonts that contain it tend to use very similar glyphs

It may not seem like the obvious behaviour for return, but perhaps it is a safe assumption to make in general to think of return as aborting the method yielding to the block.

def with_something prepare yield on_success end any return, break or throw would skip the on_success code. Skipping over the on_success code also seems quite reasonable when the block calls break and throw. It may not seem like the obvious behaviour for return, but perhaps it is a safe assumption to make in general to think of return as aborting the method yielding to the block. It might be desirable to discourage the use of return in this way for transactions to keep the code clearer, but that would also affect the use of break which seems like a reasonable way to abort a transaction from within the transaction block.

Conventions are good, but they are very limited: enforce them too little and the programmer becomes coupled to the code—no one will ever understand what they meant once they are gone. Enforce too much and you will have hour-long debates about every space and colon (true story.) The “habitable zone” is very narrow and easy to miss.

Danger runs after your CI, automating your team's conventions surrounding code review.

The vendor prefix (vnd.) indicates that it is custom for this vendor.

The +json indicates that it can be parsed as JSON, but the media type should define further semantics on top of JSON.

it is highly encouraged to switch to zeitwerk mode because it is a better autoloader

It's more opinionated than active_record_migrations and standalone-migrations, and therefore simpler to configure.

db/migrate/core/user/

By default the wizard will render a view with the same name as the step. So for our controller AfterSignupController with a view path of /views/after_signup/ if call the :confirm_password step, our wizard will render /views/after_signup/confirm_password.html.erb

Loads an appropriate @posts or @post type instance variable.

Replaces your Rails controllers, views and forms with meta programming. Considers routes.rb, ability.rb, current_user and does the right thing.

, or ‘that is tragic’, nor are we certain, since short stories, we have been taught, should be brief and conclusive, whether this, which is vague and inconclusive, should be called a short story at all.

const palette: { [key: string]: string } = {...

what is the TypeScript Way™ of handling the implicit any that appears due to object literals not having a standard index signature?

what is the conventional way

Personally I think option 1 is the way to go as it doesn't allocate any memory to create a new array but rather modifies the existing array. Then the assignment just lets the compiler know that you modified the array.

arguments = method_proc.parameters.map(&:last)

“System tests” is a common naming for automated end-to-end tests in the Rails world. Before Rails adopted this name, we used such variations as feature tests, browser tests

This meant that we owned both sides of the product implementation. For unit testing on the frontend, we stayed with Angular’s suggestion of Jasmine. For unit testing on the backend, we went with rspec-rails. These worked well since unit tests don’t need to cross technology boundaries.

But what's the matter with "raw" instance variables? They are internal to your instance; the only code that will call them by name is code inside pancake.rb which is all yours. The fact that they start with @, which I assume made you say "blech", is what makes them private. Think of @ as shorthand for private if you like.

We want the GraphQL API to be the primary means of interacting programmatically with GitLab. To achieve this, it needs full coverage - anything possible in the REST API should also be possible in the GraphQL API.

1. The main folder names have numbers in front of them, such as 0-base to ensure that the folders stay in that particular order. You can certainly omit this or choose different folder names.

There's nothing to stop you from doing initializer code in a file that lives in app/models. for example class MyClass def self.run_me_when_the_class_is_loaded end end MyClass.run_me_when_the_class_is_loaded MyClass.run_me... will run when the class is loaded .... which is what we want, right? Not sure if its the Rails way.... but its extremely straightforward, and does not depend on the shifting winds of Rails.

The use of U+212B 'Angstrom sign', which was encoded due to round-trip mapping compatibility with an East-Asian character encoding, is discouraged, and the preferred representation is U+00C5 'capital letter A with ring above', which has the same glyph.

It's simple really ... put tests into a shared example that you want multiple things to conform to. Put code into a shared context that you need to include in multiple tests.

shared_contexts is any setup code that you can use to prepare a test case . This allows you to include test helper methods or prepare for the tests to run.

This approach is preferable to overriding authenticate_user! in your controller because it won't clobber a lot of "behind the scenes" stuff Devise does (such as storing the attempted URL so the user can be redirected after successful sign in).

Meh... as I said earlier, I think using Webpack is the recommended way now. Another issue is there is no way to generate source maps in production.

But yeah, I'm not sure how you would determine which was the "recommended way" really. I don't see anything in Rails docs saying either way.

But last I have seen comments from DHH, he considered webpack(er) recommended for JS, but Sprockets still the preferred solution for (S)CSS.

we want source maps in production (like DHH)

After waiting years for sprockets to support this we were very happy to see that sprockets 4 officially added support (thanks ), but then when trying to upgrade we noticed there's actually no way to use it in production... (without brittle hacks mentioned above).

Better yet, send them a link to this page to help them understand why and how to make an example app:

Instead of one big code pile, activities will gently enforce a clean, standardized way for organizing code.

They are an abstraction that will save code and bugs, and introduce strong conventions.

Patching has no implicit, magical side-effects and is strongly encouraged to customize flows for a specific case in a quick and consise way.

It's recommended to configure this library by setting environment variables.

value returned from #execute

By convention, we call this an outcome

Call .run on your interaction to execute it.

if you name you instance variable form, then you can always just pass in params[:form]

Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

Handlers are normally not suffixed, but instead, they most often have on as the prefix (onClick, onSwipe etc.).

Listeners are often objects, so they are commonly suffixed with Listener.

The Object.getPrototypeOf() method returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.

I like to keep the ‘verb’ + ‘noun’ structure when writing button labels — this makes the action more prescriptive, e.g. ‘Save post’, ‘Next step’, etc, as opposed to ‘Save’, ‘Next’

10. Regards croisés du Défenseur des droits sur la mise en œuvre de la CIDE et de la CIDPH

Some of the verbs implemented by systemctl are designed to provide a high-level overview in a human readable format. All that information is available over dbus, and/or journalctl, systemctl show. We could provide that information in json format, but there's a second problem. Information and format of information printed by e.g. systemctl status is not stable. Since the output is not suitable for programmatic consumption anyway, there's no need to provide it in a machine readable format.

Although I agree that -o json should return proper JSON, believe the proper way for external tools like SaltStack etc. to talk to systemd is DBus. See also saltstack/salt#20392 - everything else is more or less just hack-ish and prone to break easily.

If you have a better/simpler/"more official" solution, I'd still love to see it!

is this solution considered a hack or is something that we can use as an approved workaround in scenarios where we need to manually trigger validations?

The more official way to do this would be to run the check (you could even reuse this.validate) in onSubmit.

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.

For event listeners we support the standard jsx naming convention onEventname (this is converted to on:eventname in svelte) as well.

The first rule of standard is no configuration. Whatever the outcome of this thread, adding options is the wrong solution.

it also allows for more divergence in how people write there code and where they put their logic, making different svelte codebases potentially even more different due to fewer constraints. This last point is actually something I really value, I read a lot of Svelte code by a lot of different people and broadly speaking things look the same and are in the same places.

For reasons of compatibility and simplicity, it's best to use React's built-in state management capabilities rather than external global state.

e Constitutional Convention. I t had begun i n Philadelphia on May 25, 1 787, months after Samuel S tan-hope Smith had addressed some of t he delegates on race.

When it all came together it meant supporting most JSX conventions like spreads, refs, forwardRefs, and Components as tags.

The problem I have with this approach to state and prop variables is that the difference between them is very blurry. In React you can clearly see that a prop is an input to component (because of clear function notation), and that state is something internal. In Svelte they are both just variables, with the exception that props use export keyword.

There are two ways of handling this with Rollup, as described by the troubleshooting link from the warning. Unfortunately, both Rollup and React recommend the wrong one.

The recommended solution for onMount is the same as for useEffect — place an async function inside the handler

If you want this control then wrap them in a DOM node that the parent controls. If you want to pass in values then use props and if you want to pass in values from higher up the tree, the new style RFC may be able to help.

I like use. But we would still need a noun to reference them by in the docs or libraries.

one problem with 'behavior' is that's the terminology we use to describe all of a component's encapsulated logic — methods, transitions, etc.

You should install the packages individually. Alternatively, you can install all of them at once with the svelte-material-ui package.

Passing the class prop to the root dom element is already a wide spread practice

It's a convention in Svelte to export { className as class } inspired from docs, but it's certainly not required by the compiler, so I don't think the class:directive can/should be assumed here.

Or if we formally took a stance that the class prop is THE ordained way to pass class attributes, though I don't think this functionality warrants this restriction.

On the one hand, it's an unofficial but widely-used practice to do let classNames=''; export { classNames as class }; in components and then apply that class on the top-level DOM element in the component. On the other hand, there are plenty of components out there that don't use this idiom

There are tools in Svelte that break this expectation to a degree, but they are a bit annoying to use, which makes it an active decision on the part of the developer. The API hints at the way we want you to do things because we feel that this will give the better experience.

Most of the linked issues, as well as this RFC, attempt to solve this problem by relaxing Svelte's CSS scoping rules, providing a better API with which to use global, or by manually passing down classes. We have never found this to be an acceptable solution which is why those issues have been closed. That position has not changed.

The above doesn't work for another unfortunate reason, it's not possible to write export let class = ''; instead CustomComponent because class is a reserved keyword and isn't allowed to be used as a variable name. The workaround would have to be to use some other prop name like maybe cssClass but then there's no "standard" by which all Svelte components can follow and every library will choose a different name which is cumbersome for users, because it creates scenarios like:

Also, since MS uses Canary/Dev/Beta, Beta has a concrete meaning and using that name to describe Dev would be misleading at best.

A # character always indicates a block opening tag. A / character always indicates a block closing tag. A : character, as in {:else}, indicates a block continuation tag.

Any deviations from this convention result in a more design-oriented and less user-oriented design.

Also notice that the component name Nested is capitalised. This convention has been adopted to allow us to differentiate between user-defined components and regular HTML tags.

Heat and work have signs (positive or negative), and the sign of each depends on whether the system we are considering is gaining or losing energy. In this class, if a process makes the system gain energy, qqq and/or www are positive; if the process makes the system lose energy, qqq and/or www are negative. We can put this information into four formal statements: If heat flows into a system, qqq is positive. If heat flows out of a system, qqq is negative If the surroundings do work on the system, www is positive. If the system does work, www is negative.

Discussion along these lines continued after the panel itself, as a few of the attendees convinced me to head out to dinner rather than straight up to bed (thanks for that, it was the first real meal of the day)

Is it “syncthing”, “Syncthing” or “SyncThing”?¶ It’s Syncthing, although the command and source repository is spelled syncthing so it may be referred to in that way as well. It’s definitely not SyncThing, even though the abbreviation st is used in some circumstances and file names.

we have RuboCop rules defined to codify some of our coding conventions

To follow conventions of naming across GitLab, and to further move away from the build term and toward job, some CI/CD environment variables were renamed for GitLab 9.0 release.

Some conventions reverse the order of priorities, considering lower values to be higher priority

If you really want to configure hundreds of ESLint rules individually, you can always use eslint directly with eslint-config-standard to layer your changes on top. standard-eject can help you migrate from standard to eslint and eslint-config-standard.

Then I modeled the the contributing.md and development.md after bundler's files and they use uppercase for those and so I did.

27$/year

On rare occasion two or more methods can be very tightly related. In these cases the methods can all go in a single file under the name of the method considered most significant. Usually files for the other methods should still be created that simply require the main file.