The absence of a method name here is per design: this object does only one thing, and hence what it does is reflected in the class name.

As we know, naming is hard.

Another thing I don’t like is the name of the config file manifest.js. Internally Sprockets has the concept of a manifest already Sprockets::Manifest, but the two aren’t directly coupled. We also already have a “manifest” JSON file that gets generated in public/assets/ and has manifest in the name .Sprockets-manifest-140998229eec5a9a5802b31d0ef6ed25.json. I know one is a JS file and one is a JSON file, but it’s a bit confusing to talk about.

The link name is not very helpful, it doesn’t explain what it does very well.

Most C++ template idioms will carry over to D without alteration, but D adds some additional functionality

There are two definitions of ‘Enterprise’ 1 - Enterprise as a business. In fact, in French, ‘enterprise’ literally means ‘business’ 2- Enterprise as a large business. This is the most common use of the term in business, differentiating between small, medium, and large businesses. In this context, there is no official rule, however it is generally accepted for enterprise to mean companies with over 1,000 employees and/or $1B in revenue

termini (or “ends” as we used to call them).

outcome.valid?

if outcome.success?

value returned from #execute

By convention, we call this an outcome

Call .run on your interaction to execute it.

Hopscotch

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

Why process, not save? This is entirely up to you. However, it's good to stay consistent across your team so there's no confusion. I began using save but found there are some cases for forms where you aren't saving anything, such as when you are just triggering a job or push-notification. I found using process fits more cases so that's what I use. This is also typically the only method that is public on my forms.

@conference_form.submit(conference_params)

    @conference_form = ConferenceForm.new(conference)
    @conference_form.submit(conference_params)

    if @conference_form.save

Unlike naming children, coding involves naming things on a daily basis. When you write code, naming things isn’t just hard, it’s a relentless demand for creativity. Fortunately, programmers are creative people.

If we renamed things more often, then it probably wouldn’t be so hard to name them in the first place.

We also find it hard to agree on what good names and bad names look like, which makes it hard to know when renaming improves a name.

This is funny because it’s unexpected. Cache invalidation sounds like a hard thing, while naming sounds more straightforward. The joke works because it violates our expectation that hard things should be technical. It’s also funny because it’s true.

First of all, we want names to exhibit truth and beauty: to be the right names, and to make our code clean and beautiful. At least, this is what we want to think about our code, but naming’s importance is far more practical.

Naming is communication

Naming matters for both idealogical and practical reasons.

Naming is just one part of the micro-design activity that we call programming. If design weren’t hard, we wouldn’t find good design so satisfying.

Anyone who has ever tried to name a child knows that naming is hard. Naming things in code is harder. It’s bad enough that you have to commit to a name that someone isn’t going to like. You also have to be able to live with it.

There’s only one hard thing in Computer Science: human communication. The most complex part of cache invalidation is figuring out what the heck people mean with the word cache. Once you get that sorted out, the rest is not that complicated; the tools are out there, and they’re pretty good.

When you use this syntax the lines on either end of the areas are actually getting named automatically.

Notice that you’re not naming lines with this syntax, just areas.

Is store the right name? (session?)

Maybe something more neutral just meaning a virtual element / no-element container would better express the intention? And regarding the syntax, maybe it would also feel less repetitive / boilerplaty than <svelte:slot slot="name" />... Maybe something like <svelte:fragment slot="name"> or <svelte:virtual slot="name">?

Also agree that <svelte:slot> is perhaps a little confusing since it replaces the slot attribute rather than the slot element, so <svelte:fragment> would make more sense

Just to reiterate the discussion on the RFC, there was a suggestion that we change <svelte:slot slot="foo"> to <svelte:fragment slot="foo">, since it's the counterpart to a <slot> rather than an equivalent to it

Convention in Java, and I believe most other languages, is to use Listener suffix for historical reasons!

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.

Microsoft announced IronRuby, which uses the same name as Wilco Bauwer's IronRuby project with permission.

@import is also a CSS feature, and the differences can be confusing

We could potentially have another flag that was your definition of dirty, but then we run into the hard problem in computer science: naming things.

In a browser, deep-diff defines a global variable DeepDiff. If there is a conflict in the global namespace you can restore the conflicting definition and assign deep-diff to another variable like this: var deep = DeepDiff.noConflict();.

