People want to be able to choose which service they use to communicate with people. However, today if you want to message people on Facebook you have to use Messenger, on Instagram you have to use Direct, and on WhatsApp you have to use WhatsApp. We want to give people a choice so they can reach their friends across these networks from whichever app they prefer.We plan to start by making it possible for you to send messages to your contacts using any of our services, and then to extend that interoperability to SMS too. Of course, this would be opt-in and you will be able to keep your accounts separate if you'd like.

But what should you write about? Simply ask yourself, What's bothering you most right now? Write a post where you work through that—and get to a conclusion. This is how I start every time. Writing is therapy that you publish for the world to learn from.

First, choose your topicThe best topic to write about is the one you can’t not write about. It’s the idea bouncing around your head that urges you to get to the bottom of it.You can trigger this state of mind with a two-part trick. First, choose an objective for your article:Open people’s eyes by proving the status quo wrong.Articulate something everyone’s thinking about but no one is saying. Cut through the noise.Identify key trends on a topic. Use them to predict the future.Contribute original insights through research and experimentation.Distill an overwhelming topic into something approachable. (This guide.)Share a solution to a tough problem.Tell a suspenseful and emotional story that imparts a lesson.Now pair that objective with a motivation:Does writing this article get something off your chest?Does it help reason through a nagging, unsolved problem you have?Does it persuade others to do something you believe is important?Do you obsess over the topic and want others to geek out over it too?That’s all that's needed: Pair an objective with a motivation. Now you have something to talk about.

I came up with this solution by piecing together man pages and random google result. I was surprised at how many incomplete and inaccurate answers were out there. What may have been more surprising was the complete lack of a full intact solution.

Looking at all those bearing, heading, orientation, navigation, position, direction, etc. I think we have a bigger problem here. Someone has decided how to use tag (e.g. orientation is about page orientation), but there are 100 other cases. Imho, to disallow misusing there should be no "heading", but rather "html-heading", "gps-heading", "whatelse-heading", which make mistakes impossible. So yes, "heading" should go.

It took a lot of searching around to find that variable.

By using deploy keys, you don’t have to set up a fake user account.

I use a mutator and use it's changeValue function to 'change' the value of the relevant field (I supply the same value). This in turn notifies all relevant parties of the change to the form's state, and a validation is triggered.

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

we update the validation schema on the fly (we had a similar case with a validation that needs to be included whenever some fetch operation was completed)

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 only tricky part is that the error will come back as meta.submitError, so you need to check for both when displaying your error.

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

I'd be happy to take on this issue, if no one else has up to this point!

But also, if you do want to use separate functions and have your dependencies still counted, you can make all of the relevant dependencies be arguments to those functions, so the compiler can see them in the reactive block.

Focus on your application: forget about forms details like I'm dirty, field touched...

What would happen if we get the list from a rest api when the form component is mounted? That's an interesting topic, you can add a rule once a component has been mounted and update the associated validation schema.

Ok, I have seen that there are lot of built-in and third party validations, but sooner or later I will face a validation rule not covered by this buffet. Can I build a custom one? Of course you can!

On the other hand, handling form validation on your own can be tempting, but you have to cover scenarios like:

You can try to build a solution to tackle these issues on your own, but it will cost you time and money... why not use a battle-tested solution to handle all this complexity?

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Form validation can get complex (synchronous validations, asynchronous validations, record validations, field validations, internationalization, schemas definitions...). To cope with these challenges we will leverage this into Fonk and Fonk Final Form adaptor for a React Final Form seamless integration.

Managing Form State (holding field information, check if a control has been touched, if the user has clicked the submit button, who owns the current focus...) can be tedious and prone to errors. We can get help from React Final Form to handle these challenges for us.

Use the same value that was submitted, which ensures that a 'change' is triggered even though the value itself doesn't change. Therefore, the same value gets validated again.

  mutateValue([name], state, { changeValue }) {
    // change the value to the same value, thus
    // triggering a revalidation of the same value
    changeValue(state, name, value => value);
  }

In the context of software engineering, I've always used "dependent" and "dependee".

Oops, I had not read your original description closely enough.

But it sounds like the library could use some way to setTouched()

you took 4 hours to respond, so I implemented it myself

