You don't need a separate agent API. You need to look at every `input()` call, every CWD assumption, every pretty-printed-only output, and ask: what if the user on the other end is a process, not a person?

In API design, exceptional use cases may justify exceptional support. You design for the common case, and let the edge case be edge. In this case, I believe lib deserves ad-hoc API that allows users to do exactly that in one shot:

Well-thought-out, idiomatic APIs

Diet YAML is a light weight version of YAML that removes much of the complex aspects of the mainline YAML specification.

This gem is just one concern with one scope. If you want to customize it later you can simply copy the code directly into your project.

now that I realize how easy it is to just manually include this in my app: <%= javascript_include_tag 'xray', nonce: true if Rails.env.development? %> I regret even wasting my time getting it to automatically look for and add a nonce to the auto-injected xray.js script

The new 2.1 version comes with a few necessary but reasonable changes in method signatures. As painful as that might sound to your Rails-spoiled ears, we preferred to fix design mistakes now before dragging them on forever.

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.

this second approach, while more verbose, sort of spells out better where things are coming from. (I like it, in other words.)

page is a { host, path, params, query } object where host is the URL's host, path is its pathname, params is derived from path and the route filename, and query is an object of values in the query string.

The best solution that I found while trying to build a masonry component was to package up a pair of components and place child components inside a wrapper - I chose CardLayout and Card such that users would write something like: <CardLayout> <Card><MyBeautifulCard /></Card> <Card><AnotherCard /></Card> </CardLayout>

Hm, React-way is really hacky... When we talking about lists, masonry, or any other table-style components, first of all, we talk about arrays and iteration through them. If you iterate over the children in the Masonry component, somewhere (in parent component I guess) you also iterate over the actual items. Over and over again, in all places you use this component, you perform almost the same iteration twice. Why we should do this? I believe the interface of this kind of components should look like this: <Masonry {items} {colsNum} let:item> <SomeItemComponent>{item}</SomeItemComponent> </Masonry>

<script> export let items = []; export let colsNum = 3; $: cols = items.reduce(...); </script> {#each cols as col} {#each col as item} <slot {item} /> {/each} {/each}

I think the main difference between the two are the way API are served. Some smelte components need you to input big chunk of json as props, while i prefer keep props as primitive types and in the other hand give you different components tags to compose.

StackProf.start(mode: :cpu) StackProf.stop StackProf.results('/tmp/some.file')

We get a boilerplate-free API where shared state has the same simple get/set interface as React local state (yet can be encapsulated with reducers etc. if needed).

I couldn't land on how I wanted to box primitives. Should I use a getter/setter, or function form like Knockout, or explicit get/set like MobX? These were all ugly.

However, if you want to create a backend API that is meant to be consumed only by your frontend, then you don't need REST nor GraphQL — RPC, such as Wildcard, is enough.

This library exports a single React Hook, useMethods, which has all the power of useReducer but none of the ceremony that comes with actions and dispatchers.

In Formik, validateOnBlur defaults to true and it allows you to tell Formik not to validate on blur. React Final Form validates on every change by default, and setting validateOnBlur to true is a way to tell React Final Form to only validate on blur (to not validate on change).

both copied much of their API from Redux Form, so, despite working very differently under the hood, there is a lot of overlap in their APIs.

detach, as an api, should be declarative (ensure the node is detached) instead of imperative (detach the node), allowing it to be called multiple times by performing a noop if the node is already detached. This way, it won't matter if the node is removed from the DOM from outside of svelte.

The feature is highly likely to be implemented, the API and implementation are the only real topics of discussion right now.

When it comes to building HTTP APIs, other frameworks weigh you down with tons of dependencies and unnecessary abstractions. Falcon cuts to the chase with a clean design that embraces HTTP and the REST architectural style.

When the grid is initialised, it will fire the gridReady event. If you want to use the API of the grid, you should put an onGridReady(params) callback onto the grid and grab the api from the params. You can then call this api at a later stage to interact with the grid (on top of the interaction that can be done by setting and changing the props).

REST and GraphQL are wonderful tools to create an API that is meant to be consumed by third parties. Facebook's API, for example, is consumed by ~200k third parties. It is no surprise that Facebook is using (and invented) GraphQL; a GraphQL API enables third parties to extensively access Facebook's social graph enabling them to build all kinds of applications. For an API with that many consumers, GraphQL is the fitting tool. But, to create an internal API (an API developed and consumed by code written by the same organization), RPC offers a simpler and more powerful alternative. Large companies, such as Netflix, Google and Facebook, are starting to replace REST/GraphQL with RPC for their internal APIs. Most notably with gRPC which is getting popular in the industry.

Do you need to learn code to use The Grid? No coding is required to use The Grid. Just do what you're already doing on Facebook, Twitter, Instagram, etc. Post images, video, and content to your site and our AI Designer will make it beautiful. If you know code, you can extend functionality using our platform tools and API.

Can I migrate my existing website into The Grid? We will provide tools so that you can migrate your existing website, however, there will be some limitations depending on how your website was built. In addition, third parties can use our APIs to build tools that can add additional functionality for migrating content.

While the Atom Protocol specifies the formats of the representations that are exchanged and the actions that can be performed on the IRIs embedded in those representations, it does not constrain the form of the URIs that are used. HTTP [RFC2616] specifies that the URI space of each server is controlled by that server, and this protocol imposes no further constraints on that control.