REST

the methods defined by HTTP are part of the Web’s architecture definition, not the REST architectural style

most folks who use the term are talking about REST without the hypertext constraint

Should any one stumble upon this issue @tenderlove reverted commit a8bf129 in a71350c which is in v5.0.0.beta1 and later.

Today “REST” and “RESTful architecture” are widely used terms,and sometimes even used appropriately.

Clients interact with a service by exchanging representations of resources.

A primary advantage of REST over HTTP is that it uses open standards, and does not bind the implementation of the API or the client applications to any specific implementation.

Protecting and practicing fallow time is an act of resistance; it can make us feel out of step with what the prevailing culture tells us.

Fielding’s dissertation (titled “Architectural Styles and the Design of Network-based Software Architectures”) is not about how to build APIs on top of HTTP but rather about HTTP itself.

如何理解 restful 中操作的无状态 “stateless”?

WEB开发中，使用JSON-RPC好，还是RESTful API好？

怎样用通俗的语言解释REST，以及RESTful？

如何获取（GET）一杯咖啡——星巴克 REST 案例分析

I would like to understand this design then. In my experience it has only served to limit what I can achieve, and gained me no additional benefit.

Take regular breaks

Everything else in this issue is just figuring out how to make that happen, which turns out to be rather involved.

Results indicate that participants were more likely to interact with their smartphone the more fatigued or bored they were, but that they did not use it for longer when more fatigued or bored. Surprisingly, participants reported increased fatigue and boredom after having used the smartphone (more). While future research is necessary, our results (i) provide real-life evidence for the notion that fatigue and boredom are temporally associated with task disengagement, and (ii) suggest that taking a short break with the smartphone may have phenomenological costs.

ust an aside about "tools for thought," a burgeoning attention-sump in some circles. I seldom notice mention of the following: A walk. A shower. A good night's sleep. Introspection and reflection. I don't know that we understand "thought" well enough to design tools to improve it. But we do love our cleverness and the artifacts thereof. We can see those, and, more importantly, show them to others! We can talk about them, criticize them, modify them, endlessly.

When you see a job post mentioning REST or a company discussing REST Guidelines they will rarely mention either hypertext or hypermedia: they will instead mention JSON, GraphQL(!) and the like.

The creator of GraphQL admits this. During his presentation on the library at a Facebook internal conference, an audience member asked him about the difference between GraphQL and SOAP. His response: SOAP requires XML. GraphQL defaults to JSON—though you can use XML.

Conclusion There are decades of history and a broad cast of characters behind the web requests you know and love—as well as the ones that you might have never heard of. Information first traveled across the internet in 1969, followed by a lot of research in the ’70s, then private networks in the ’80s, then public networks in the ’90s. We got CORBA in 1991, followed by SOAP in 1999, followed by REST around 2003. GraphQL reimagined SOAP, but with JSON, around 2015. This all sounds like a history class fact sheet, but it’s valuable context for building our own web apps.

which I hope would extend to iframes.

Or Google Maps?

APIs that simply map CRUD actions to HTTP verbs have nothing to do with Application State Transfer. You can call them Web APIs or HTTP APIs, but please don’t call them RESTful.

The key thing about the REST approach is that the server addresses the client state transitions. The state of the client is almost totally driven by the server and, for this reason, discussions on API versioning make little sense, too. All that a client should know about a RESTful interface should be the entry point. The rest should come from the interpretation of server responses.

In fact, most people believe that to build a RESTful API you can simply create an API based on URLs and HTTP verbs. This is absolutely false. This misunderstanding is going around for too long.

"links": { "deposits": "/accounts/12345/deposits", "withdrawals": "/accounts/12345/withdrawals", "transfers": "/accounts/12345/transfers", "close-requests": "/accounts/12345/close-requests" } } } The response contains these possible follow-up links: POST a deposit, withdrawal, transfer, or close request (to close the account).

The client transitions through application states by selecting from the links within a representation or by manipulating the representation in other ways afforded by its media type. In this way, RESTful interaction is driven by hypermedia, rather than out-of-band information.

Feature GraphQL REST

There are advantages and disadvantages to both systems, and both have their use in modern API development. However, GraphQL was developed to combat some perceived weaknesses with the REST system, and to create a more efficient, client-driven API.

Climate scientist Katharine Hayhoe stresses the need for finding shared values, rather than trying to change someone’s mind, as a basis for productive conversations

Thanks for the rest of the story.

HTTP REST seems like an "out of external dependency" way to go.

Uses Pydantic which enforces type hints at runtime.

gRPC can use protocol buffers as both its Interface Definition Language (IDL) and as its underlying message interchange format

protocol buffers as the Interface Definition Language (IDL) for describing both the service interface and the structure of the payload messages.

The gRPC infrastructure decodes incoming requests, executes service methods, and encodes service responses.