There's an issue #3368 for describing better what triggers reactive updates, as I do think there is some stuff we could be more explicit about

Anyway, If this is an expected behaviour, we should probably add an asterisk to the docs, describing the pitfall, because I believe many will be bitten by this.

we do need to have this somewhere

if you make a shallow copy, it works

SQL regular expressions are a curious cross between LIKE notation and common (POSIX) regular expression notation.

Mr Dutton will renew his attack on Facebook and other companies for moving to end-to-end encryption, saying it will hinder efforts to tackle online crime including child sexual abuse.This month, Australia joined its "Five-Eyes" intelligence partners – the United States, Britain, New Zealand and Canada – along with India and Japan, in signing a statement calling on tech companies to come up with a solution for law enforcement to access end-to-end encrypted messages.

I have a feature spec to test the Javascript behavior of the blur event, sadly Capybara's native DSL doesn't seem to support it yet.

The idea of the hermeneutic circle is to envision a whole in terms how the parts interact with each other, and how they interact with the whole. That may sound a little bit out there, so let’s have a look at a concrete example.

This reactive statement is just used to have the store automatically subscribed and unsubscribed.

I'm not sure I understand the problem, everything you are describing is already possible.

Svelte right now has a lot of opportunities to have component state become out of sync with props.

I'm suggesting this is a problem generally. Users will not think of being out of sync with props

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

I highly recommend setting a higher bound on the number of returned entities by each resolve function in your code.

withindex.js, we have a single source of truth, giving fine grained control on what we expose to the outside world.

The index.js file is the main entry point and imports and exports everything from internal.js that you want to expose to the outside world.

This does solve the problem, but now our project and API is structured differently. In large projects it might be very hard to determine how to pull this trick off, or even impossible!

In a large code base, this will result in moving imports randomly around until stuff just happens to work. Which is often only temporary, as a small refactoring or change in import statements in the future can subtly adjust the module loading order, reintroducing the problem.

To silence circular dependencies warnings for let's say moment library use: // rollup.config.js import path from 'path' const onwarn = warning => { // Silence circular dependency warning for moment package if ( warning.code === 'CIRCULAR_DEPENDENCY' && !warning.importer.indexOf(path.normalize('node_modules/moment/src/lib/')) ) { return } console.warn(`(!) ${warning.message}`) }

Any software that makes HTTP requests to other sites should make it straightforward to enable the use of a cache.

Take responsibility for your outgoing network traffic If you install software that interacts with other sites over the network, you should be aware how it works and what kind of traffic it generates. If it has the potential to make thousands of requests to other sites, make sure it uses an HTTP cache to prevent inflicting abuse on other sites.

Identify your user agents When deploying software that makes requests to other sites, you should set a custom User-Agent header to identify the software and provide a means to contact its maintainers. Many of the automated requests we receive have generic user-agent headers such as Java/1.6.0 or Python-urllib/2.1 which provide no information on the actual software responsible for making the requests.

It is not appropriate to use these document types for live content. These are made available only for download, to support local use in development, evaluation, and validation tools. Using these versions directly from the W3C server could cause automatic blockage, preventing them from loading. If it is necessary to use schemata in content, follow guidelines to avoid excessive DTD traffic. For instance, use caching proxies to avoid fetching the schema each time it is used, or ensure software uses a local cache, such as with XML catalogs.

A simple rule of thumb: the name of the updated variable must appear on the left hand side of the assignment. For example this... const foo = obj.foo; foo.bar = 'baz';...won't update references to obj.foo.bar, unless you follow it up with obj = obj.

Longstanding controversy surrounds the meaning of the term "hacker". In this controversy, computer programmers reclaim the term hacker, arguing that it refers simply to someone with an advanced understanding of computers and computer networks[5] and that cracker is the more appropriate term for those who break into computers, whether computer criminals (black hats) or computer security experts (white hats).

One of Svelte's advantages, for me, is that I can test out ideas with relatively few lines of code. the #with feature could save me from adding a separate component for the content of an #each loop. I get frustrated when I have to create a new file, move the content of the #each clause, import it as a component, and add attributes and create exports for that, and implement events to send messages back, and event handlers, when I just wanted to test a small feature.