I vote for calling it let Could be used like this {#let foo = initialValue}. It's closer to javascript

I expressed doubts about the name with because of its existing meaning in javascript, which is a fair point from my past self.

The other module on npm that I found to do this

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

their name gives no mnemonic boost whatsoever. Whatever faint associations it might once have held fade away, especially when the discover was neither famous nor narrow, and the reader is several generations removed.

The worst answer I can imagine is the one Pope Gregory VII gave for refusing to let the Holy Scripture be translated out of Latin: “... [I]f it were plainly apparent to all men, perchance it would be little esteemed and be subject to disrespect; or it might be falsely understood by those of mediocre learning, and lead to error.”

remaining: 0, callbacks: [] r: 0, // remaining outros c: [], // callbacks p: outros // parent group

Why the obfuscation of remaining to r and callbacks to c? This is fine for function-local variables but in this instance makes the code significantly harder to reason about? There is no notion of what c and r mean.

But I just want to say npx is lame. It should have been npm run or npm exec or something.

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.

if this does land, my vote is for smoosh

For the actual name of the thing, I like behaviors more than enhancers. That might be too limiting but I can't think of using this for styles or something that I wouldn't call a behavior. traits is also nice. Hey, decorators works too.

While there is some precedence in other frameworks for using as, the word doesn't fit well. Since you are adding functionality to elements I like the word add better (and it only has 1 more character).

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

What do you think of one of these: "actions", "enhancements", "additions" or "extensions"? My vote goes to "actions". It is short but it has meaning, as do the others.

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

To differentiate <style scoped> from the existing top-level <style> elements, I propose that we refer to these as 'local scoped styles'.

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:

It was called a "virtual DOM" library because it didn't start out as isomorphic, but actually tied to the DOM from the start. It was an afterthought to make it isomorphic.

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.

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.

The folks at Netlify created Netlify CMS to fill a gap in the static site generation pipeline. There were some great proprietary headless CMS options, but no real contenders that were open source and extensible—that could turn into a community-built ecosystem like WordPress or Drupal. For that reason, Netlify CMS is made to be community-driven, and has never been locked to the Netlify platform (despite the name).

This change was made because GitLab License Management is now renamed to GitLab License Compliance. After review with users and analysts, we determined that this new name better indicates what the feature is for, aligns with existing market terminology, and reduces confusion with GitLab subscription licensing features.

If the add-on is a fork of another add-on, the name must clearly distinguish it from the original and provide a significant difference in functionality and/or code.

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

It’s true that there are two hard problems in computer science and one of them is naming things. Why? Because good names are important. A good name teaches about purpose and responsibility, so you have to spend some time thinking about it.

You don't "sanitize your output" you encode it for proper context within the application it is being presented. You encode the output for HTML, HTML Attribute, URL, JavaScript

I would call this output encoding instead of sanitization

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

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.

Don't be discouraged when you get feedback about a method that isn't all sunshine and roses. Facets has been around long enough now that it needs to maintain a certain degree of quality control, and that means serious discernment about what goes into the library. That includes having in depth discussions the merits of methods, even about the best name for a method --even if the functionality has been accepted the name may not.

kasper-netcdf.zip

pattern library with the specific goal of naming and shaming deceptive user interfaces

chart the index finger as the 2nd finger, middle finger as the 3rd, ring finger as the 4th, and pinky as the 5th finger

PHP variables begin with the dollar symbol $ and PHP variable names adhere to the following rules:• Names are case sensitive• Names may contain letters, numbers, and the underscore character• Names may not begin with a number

return <Lower

Therefore, it's easy to search around for tweets/blog posts/talks that say "ES7 Decorators" and find that it's become the accustomed name for it.

Part of the issue is precisely around naming things, and as we often hear, naming things is hard.

child

The idea is that the additional prefix _ of a Null Component symbolizes that it adds even less to the DOM than an Injector. I picture the name falling through to become just the _, like the unused argument convention in javascript functions: const handleEvent = (_, id) => { console.log(id) } .

Эргонимика Изучает наименования деловых объединений людей.

Why Siding 14?  It's  a nod to our rich Alberta and western Canadian railway heritage.  Before the town of Ponoka was named, it was Siding 14 of the Calgary-Edmonton Railway Company.  The siding was a supply point  for steam locomotives making the run between the two major cities.  The railway  not only provided transportation between small towns and major centers, it was  historically the heart of communication and social interaction in communities across the province.

selector: 'admin-users'

(Again, this is in no way a proposal for how the URLs should be structured.)