What's the point of playing a game featuring fjords without also including vikings to pillage the other player's lands...I've actually developed two additional tiles for Fjords: The Dragon and The Marauding Hoard. Both do exactly that.(I've play tested them with a friend well over 40 times and we both agree that with an expanded set of Fjords tiles, these two greatly improve the game for us. I'll write the tiles up and post them to BGG... eventually)

locked and limited conversation to collaborators

A resource route maps a number of related requests to actions in a single controller.

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

Unfortunately, it is an expression mired with a negative context because of how Rumsfeld used it to lie.

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!

@subfuzion That error looks unrelated to the existing discussion.

Wow, no answers to this question. That's too bad. Did you ever find the solution?

possibly making it harder for them to appreciate how severe the discoverability issues are for the rest of us.

We first ran up against the power of mindset two decades ago when we began to make a case inside organizations that rest and renewal are essential for sustaining high performance. The scientific evidence we presented to clients was compelling. Nearly all of them found the concept persuasive and appealing, both logically and intuitively. We taught them very simple strategies to build renewal into their lives, and they left our workshops eager to change the way they worked. Nonetheless, most of them struggled with changing their behavior when they got back to their jobs.

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

hypermedia

Use a swagger or OpenAPI library to generate a schema and you’re pretty much doing what most people are doing.

JSON-RPC is “level 0” of the Richardson Maturity Model – a model that describes the qualities of a REST design.

REST is a good architectural style (and it is, a lot of the modern naysaying about REST is relatively uninformed and not too dissimilar to the treatment SOAP had before it)

The basics of HTTP are easy to grasp – there’s a mandatory “request line”

GET http://www.davidwhitney.co.uk/ HTTP/1.1
Host: www.davidwhitney.co.uk
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64…
Accept: text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: en-GB,en-US;q=0.9,en;q=0.8

HTTP/1.1 200 OK
Cache-Control: public,max-age=1
Content-Type: text/html; charset=utf-8
Vary: Accept-Encoding
Server: Kestrel
X-Powered-By: ASP.NET
Date: Wed, 11 Dec 2019 21:52:23 GMT
Content-Length: 8479


<!DOCTYPE html>
<html lang="en">...

web is an implementation of the design pattern REST – which stands for “Representational State Transfer”. You’ll hear people talk about REST a lot – it was originally defined by Roy Fielding in his PhD dissertation, but more importantly was a description of the way HTTP/1.0 worked at the time

So the web is RESTful by default. REST describes the way HTTP works.

Most APIs you use, or build will be “REST-ish”.

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

traversal mechanism between the operations

REST's client-server separation of concerns

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.

RPC is increasingly used to create backend APIs as most are internal: most of the time, a backend API is consumed only by frontends developed within the same organization. In general, REST and GraphQL are the right tools if you want to create an API consumed by code written by third parties and RPC is the right tool if you want to create an API consumed by code written by yourself / your organization.

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

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

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

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

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

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

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

Uniform interface

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

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

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

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

REST API

一开始数据源的上传用的是 -d @/home/centos.tar  这个选项，但是经过反复试验，这个选项TM上传文件不完整，800M的文件只能上传230M，反复查找问题也找不到，最终换成--upload-file选项，上传成功，且根据此镜像可正常启动实例

curl -i -X PUT -H "X-Auth-Token: $token" -H "Content-Type: application/octet-stream" -d @/home/glance/ubuntu-12.10.qcow2 $image_url/v2/images/{image_id}/file

curl -i -X PUT -H "X-Auth-Token: $token" -H "Content-Type: application/octet-stream" --upload-file @/home/glance/ubuntu-12.10.qcow2 $image_url/v2/images/{image_id}/file

curl -H "Content-Type:application/json" -X POST -d 'json data' URL

curl -H "Content-Type:application/json" -X POST -d '{"user": "admin", "passwd":"12345678"}' http://127.0.0.1:8000/login

I was able to take time, to chill out.   I read Tania Sheko's post 'The art of slowing down.'

Rather than feeling under pressure, I felt rejuvenated.

Rather than blogging, (I was tired with blogging), I spent my time doing drawing. 

Schedule

Also, it does not safeguard against tampering of headers or body.

RFC 7235 - Access Authentication Framework RFC 2617 - HTTP Authentication: Basic and Digest Access Authentication

if the client is incapable of working with HTTP headers

I'm a big fan of the approach that Stripe has taken to API versioning -

Setting headers and http params for a single request in restangular

A client-side Javascript SDK for authenticating with OAuth2 (and OAuth1 with a oauth proxy) web services and querying their REST API's. HelloJS standardizes paths and responses to common API's like Google Data Services, Facebook Graph and Windows Live Connect. It's modular, so that list is growing. No more spaghetti code!

Writing REST Services in Java: Part 6 Security & Authorization