Wondering how to get field state from multiple fields at once? People coming from Redux-Form might be wondering where the equivalent of Redux Form's Fields component is, as a way to get state from several fields at once. The answer is that it's not included in the library because it's so easy to write one recursively composing Field components together.

One of the significant differences between the two is that a call to a partially applied function returns the result right away, not another function down the currying chain; this distinction can be illustrated clearly for functions whose arity is greater than two.

Looks like the problem is that debounce defaults to waiting for 0 ms ... which is completely useless!

It looks like you accidentally passed resolve() (immediately invoking the function) directly to setTimeout rather than passing a function to invoke it. So it was being resolved immediately instead of after a 1000 ms delay as intended.

You should not create a new debounce function on every render with: return new Promise(resolve => { debounce(() => resolve(this.getIsNameUnique(name)), 2000); }); Instead you should just wrap your whole function isNameUnique with the debounce (see my sandbox). By creating a new debounce function on every hit, it cannot 'remember' that is was called or that is will be called again. This will prevent the debouncing.

_.debounce creates a function that debounces the function that's passed into it. What your s.search function is doing is calling _.debounce all over again every time s.search is called. This creates a whole new function every time, so there's nothing to debounce.

I run s.search() by typing into an input box, and if I type gibberish very quickly, the console prints out "making search request" on every key press, so many times per second -- indicating that it hasn't been debounced at all.

they're not invoking the function that _.debounce returns

If you define a variable outside of your form, you can then set the value of that variable to the handleSubmit function that 🏁 React Final Form gives you, and then you can call that function from outside of the form.

Also, if you don't put that implementation of URLSearchParams in the global scope you're not using it as a polyfill but a ponyfill, and those are meant for your code, not for external dependencies.

Sometimes we can’t implement a solution that’s fully spec-compliant, and in those cases using a polyfill might be the wrong answer. A polyfill would translate into telling the rest of the codebase that it’s okay to use the feature, that it’ll work just like in modern browsers, but it might not in edge cases.

Use ponyfill.com for linking here.

"doesn't work" is meaningless

Using the keyboard arrows, navigate down the suggestion list to the item(s) you want to remove from the Chrome autofill suggestions With the suggestion highlighted, use the appropriate keystroke sequence to delete the Chrome suggestion:

FI:

Once again, this isn’t good or bad, it’s just the most efficient way to create something that is similar to something else

This isn’t to say that multiplying code is good or bad – it’s a characteristic of all code regardless of quality.

Anyone who’s ever worked with me knows that I place a very high value on what ends up checked-in to a source code repository.

The reason for this is very simple: once code gets checked-in, it takes on a life of its own.

Checking in is akin to sharing your code with others, and once out in the world, it’s hard to predict what that code will do.

I'm okay with an overall design that allows people to plugin the parts they need in order to be able to generically support a compile-to-javascript language, but to bake in support for one singular solution because its popular is simply bad engineering.

Of all the compile-to-languages, the one that strikes me as having the least merit is JSX. It's basically a ton of added complexity for the sake of what boils down to syntax. There are no real gains in terms of language semantics in JSX.

Furthermore, JSX encourages bad non-dry code. Having seen a lot of JSX over the past few months, its encourages copypasta coding.

I know where you're coming from, and to a degree, I think you're right.

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

hyperscript is much simpler to refactor and DRY up your code than with JSX, because, being vanilla javascript, its easier to work with variable assignment, loops and conditionals.

The only "issue" it has is that its unfamiliar. People have been working with HTML for years and are comfortable with it. That's basically the only reason that people find it more readable. If you make an effort to spend sometime with hyperscript, it becomes as familiar and readable as jsx.

However, as a developer that uses JSX, I find it too useful/concise to give up in the name of syntax purity, especially when I know that what it translates to is still very isolated and computationally pure.

