631 Matching Annotations
  1. Last 7 days
    1. Path parameters:

      • Identify a resource uniquely

      Request body:

      • Send and receive data via the REST API, often specifically to upload data.
      • Needs to adhere to REST API principles to be RESTful. Therefore for POST/PUT, needs to send the whole resource in the body.

      Query:

      • Mainly used for filtering. If you send a query asking for a large number of resources, use query parameters to filter the set of resources that you want. Example: You send a request to api/pictures/category/cat. You will now get all pictures with cats which could be millions. You can put in the query more specific parameters to clarify your request, such as: api/pictures/category/cat?color=black&breed=korat. Now you will get the subset of pictures of cats which havethe color black and are korat cats.
  2. Dec 2020
    1. 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.

      I like that we don't have to manually parse params/query out of the full request URI. It provides the data that you are most likely to need, in an readily/easily-usable form.

    1. Go is introducing publicly-visible API changes related to these issues in an upcoming major release, which risks making the vulnerabilities public without explicit public disclosure. 

      Whaaat ?!

    1. 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>
    2. 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>
    3. <script> export let items = []; export let colsNum = 3; $: cols = items.reduce(...); </script> {#each cols as col} {#each col as item} <slot {item} /> {/each} {/each}
    1. 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.
    2. I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.
  3. Nov 2020
    1. The Object.getPrototypeOf() method returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.

      internal: [[Prototype]]

      Other times we see something used to indicate it is internal. In fact, this even supersedes proto__. So why did they use a different naming convention? Did they decide [[ ]] is a better naming convention?

    1. Adapters are strictly versioned: any change to an adapter interface - associative or not - is considered breaking and will cause a major version update of the component.
    1. Capacitor is a framework that provides developers a coherent API set to access various features on different platforms. By doing so, it also simplifies using those features. Especially for web APIs that are hard to use or require multiple steps to set them up, Capacitor provides an easy-to-use interface.
    1. The details of what goes into a policy vary for each service, depending on what actions the service makes available, what types of resources it contains, and so on.

      This means that some kinds of validation cannot be done on write. For example, I've been able to write Resource values that contain invalid characters.

    1. However, this coalescing was very complicated, both in the specification and implementations, due to the dynamism of computed property names for accessors. Coalescing was a big source of overhead (e.g., in terms of code size) in polyfill implementations of "Stage 2" decorators.
    1. But using internal api's is dangerous as these may change when you update svelte. If you decide to use this, add a line to your project Readme.md mentioning which internal api's you used and why. Try to write it using other methods when you can.
    1. 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.
  4. Oct 2020
    1. React Final Form was written by the same guy (@erikras) that wrote Redux Form, so much of the API is exactly the same.
    1. You can set options.params to a POJO as shown above, or to an instance of the JavaScript's built-in URLSearchParams class. const params = new URLSearchParams([['answer', 42]]); const res = await axios.get('https://httpbin.org/get', { params });
    1. This assumes that the module has been given a well-defined, stable description (the interface in the sense of information hiding).
    1. 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).
    2. We want to improve this while keeping both the API and the semantics and behavior as Reactish as possible.
    1. Once again I am reminded of the importance of API 101 demos, and how I need to focus more in this area.

      I'd love to see a list of API 101 demos. This would be particularly cool if there were a DS106-esque site for content like this. Examples can be powerful things.

    1. My hope is that it will somehow bring comments on Facebook back to the blog and display them as comments here.

      Sadly, Aaron Davis is right that Facebook turned off their API access for this on August 1st, so there currently aren't any services, including Brid.gy, anywhere that allow this. Even WordPress and JetPack got cut off from posting from WordPress to Facebook, much less the larger challenge of pulling responses back.

    1. 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.
    2. For an API used by many third parties with many diverse uses cases, GraphQL is the right tool.
    1. You can add an attribute replace to replace the current entry in the history stack instead of adding a new one.
    1. 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).
    2. 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.
  5. Sep 2020
    1. 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.
    1. The onBlur function can take a SyntheticFocusEvent like it would if you had given it directly to an <input/> component, but you can also just call it: props.input.onBlur() to mark the field as blurred (inactive).
    1. tip no 8. API should be explicit!

      Optional props (which are not used) make the component less reusable.

      In my opinion, the API of a component should match strictly the values that are used. If the prop is a large object in which only a subset of of properties are used, then it is better to restrict the API to those set of properties.

  6. react-spectrum.adobe.com react-spectrum.adobe.com
    1. let {focusProps} = useFocus({ onFocus: (e) => setEvents((events) => [...events, 'focus']), onBlur: (e) => setEvents((events) => [...events, 'blur']), onFocusChange: (isFocused) => setEvents((events) => [...events, `focus change: ${isFocused}`]) });
    1. In general, my focus has shifted from optimization to DX. Partly because Svelte does a lot of the heavy lifting. For things that can be optimized on a need-to basis, I would rarely sacrifice DX.
    2. The language should work for developers, not the other way around.
    1. To avoid these complexities, it was decided to introduce an additional, intermediate service, which was called Translation Proxy. Translation Proxy is an intermediate software between WPML and the software of other companies offering translation services.
    1. The purpose (for me) in these bookmarks is to identify a space (or process) between Hypothesis and my IndieWeb commonplace site. I want to read, review, and share the link, salient quotes, and perhaps some context for others. The use of Hypothesis helps as I have another series of links behind to “show my work.”

      Bookmarks op je site zijn één van de meest traditionele vormen van bloggen en je eigen website vorm geven. Inderdaad kan Hypothesis helpen in het proces om de links van context te voorzien, ze bij elkaar te houden én via de Hypothesis API ze op allerlei manieren in je eigen systeem te krijgen. In welke vorm ze uiteindelijk in je eigen commonplace site/digital garden terecht komen, dat is aan je eigen creativiteit. Wat ik erg hoopgevend vind, is dat Hypothesis best wat metadata opslaat van de annotatie, wat weer mogelijkheden geeft voor andere dwarsverbanden, backlinks en digitaal "tuinieren".

  7. Aug 2020
    1. The straightforward solution to integrate WPML with third party translation services was to do it via dedicated plugins. A separate plugin for each company offering translation services could do the trick. However, this approach had a few drawbacks. For example, WPML developers would need to update and test all these plugins whenever the WPML core plugins received an update, and vice versa; when the API used by the external service changed, you needed to incorporate the change to WPML and test it as well.
    2. WPML knows how to communicate with the Translation Proxy, and the Translation Proxy knows how to communicate with translation services. If a Translation Service company happened to change their API, we needed to only update the Translation Proxy.
  8. Jun 2020
    1. You can use any Firebase Database URL as a REST endpoint. All you need to do is append .json to the end of the URL and send a request
    1. n an enterprise environment, you would likely use the express router and the code would probably look a little less verbose
    1. Serverless architectures refer to applications that significantly depend on third-party services (known as Backend as a Service or “BaaS”) or on custom code that’s run in ephemeral containers (Function as a Service or “FaaS”). This simply means the application developer does not need to worry about provisioning servers and scaling them but simply relies on infrastructure and services already built for all of that
  9. May 2020
    1. All API requests support performing an API call as if you were another user, provided you are authenticated as an administrator with an OAuth or Personal Access Token that has the sudo scope.
    1. AppCache was standardized in the Offline Web applications section of the HTML specification. The standard is formally referred to as application caches. New Web applications should be built around Service Workers. Existing applications that use AppCache should migrate to Service Workers. AppCache access was removed from insecure origins in M70. This intent addresses AppCache usage in secure origins.

      First and foremost, AppCache is a deprecated standard with serious architectural concerns. Second, Chrome's AppCache implementation is a security and stability liability. AppCache is documented as deprecated and under removal in MDN and in the WHATWG standard, and marked as obsolete in W3C’s HTML 5.1. It is incompatible with CORS, making it unfriendly for usage with CDNs. Overall, AppCache was changed in over 400 Chromium CLs in 2018-2019. It has imposed a tax on all of Chrome’s significant architectural efforts: Mojofication, Onion Souping, and the Network Service. The security benefits of the removal are covered under Security Risks.

    1. The iubenda Cookie Solution features a JS API for easy interaction with some of its main functions.
    2. callback {} (object) – This is the parameter through which you can define the callback that iubenda Cookie Solution can perform upon the occurrence of an event
    1. For a non-proxy integration, you must set up at least one integration response, and make it the default response, to pass the result returned from the backend to the client. You can choose to pass through the result as-is or to transform the integration response data to the method response data if the two have different formats. For a proxy integration, API Gateway automatically passes the backend output to the client as an HTTP response. You do not set either an integration response or a method response.

      integration vs method response

    1. Set up method response status code The status code of a method response defines a type of response. For example, responses of 200, 400, and 500 indicate successful, client-side error and server-side error responses, respectively.

      method response status code

  10. Apr 2020
    1. Invert the exit code of a process. Make 0 into 1 and everything else into a 0. An alternative to ! some-command syntax present in some shells.
  11. Mar 2020
    1. Change every detail of your pop-ups and bottom bars or build your own consent experience using the powerful JavaScript API.
    1. OpenAPI links are different than HAL links or HATEOAS links, because these links mainly specify the "flow" throughout the API methods.

    2. OpenAPI links do not require the link information present in the actual responses

      This means that these links mostly document the way this API can be traversed.

    3. traversal mechanism between the operations
    1. Javascript, APIs and Markup — this stack is all about finding middleground from the chaos of SSR+SPA. It is about stepping back and asking yourself, what parts of my page change and what parts don’t change?

      JavaScript, APIs and Markup (JAM Stack) - middleground between SSR + SPA.

      Advantages:

      • The parts that don’t change often are pre-rendered on the server and saved to static HTML files. Anything else is implemented in JS and run on the client using API calls.
      • Avoids too much data transfer (like the hydration data for SSR), therefore finds a good tradeoff to ship web content
      • Allows to leverage the power and cost of Content delivery networks (CDNs) to effectively serve your content
      • With serverless apps your APIs will never need a server to SSH into and manage
    1. For automated testing, include the parameter is_test=1 in your tests. That will tell Akismet not to change its behaviour based on those API calls – they will have no training effect. That means your tests will be somewhat repeatable, in the sense that one test won’t influence subsequent calls.
    1. Yes, it’s been deprecated. Why? Because too few people were using it to make it worth the time, money, and energy to maintain. In truth, although I sometimes disagree with the operator changes, I happen to agree with this one. Maintaining ALL of the synonyms takes real time and costs us real money. Supporting this operator also increases the complexity of the code base. By dropping support for it we can free up a bunch of resources that can be used for other, more globally powerful changes.
  12. Dec 2019
    1. To make some of this possible, we had to create our webpack configuration API, called webpack-chain. As you may know, webpack exposes a low-level configuration format, but this format isn't well-suited for merging configuration deterministically across middleware, or even across many projects. With webpack-chain, we expose a chainable or fluent API for aggregating a webpack configuration which is much more deterministic.
  13. Nov 2019
    1. 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).
    1. I'm considering this, although I'm still leaning towards not including it and I'd love to just get rid of first if it wouldn't break so many peoples tests. Newcomers to Capybara don't understand (or aren't willing to learn) the issues that all/first (and last if added) have and massively overuse them. Yes the fact that all and first now wait by default will prevent some of the new user issues/confusion, but it won't fix the non-reloadability issue.
    1. It makes sense that the incoherent render would not be committed to browser and that it would not have any consequences most of the time. But that means that you render logic must be ready to manage incoherency between props and states without crashing. E.g. a list of resource ids in props that doesn't match a list of http requests from a previous id list in the state could lead to weird situations. This is a worry that didn't exist in class components.
    1. 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.
    1. The result of the uniform interface is that requests from different clients look the same, whether the client is a chrome browser, a linux server, a python script, an android app or anything else

      Reason of the uniform interface - requests from different clients look the same

    2. The client can request code from the server, and then the response from the server will contain some code, usually in the form of a script, when the response is in HTML format. The client then can execute that code

      6) Code-on-demand (optional) - when the response is in HTML format, the response will come in form of a script, which can be executed

    3. data the server sends contain information about whether or not the data is cacheable. If the data is cacheable, it might contain some sort of a version number. The version number is what makes caching possible: since the client knows which version of the data it already has (from a previous response), the client can avoid requesting the same data again and again

      5) Cacheable - client can avoid requesting the same data again, thanks to remembering the version number of the cacheable data

    4. In order for an API to be RESTful, it has to adhere to 6 constraints

      6 constraints of RESTful API:

      1. uniform interface
      2. client - server separation
      3. stateless
      4. layered system
      5. cacheable
      6. code-on-demand (optional)
    5. there might be a number of servers in the middle. These servers might provide a security layer, a caching layer, a load-balancing layer, or other functionality

      4) Layered system - there's a number of server between the server and the response

    6. Stateless means the server does not remember anything about the user who uses the API

      3) Stateless - server doesn't store any history/information of user's requests

    7. client and the server act independently, each on its own, and the interaction between them is only in the form of requests, initiated by the client only, and responses, which the server send to the client only as a reaction to a request

      2) Client - server separation - client and server act independently, communicating through requests (client) and responses (server)

    8. Uniform interface

      1) Uniform interface has 4 parts:

      1. Request to the server includes resource identifier.
      2. Response from the server includes enough information so the client can modify the resource.
      3. Request to APi contains all the information server needs to perform the request, and vice versa.
      4. Hypermedia as the engine of application state - the server can inform the client, in a response, of the ways to change the state of the web application.
    1. What the server does when you, the client, call one of its APIs depends on 2 things that you need to provide to the server

      2 things required by the server:

      1. endpoint <--- identifier of a resource (its URL).
      2. HTTP method / verb <--- operation to perform: GET, POST, PUT, DELETE
    2. The representation of the state can be in a JSON format, and probably for most APIs this is indeed the case. It can also be in XML or HTML format

      JSON, XML or HTML <--- most popular formats of state representations

    3. It means when a RESTful API is called, the server will transfer to the client a representation of the state of the requested resource.

      Reason REST is named as REST:

      *REpresentational State Transfer*

    4. RESTful web application exposes information about itself in the form of information about its resources. It also enables the client to take actions on those resources, such as create new resources (i.e. create a new user) or change existing resources (i.e. edit a post).

      RESTful web application

  14. Oct 2019