This is the problem with baking in support for frameworks with special cases in the codebase. You can never support all the frameworks. :-(

I've recently started playing with segmentio/deku, an alternative to React, and I'm also using Babel to transpile my js and jsx code.

The reason why we don't just create a real DOM tree is that creating DOM nodes and reading the node properties is an expensive operation which is what we are trying to avoid.

This module is similar to JSX, but provided as a standards-compliant ES6 tagged template string function.

if you think this project can help you or anyone else, you may star it on GitHub

For the sake of best compatibility we convert the className attribute to class for svelte.

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

We aim to support all svelte features. In some cases this is not possible. For those cases we provided feasible workarounds.

jsx currently does not allow to use : in attribute/property names. As a workaround every : can be replaced be _ (for example bind_value is converted to bind:value for svelte).

The goal is to bring element creation down to this logic:

In React 0.12 time frame we did a bunch of small changes to how key, ref and defaultProps works. Particularly, they get resolved early on in the React.createElement(...) call. This made sense when everything was classes, but since then, we've introduced function components. Hooks have also make function components more prevalent. It might be time to reevaluate some of those designs to simplify things (at least for function components).

However, in function components there really isn't much need for this pattern since you can just use JS default arguments

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

Good risk management is inherently simple; adding too many complexities increases the likelihood of overlooking the obvious.

I recommend folks use https://github.com/shama/bel instead of this package; we've been working hard on it for the past two years to make sure it has all the features you could want to write inline HTML. Hope it's good; closing for now!

By default all content inside template strings is escaped. This is great for strings, but not ideal if you want to insert HTML that's been returned from another function (for example: a markdown renderer). Use nanohtml/raw for to interpolate HTML directly.

Hyperscript syntax for React.js markup

However, this would lead to further divergence. Tooling that is built around the assumptions imposed by template literals wouldn't work. It would undermine the meaning of template literals. It would be necessary to define how JSX behaves within the rest of the ECMAScript grammar within the template literal anyway.

Deku is a library for rendering interfaces using pure functions and virtual DOM.

It also aims to support only modern browsers to keep things simple.

One of the inherent dangers of any form of iterative development is confusing iteration with oscillation.

However, know when to be inconsistent -- sometimes style guide recommendations just aren't applicable.

When applying the guideline would make the code less readable, even for someone who is used to reading code that follows this PEP.

although this is also an opportunity to clean up someone else's mess

To be consistent with surrounding code that also breaks it (maybe for historic reasons)

An onevent event handler property serves as a placeholder of sorts, to which a single event handler can be assigned. In order to allow multiple handlers to be installed for the same event on a given object, you can call its addEventListener() method, which manages a list of handlers for the given event on the object.

Then at some moment I just stumbled upon limitations and inexpressiveness of templates and started to use JSX everywhere — and because JSX was not a typical thing for Vue I switched to React over time. I don’t want to make a step back.

But the vast majority of things that our apps are doing are just conditional and list rendering.

In my opinion it is okay to say your tool is revolutionary compared to existing ones. And it is hard to be fully unbiased about your own creation, I get it.

Tables are not yet supported. If you love impossible to read regular expressions, submit a PR!

I suppose it all comes down to tooling. It should be easy to author a pattern. A set of implicit (possibly explicit) patterns to author patterns may be useful.

Thank you to those who have failed many times, yet never gave up

A reasonably clean alternative would be to map a function over the array and use destructuring in the each loop: {#each [1, 2, 3, 4].map(n => ({ n, sqr_n: n * n })) as { n, sqr_n }} {sqr_n} {sqr_n / 2}<br> {/each}

I discovered that a solution can be hacked using an {#if}, but a proper one would be nice:

Every new variation to the view requires updating both the view model and the template. This holds true even for simple variations.

Offsetting the rules of a logic-less template requires a lot of helper methods.

Writing a logic-less template requires a bloated view model with comprehensive getters for the raw data. As a result, a messy and difficult-to-maintain view model usually accompanies logic-less templates.

that does not mean that I am advocating the other extreme–i.e., a templating language that allows a lot of logic. I find such templating languages, especially those that allow the host programming languages to be used inside the template, to be hard to read, hard to maintain, and simply a bad choice.

It's certainly something I've wanted to reach for prior

An alternative (maybe not good) would be to restrict {@const} to certain blocks like {#each} and {#if}. In both cases, it significantly reduces the "multiple ways to do the same thing" problem and avoids ergonomic and performance overhead of our current situation.

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.

I had this problem and figured out how to make something like this work with the compiler quirks.

Here's a proxy store I wrote to derive the value of a store nested within other stores, it plays nice with typescript and can go infinitely deep