{"openapi":"3.1.0","info":{"title":"Medium API","version":"1.0.0","description":"Read Medium posts in real time — no login or key needed. Pull the recent stories of any Medium user (@handle), any topic/tag, or any publication, straight from Medium's own public RSS feeds. Each post comes with its title, author, canonical link, publish date, categories/tags, a clean text excerpt and the full content HTML. Pass user = the @handle, tag = a topic slug, or publication = a publication slug; every call is live (no cache). 4 endpoints. Built for content aggregation, author/topic monitoring and reading-list back-ends. A Medium reader API. No upstream key, no cache.","contact":{"name":"PremiumApi","url":"https://www.oanor.com/by/premiumapi"}},"servers":[{"url":"https://api.oanor.com/medium-api","description":"oanor gateway"}],"tags":[{"name":"Medium"},{"name":"Meta"}],"components":{"securitySchemes":{"oanorKey":{"type":"apiKey","in":"header","name":"x-oanor-key","description":"Get your key at https://www.oanor.com/developer/keys"}}},"security":[{"oanorKey":[]}],"paths":{"/v1/publication":{"get":{"operationId":"get_v1_publication","tags":["Medium"],"summary":"Publication posts","description":"","parameters":[{"name":"publication","in":"query","required":true,"description":"Publication slug","schema":{"type":"string"},"example":"better-programming"}],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"feed":{"link":"https://betterprogramming.pub?source=rss----d0b105d10f0a---4","image":"https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png","title":"Better Programming - Medium","description":"Advice for programmers. - Medium"},"count":10,"items":[{"guid":"https://medium.com/p/bf37baef8f27","link":"https://medium.com/better-programming/let-a-thousand-programming-publications-bloom-bf37baef8f27?source=rss----d0b105d10f0a---4","title":"Let a thousand programming publications bloom.","author":"Tony Stubblebine","excerpt":"I’m putting Better Programming on hiatus to make room for other programming publications. I get that this is a big pivot given that we switched to a new editor recently. But things are changing at Medium and I think this will ultimately be a boon for everyone, authors, readers and publications. I wo","updated":"2023-11-27T17:53:37.557Z","published":"Fri, 10 Nov 2023 18:18:10 GMT","categories":[],"content_html":"

I’m putting Better Programming on hiatus to make room for other programming publications.

I get that this is a big pivot given that we switched to a new editor recently. But things are changing at Medium and I think this will ultimately be a boon for everyone, authors, readers and publications.

I would like to inspire some (but not all) of you to start a publication and give you some guidelines on how to do it well. If you are an author, there are many other publications to write for and hopefully there will soon be even more (check the comments for suggestions).

Medium has always had publications that acted as something in between a group blog and a sub-reddit. Publication editors help set a quality bar, give feedback on your posts, and bring you an audience. Publications are a pillar of the Medium experience.

But the publication opportunities that (I think) are exciting are changing. In the past, the way to have a successful publication was to publish on anything and everything. So Medium was dominated by broad, high volume publications. Better Programming was one of those pubs and we published on topics that might not have a lot of overlapping readers. How many of you are currently programming in all of these languages: Go, Rust, Javascript, Ruby, Python, Swift, Kotlin, and Dart?

Better Programming has published stories on all of those topics and more, and so by definition we were often publishing stories that a lot of you don’t want to read. The direction Medium is heading is to optimize for publications that are more focused than Better Programming has been.

There are two types of focuses that I’m personally excited about. One is that publications are de facto communities of enthusiasts. The other is that publications bring a level of expertise to Medium’s boost program. Caveat: these are just what I’m excited about — maybe you have more creative ideas than I do.

Both cases beg for publications that are focused.

If you want to build an enthusiast community of people who love Kotlin, who want to write about their Kotlin projects and what they are learning, then you don’t also need authors in your publication who are writing about Swift.

Similarly, Medium is leaning on the expertise of publication editors to contribute as nominators in the Boost program. It’s hard to bring credible expertise when your focus is too broad. Most nominators also have first hand expertise beyond what they publish. So, if I were to run Better Programming myself, I think I could credibly nominate within Rails (I’ve built several companies on that stack) and Regular Expressions (I wrote a book), but I’m clueless on nearly everything else.

Running a publication isn’t for everyone and it isn’t a get-rich-quick scheme. The best publications are run out of authentic interest in a topic and nothing more. In technical topics, there can be some financial rewards, which I’ll get to. But mainly it’s best to think of this as a way to harness a passion you may have. I know that the community building impulse is strong in many of you because I’ve seen how many people have started publications on Medium over the years.

For any of you who are interested, I’m going to give you some tips on starting a publication. These aren’t exactly a recipe, but I’ll try to arrange them in order.

  1. Pubs are easy to start and at minimum you have yourself as a possible author to fill the pub with stories. Here’s a link to get going.
  2. If you want to accept other authors then you need to setup instructions. Almost all publications that accept other authors setup a “write for us” page with instructions, make it a tab on the publication, write a style guide, and then create a Google form to handle new author applications. Copy ours.
  3. Do you want to focus on inclusivity? If so, then your role is probably more about support and encouragement and less about setting a high editorial bar. People get squeamish about being judged but the thing I’ve long recognized is that all writing was useful to the writer and is often useful to at least a few people, but very little writing is going to trend on Reddit or HackerNews.
  4. Do you want to focus on exclusivity, i.e. finding the best of the best ideas and information on a topic? Medium’s Boost program gives publication editors a tool to recruit authors: “I can help boost your stories to more readers.” You can’t just boost anything, it has to be the best of the best. And so focusing on that is a very exclusive approach. I often think of a publication here about Runners where the editor is using his access to the Boost to work with professional running coaches, professional runners, and the former editor-in-chief of Runners World. That must be so fun for him! The programming equivalent is different for each programming languange so I’ll use an example from the language I got started in: if I started a publication for Perl, I’d use the boost as a way to recruit Larry Wall.
  5. Consider becoming a Boost nominator but also consider that doing that will require having a strong nose for the best of the best. Of course every story on Medium is “high quality” but there are certain stories that are important, accurate, helpful and maybe even more than that. This isn’t official policy, but unofficially, it would be reasonable to submit an application to be a Boost Nominator once you have a publication with three authors and ten stories.
  6. Getting a publication started requires recruiting authors. Hopefully you know some already, even if they aren’t on Medium. I think that if you don’t know a subject well enough that you also already know other people with similar enthusiasm and expertise in that subject, then starting a publication isn’t for you. That’s not a hard rule, but I’m saying it from experience. After recruiting from your own network, the way almost every other publication has recruited authors is by monitoring relevant tags on Medium and then using the private note feature to invite recently published stories into your publication.
  7. Lets talk money. If you are a publication that Boosts stories you will get paid an honorarium. Plus if you build an audience, your own stories might make more money. But, you are missing the big picture if this is the most important thing to you. Writing and editing is a form of portfolio building. The software engineering field pays so much money, way beyond what Medium pays for writing. So focusing on getting paid from Medium is the ultimate example of a local maxima because the you can make 1000x more by building a reputation and using it to get a job or raise. This is just fact.

If you do start a programming publication that is looking for authors or you’ve already started a programming publication like that, post a link in the responses along with a link to your submission guidelines.

Authors: I looked up Better Programming’s stats. 4.6k authors have published 16.8k stories to Better Programming. Those stories generated 151M page views. Not all of them were behind the paywall, but the ones that were earned authors $999 thousand dollars. It’s been a huge honor to play a role in that and my thanks go out to the editors who’ve made it happen and to all of you for writing. Medium is still a great home for you, it’s just that you should find new places to publish.

\"\"
\"\"

Let a thousand programming publications bloom. was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/3f456a51ff99","link":"https://medium.com/better-programming/calling-aws-bedrock-from-code-3f456a51ff99?source=rss----d0b105d10f0a---4","title":"Calling AWS Bedrock from code","author":"Thomas Reid","updated":"2023-11-10T17:35:02.467Z","published":"Fri, 10 Nov 2023 17:35:02 GMT","categories":["bedrock","python","llm","boto3","ai"]},{"guid":"https://medium.com/p/3e51432ae0e9","link":"https://medium.com/better-programming/pandas-v-psycopg-a-postgres-database-speed-test-who-wins-3e51432ae0e9?source=rss----d0b105d10f0a---4","title":"Pandas v Psycopg:","author":"Thomas Reid","updated":"2023-11-10T17:34:53.793Z","published":"Fri, 10 Nov 2023 17:34:53 GMT","categories":["speed-test","psycopg2","postgres","performance","pandas"]},{"guid":"https://medium.com/p/e1f66a3b0530","link":"https://medium.com/better-programming/automating-your-devops-writing-scripts-that-save-time-and-headaches-e1f66a3b0530?source=rss----d0b105d10f0a---4","title":"Automating Your DevOps: Writing Scripts that Save Time and Headaches","author":"Ulas Can Cengiz","updated":"2023-11-10T17:34:20.767Z","published":"Fri, 10 Nov 2023 17:34:20 GMT","categories":["software-development","development","devops","engineering","automation"]},{"guid":"https://medium.com/p/c5f79fc8019e","link":"https://medium.com/better-programming/integrating-psychology-into-software-development-c5f79fc8019e?source=rss----d0b105d10f0a---4","title":"Integrating Psychology into Software Development","author":"Ulas Can Cengiz","updated":"2023-11-10T17:34:07.833Z","published":"Fri, 10 Nov 2023 17:34:07 GMT","categories":["engineering","architecture","software-design","software-development","psychology"]},{"guid":"https://medium.com/p/ccbd1d3f9fd7","link":"https://medium.com/better-programming/gpt-function-calling-5-underrated-use-cases-ccbd1d3f9fd7?source=rss----d0b105d10f0a---4","title":"GPT Function Calling: 5 Underrated Use Cases","author":"Max Brodeur-Urbas","excerpt":"OpenAI’s backend converting messy unstructured data to structured data via functions OpenAI’s “Function Calling” might be the most groundbreaking yet under appreciated feature released by any software company… ever. What are GPT Functions Functions allow you to turn unstructured data into structured","updated":"2023-11-20T20:55:28.826Z","published":"Fri, 10 Nov 2023 17:33:58 GMT","categories":["automation","llm","gpt","chatgpt","openai"],"content_html":"
\"\"
OpenAI’s backend converting messy unstructured data to structured data via functions

OpenAI’s “Function Calling” might be the most groundbreaking yet under appreciated feature released by any software company… ever.

What are GPT Functions

Functions allow you to turn unstructured data into structured data. This might not sound all that groundbreaking but when you consider that 90% of data processing and data entry jobs worldwide exist for this exact reason, it’s quite a revolutionary feature that went somewhat unnoticed.

Have you ever found yourself begging GPT (3.5 or 4) to spit out the answer you want and absolutely nothing else? No “Sure, here is your…” or any other useless fluff surrounding the core answer. GPT Functions are the solution you’ve been looking for.

How are Functions meant to work?

OpenAI’s docs on function calling are extremely limited. You’ll find yourself digging through their developer forum for examples of how to use them. I dug around the forum for you and have many example coming up.

Here’s one of the only examples you’ll be able to find in their docs:

functions = [
        {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["location"],
            },
        }
    ]

A function definition is a rigid JSON format that defines a function name, description and parameters. In this case, the function is meant to get the current weather. Obviously GPT isn’t able to call this actual API (since it doesn’t exist) but using this structured response you’d be able to connect the real API hypothetically.

At a high level however, functions provide two layers of inference:

Picking the function itself:

You may notice that functions are passed into the OpenAI API call as an array. The reason you provide a name and description to each function are so GPT can decide which to use based on a given prompt. Providing multiple functions in your API call is like giving GPT a Swiss army knife and asking it to cut a piece of wood in half. It knows that even though it has a pair of pliers, scissors and a knife, it should use the saw!

Function definitions contribute towards your token count. Passing in hundreds of functions would not only take up the majority of your token limit but also result in a drop in response quality. I often don’t even use this feature and only pass in 1 function that I force it to use. It is very nice to have in certain use cases however.

Picking the parameter values based on a prompt:

This is the real magic in my opinion. GPT being able to choose the tool in it’s tool kit is amazing and definitely the focus of their feature announcement but I think this applies to more use cases.

You can imagine a function like handing GPT a form to fill out. It uses its reasoning, the context of the situation and field names/descriptions to decide how it will fill out each field. Designing the form and the additional information you pass in is where you can get creative.

\"\"
GPT filling out your custom form (function parameters)

5 Useful Applications

Data Extraction

One of the most common things I use functions for to extract specific values from a large chunk of text. The sender’s address from an email, a founders name from a blog post, a phone number from a landing page.

I like to imagine I’m searching for a needle in a haystack except the LLM burns the haystack, leaving nothing but the needle(s).

\"\"
GPT Data Extraction Personified.

Use case: Processing thousands of contest submissions

I built an automation that iterated over thousands of contest submissions. Before storing these in a Google sheet I wanted to extract the email associated with the submission. Heres the function call I used for extracting their email.

{
   "name":"update_email",
   "description":"Updates email based on the content of their submission.",
   "parameters":{
      "type":"object",
      "properties":{
         "email":{
            "type":"string",
            "description":"The email provided in the submission"
         }
      },
      "required":[
         "email"
      ]
   }
}

Scoring

Assigning unstructured data a score based on dynamic, natural language criteria is a wonderful use case for functions. You could score comments during sentiment analysis, essays based on a custom grading rubric, a loan application for risk based on key factors. A recent use case I applied scoring to was scoring of sales leads from 0–100 based on their viability.

Use Case: Scoring Sales leads

We had hundreds of prospective leads in a single google sheet a few months ago that we wanted to tackle from most to least important. Each lead contained info like company size, contact name, position, industry etc.

Using the following function we scored each lead from 0–100 based on our needs and then sorted them from best to worst.

{
   "name":"update_sales_lead_value_score",
   "description":"Updates the score of a sales lead and provides a justification",
   "parameters":{
      "type":"object",
      "properties":{
         "sales_lead_value_score":{
            "type":"number",
            "description":"An integer value ranging from 0 to 100 that represents the quality of a sales lead based on these criteria. 100 is a perfect lead, 0 is terrible. Ideal Lead Criteria:\\n- Medium sized companies (300-500 employees is the best range)\\n- Companies in primary resource heavy industries are best, ex. manufacturing, agriculture, etc. (this is the most important criteria)\\n- The higher up the contact position, the better. VP or Executive level is preferred."
         },
         "score_justification":{
            "type":"string",
            "description":"A clear and conscise justification for the score provided based on the custom criteria"
         }
      }
   },
   "required":[
      "sales_lead_value_score", 
      "score_justification"
   ]
}

Categorization:

Define custom buckets and have GPT thoughtfully consider each piece of data you give it and place it in the correct bucket. This can be used for labelling tasks like selecting the category of youtube videos or for discrete scoring tasks like assigning letter grades to homework assignments.

Use Case: Labelling news articles.

A very common first step in data processing workflows is separating incoming data into different streams. A recent automation I built did exactly this with news articles scraped from the web. I wanted to sort them based on the topic of the article and include a justification for the decision once again. Here’s the function I used:

{
   "name":"categorize",
   "description":"Categorize the input data into user defined buckets.",
   "parameters":{
      "type":"object",
      "properties":{
         "category":{
            "type":"string",
            "enum":[
               "US Politics",
               "Pandemic",
               "Economy",
               "Pop culture",
               "Other"
            ],
            "description":"US Politics: Related to US politics or US politicians, Pandemic: Related to the Coronavirus Pandemix, Economy: Related to the economy of a specific country or the world. , Pop culture: Related to pop culture, celebrity media or entertainment., Other: Doesn't fit in any of the defined categories. "
         },
         "justification":{
            "type":"string",
            "description":"A short justification explaining why the input data was categorized into the selected category."
         }
      },
      "required":[
         "category",
         "justification"
      ]
   }
}

Option-Selection:

Often times when processing data, I give GPT many possible options and want it to select the best one based on my needs. I only want the value it selected, no surrounding fluff or additional thoughts. Functions are perfect for this.

Use Case: Finding the “most interesting AI news story” from hacker news

I wrote another medium article here about how I automated my entire Twitter account with GPT. Part of that process involves selecting the most relevant posts from the front pages of hacker news. This post selection step leverages functions!

To summarize the functions portion of the use case, we would scrape the first n pages of hacker news and ask GPT to select the post most relevant to “AI news or tech news”. GPT would return only the headline and the link selected via functions so that I could go on to scrape that website and generate a tweet from it.

I would pass in the user defined query as part of the message and use the following function definition:

{
   "name":"find_best_post",
   "description":"Determine the best post that most closely reflects the query.",
   "parameters":{
      "type":"object",
      "properties":{
         "best_post_title":{
            "type":"string",
            "description":"The title of the post that most closely reflects the query, stated exactly as it appears in the list of titles."
         }
      },
      "required":[
         "best_post_title"
      ]
   }
}

Filtering:

Filtering is a subset of categorization where you categorize items as either true or false based on a natural language condition. A condition like “is Spanish” will be able to filter out all Spanish comments, articles etc. using a simple function and conditional statement immediately after.

Use Case: Filtering contest submission

The same automation that I mentioned in the “Data Extraction” section used ai-powered-filtering to weed out contest submissions that didn’t meet the deal-breaking criteria. Things like “must use typescript” were absolutely mandatory for the coding contest at hand. We used functions to filter out submissions and trim down the total set being processed by 90%. Here is the function definition we used.

{
   "name":"apply_condition",
   "description":"Used to decide whether the input meets the user provided condition.",
   "parameters":{
      "type":"object",
      "properties":{
         "decision":{
            "type":"string",
            "enum":[
               "True",
               "False"
            ],
            "description":"True if the input meets this condition 'Does submission meet the ALL these requirements (uses typescript, uses tailwindcss, functional demo)', False otherwise."
         }
      },
      "required":[
         "decision"
      ]
   }
}

If you’re curious why I love functions so much or what I’ve built with them you should check out AgentHub!

AgentHub is the Y Combinator-backed startup I co-founded that let’s you automate any repetitive or complex workflow with AI via a simple drag and drop no-code platform.

“Imagine Zapier but AI-first and on crack.” — Me

Automations are built with individual nodes called “Operators” that are linked together to create power AI pipelines. We have a catalogue of AI powered operators that leverage functions under the hood.

\"\"
Our current AI-powered operators that use functions!

Check out these templates to see examples of function use-cases on AgentHub: Scoring, Categorization, Option-Selection,

If you want to start building AgentHub is live and ready to use! We’re very active in our discord community and are happy to help you build your automations if needed.

Feel free to follow the official AgentHub twitter for updates and myself for AI-related content.

\"\"

GPT Function Calling: 5 Underrated Use Cases was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/8d81fccd8250","link":"https://medium.com/better-programming/webassembly-with-go-taking-web-apps-to-the-next-level-8d81fccd8250?source=rss----d0b105d10f0a---4","title":"WebAssembly with Go: Taking Web Apps to the Next Level","author":"Ege Aytin","excerpt":"You might’ve noticed the increasing chatter around WebAssembly (WASM) in the dev community. Its potential is vast, and we’ve found it invaluable in enhancing our open source project! Hi everyone, I’m part of the team behind Permify , an open-source infra that helps developers to create and manage gr","updated":"2023-11-21T12:18:43.843Z","published":"Fri, 10 Nov 2023 17:31:06 GMT","categories":["javascript","golang","tutorial"],"content_html":"
\"\"

You might’ve noticed the increasing chatter around WebAssembly (WASM) in the dev community. Its potential is vast, and we’ve found it invaluable in enhancing our open source project!

Hi everyone, I’m part of the team behind Permify, an open-source infra that helps developers to create and manage granular permissions throughout their applications.

In this article, I’ll demonstrate why and how we integrated WebAssembly (WASM) into our Playground and gained benefits from its collaboration with Golang.

What does this playground do? Well, without diving too deep, its a interactive module of Permify which used for creating and testing authorization models.

Throughout this post, I’ll be sharing:

By the end, you should have a clearer understanding of why and how we leveraged WASM’s capabilities for our project.

Understanding WebAssembly

WebAssembly (Wasm) has established itself as a pivotal technology, enabling quick and efficient code execution in web browsers and forming a robust bridge between web applications and the high-performance typically associated with native applications.

1. Unveiling WebAssembly:

Wasm acts as a low-level virtual machine, executing a compact binary code that’s translated from high-level languages.

Primary Advantages:

In our open-source project, Permify, we strategically incorporated Go (also known as Golang) into its foundational core, selecting it for its widely recognized static typing, concurrency handling, and performance optimization. When the development journey led us to craft the Permify Playground, WebAssembly stepped into the spotlight as a crucial element.

2. Blending Go & WebAssembly:

Our journey isn’t just about melding Go and WebAssembly. Moving forward, we’ll unearth why Wasm was pinpointed as the technology of choice for the Permify Playground development and what significant benefits were reaped from this decision.

Why WebAssembly?

The inception of the Permify Playground brought with it a key question: How to showcase our capabilities without being entwined in the complexities and maintenance woes of traditional server architectures? WebAssembly appeared as a shining answer. Adopting this binary instruction format allowed us to:

Harvesting Technical Benefits and Gathering User Feedback

Utilizing WebAssembly in our Permify Playground led us down a path of discernible technical advantages and an embrace from the community:

Join us in the following sections as we delve deeper into the technicalities, feedback, and learnings from our adventure, providing a thorough exploration of our endeavours with WebAssembly.

WASM Implementation with Go

Before we explore Permify’s use of WebAssembly (WASM) and Go, let’s understand their combination in a sample app. What follows is a step-by-step guide to bringing them together, setting the stage for our deeper dive into Permify’s implementation.

1. Transforming Go into WebAssembly:

  1. To get started, ensure you’ve set the WebAssembly build target in Go:
GOOS=js GOARCH=wasm go build -o main.wasm main.go
  1. Next, apply optimizations to reduce the file size and enhance performance:
wasm-opt main.wasm --enable-bulk-memory -Oz -o play.wasm

Suppose you want your Go function to react to a button click from your web page:

package main

import "syscall/js"

func registerCallbacks() {
    js.Global().Set("handleClick", js.FuncOf(handleClick))
}

func handleClick(this js.Value, inputs []js.Value) interface{} {
    println("Button clicked!")
    return nil
}

In your HTML, after loading your WebAssembly module:

<button onclick="window.handleClick()">Click me</button>

2. Integrating with Web Pages:

Ensure you have the wasm_exec.js script linked, then instantiate your Wasm module:

<script src="wasm_exec.js"></script>
<script>
    const go = new Go();
    WebAssembly.instantiateStreaming(fetch("play.wasm"), go.importObject).then((result) => {
        go.run(result.instance);
    });
</script>

Accessing and modifying web elements is fundamental. For instance, changing the content of a paragraph element from Go would look something like this:

func updateDOMContent() {
    document := js.Global().Get("document")
    element := document.Call("getElementById", "myParagraph")
    element.Set("innerText", "Updated content from Go!")
}

3. The Gains: Efficiency & Speed:

Imagine having multiple data fetch operations that can run simultaneously without blocking the main thread:

func fetchData(url string, ch chan string) {
    // Simulate data fetch.
    ch <- "Data from " + url
}

func main() {
    ch := make(chan string)
    go fetchData("<https://api.example1.com>", ch)
    go fetchData("<https://api.example2.com>", ch)

    data1 := <-ch
    data2 := <-ch
    println(data1, data2)
}

Navigating through Go and WebAssembly (WASM) showcases a powerful union, merging Go’s concurrent processing with WASM’s rapid client-side execution. The depth explored in our sample app lights the way forward into Permify, where we apply these technological strengths into a scalable, real-world authorization system.

Deeper Dive: Permify’s WASM Code Breakdown

Let’s dive a bit deeper into the heart of our WebAssembly integration by exploring the key segments of our Go-based WASM code.

1. Setting up the Go-to-WASM Environment

involves preparing and specifying our Go code to be compiled for a WebAssembly runtime.

// go:build wasm
// +build wasm

These lines serve as directives to the Go compiler, signaling that the following code is designated for a WebAssembly runtime environment. Specifically:

In essence, these directives guide the compiler to include this code segment only when compiling for a WebAssembly architecture, ensuring an appropriate setup and function within this specific runtime.

2. Bridging JavaScript and Go with the run Function

package main

import (
 "context"
 "encoding/json"
 "syscall/js"

 "google.golang.org/protobuf/encoding/protojson"

 "github.com/Permify/permify/pkg/development"
)

var dev *development.Development

func run() js.Func {
  // The `run` function returns a new JavaScript function
  // that wraps the Go function.
 return js.FuncOf(func(this js.Value, args []js.Value) interface{} {

  // t will be used to store the unmarshaled JSON data.
  // The use of an empty interface{} type means it can hold any type of value.
  var t interface{}

  // Unmarshal JSON from JavaScript function argument (args[0]) to Go's data structure (map).
  // args[0].String() gets the JSON string from the JavaScript argument,
  // which is then converted to bytes and unmarshaled (parsed) into the map `t`.
  err := json.Unmarshal([]byte(args[0].String()), &t)

  // If an error occurs during unmarshaling (parsing) the JSON,
  // it returns an array with the error message "invalid JSON" to JavaScript.
  if err != nil {
   return js.ValueOf([]interface{}{"invalid JSON"})
  }

  // Attempt to assert that the parsed JSON (`t`) is a map with string keys.
  // This step ensures that the unmarshaled JSON is of the expected type (map).
  input, ok := t.(map[string]interface{})

  // If the assertion is false (`ok` is false),
  // it returns an array with the error message "invalid JSON" to JavaScript.
  if !ok {
   return js.ValueOf([]interface{}{"invalid JSON"})
  }

  // Run the main logic of the application with the parsed input.
  // It’s assumed that `dev.Run` processes `input` in some way and returns any errors encountered during that process.
  errors := dev.Run(context.Background(), input)

  // If no errors are present (the length of the `errors` slice is 0),
  // return an empty array to JavaScript to indicate success with no errors.
  if len(errors) == 0 {
   return js.ValueOf([]interface{}{})
  }

  // If there are errors, each error in the `errors` slice is marshaled (converted) to a JSON string.
  // `vs` is a slice that will store each of these JSON error strings.
  vs := make([]interface{}, 0, len(errors))

  // Iterate through each error in the `errors` slice.
  for _, r := range errors {
   // Convert the error `r` to a JSON string and store it in `result`.
   // If an error occurs during this marshaling, it returns an array with that error message to JavaScript.
   result, err := json.Marshal(r)
   if err != nil {
    return js.ValueOf([]interface{}{err.Error()})
   }
   // Add the JSON error string to the `vs` slice.
   vs = append(vs, string(result))
  }

  // Return the `vs` slice (containing all JSON error strings) to JavaScript.
  return js.ValueOf(vs)
 })
}

Within the realm of Permify, the run function stands as a cornerstone, executing a crucial bridging operation between JavaScript inputs and Go's processing capabilities. It orchestrates real-time data interchange in JSON format, safeguarding that Permify's core functionalities are smoothly and instantaneously accessible via a browser interface.

Digging into run:

Thus, through adeptly managing data, error-handling, and ensuring a fluid two-way communication channel, run serves as an integral bridge, linking JavaScript and Go to ensure the smooth, real-time operation of Permify within a browser interface. This facilitation of interaction not only heightens user experience but also leverages the respective strengths of JavaScript and Go within the Permify environment.

3. Main Execution and Initialization

// Continuing from the previously discussed code...

func main() {
  // Instantiate a channel, 'ch', with no buffer, acting as a synchronization point for the goroutine.
  ch := make(chan struct{}, 0)

  // Create a new instance of 'Container' from the 'development' package and assign it to the global variable 'dev'.
  dev = development.NewContainer()

  // Attach the previously defined 'run' function to the global JavaScript object,
  // making it callable from the JavaScript environment.
  js.Global().Set("run", run())

  // Utilize a channel receive expression to halt the 'main' goroutine, preventing the program from terminating.
  <-ch
}
  1. ch := make(chan struct{}, 0): A synchronization channel is created to coordinate the activity of goroutines (concurrent threads in Go).
  2. dev = development.NewContainer(): Initializes a new container instance from the development package and assigns it to dev.
  3. js.Global().Set("run", run()): Exposes the Go run function to the global JavaScript context, enabling JavaScript to call Go functions.
  4. <-ch: Halts the main goroutine indefinitely, ensuring that the Go WebAssembly module remains active in the JavaScript environment.

In summary, the code establishes a Go environment running within WebAssembly that exposes specific functionality (run function) to the JavaScript side and keeps itself active and available for function calls from JavaScript.

Building the Go Code into a WASM Module

Before we delve into Permify’s rich functionalities, it’s paramount to elucidate the steps of converting our Go code into a WASM module, priming it for browser execution.

For enthusiasts eager to delve deep into the complete Go codebase, don’t hesitate to browse our GitHub repository: Permify Wasm Code.

1. Compiling to WASM

Kickstart the transformation of our Go application into a WASM binary with this command:

GOOS=js GOARCH=wasm go build -o permify.wasm main.go

This directive cues the Go compiler to churn out a .wasm binary attuned for JavaScript environments, with main.go as the source. The output, permify.wasm, is a concise rendition of our Go capabilities, primed for web deployment.

2. WASM Exec JS

In conjunction with the WASM binary, the Go ecosystem offers an indispensable JavaScript piece named wasm_exec.js. It's pivotal for initializing and facilitating our WASM module within a browser setting. You can typically locate this essential script inside the Go installation, under misc/wasm.

However, to streamline your journey, we’ve hosted wasm_exec.js right here for direct access: wasm_exec.

cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" .

Equipped with these pivotal assets — the WASM binary and its companion JavaScript — the stage is set for its amalgamation into our frontend.

Steps to Embed Go WASM in a React Application

1. Setting Up the React Application Structure

To kick things off, ensure you have a directory structure that clearly separates your WebAssembly-related code from the rest of your application. Based on your given structure, the loadWasm folder seems to be where all the magic happens:

loadWasm/
│
├── index.tsx            // Your main React component that integrates WASM.
├── wasm_exec.js         // Provided by Go, bridges the gap between Go's WASM and JS.
└── wasmTypes.d.ts       // TypeScript type declarations for WebAssembly.

To view the complete structure and delve into the specifics of each file, refer to the Permify Playground on GitHub.

2. Establishing Type Declarations

Inside the wasmTypes.d.ts, global type declarations are made which expand upon the Window interface to acknowledge the new methods brought in by Go's WebAssembly:

declare global {
  export interface Window {
    Go: any;
    run: (shape: string) => any[];
  }
}
export {};

This ensures TypeScript recognizes the Go constructor and the run method when called on the global window object.

3. Preparing the WebAssembly Loader

In index.tsx, several critical tasks are accomplished:

import "./wasm_exec.js";
import "./wasmTypes.d.ts";
async function loadWasm(): Promise<void> {
  const goWasm = new window.Go();
  const result = await WebAssembly.instantiateStreaming(
    fetch("play.wasm"),
    goWasm.importObject
  );
  goWasm.run(result.instance);
}

Here, new window.Go() initializes the Go WASM environment. WebAssembly.instantiateStreaming fetches the WASM module, compiles it, and creates an instance. Finally, goWasm.run activates the WASM module.

export const LoadWasm: React.FC<React.PropsWithChildren<{}>> = (props) => {
  const [isLoading, setIsLoading] = React.useState(true);

  useEffect(() => {
    loadWasm().then(() => {
      setIsLoading(false);
    });
  }, []);

  if (isLoading) {
    return (
      <div className="wasm-loader-background h-screen">
        <div className="center-of-screen">
          <SVG src={toAbsoluteUrl("/media/svg/rocket.svg")} />
        </div>
      </div>
    );
  } else {
    return <React.Fragment>{props.children}</React.Fragment>;
  }
};

While loading, SVG rocket is displayed to indicate that initialization is ongoing. This feedback is crucial as users might otherwise be uncertain about what’s transpiring behind the scenes. Once loading completes, children components or content will render.

4. Calling WebAssembly Functions

Given your Go WASM exposes a method named run, you can invoke it as follows:

function Run(shape) {
  return new Promise((resolve) => {
    let res = window.run(shape);
    resolve(res);
  });
}

This function essentially acts as a bridge, allowing the React frontend to communicate with the Go backend logic encapsulated in the WASM.

5. Implementing the Run Button in React

To integrate a button that triggers the WebAssembly function when clicked, follow these steps:

  1. Creating the Button Component

First, we’ll create a simple React component with a button:

import React from "react";

type RunButtonProps = {
  shape: string;
  onResult: (result: any[]) => void;
};

function RunButton({ shape, onResult }: RunButtonProps) {
  const handleClick = async () => {
    let result = await Run(shape);
    onResult(result);
  };

  return <button onClick={handleClick}>Run WebAssembly</button>;
}

In the code above, the RunButton component accepts two props:

  1. Integrating the Button in the Main Component

Now, in your main component (or wherever you’d like to place the button), integrate the RunButton:

import React, { useState } from "react";
import RunButton from "./path_to_RunButton_component"; // Replace with the actual path

function App() {
  const [result, setResult] = useState<any[]>([]);

  // Define the shape content
  const shapeContent = {
    schema: `|-
    entity user {}

    entity account {
        relation owner @user
        relation following @user
        relation follower @user

        attribute public boolean
        action view = (owner or follower) or public  
    }

    entity post {
        relation account @account

        attribute restricted boolean

        action view = account.view

        action comment = account.following not restricted
        action like = account.following not restricted
    }`,
    relationships: [
      "account:1#owner@user:kevin",
      "account:2#owner@user:george",
      "account:1#following@user:george",
      "account:2#follower@user:kevin",
      "post:1#account@account:1",
      "post:2#account@account:2",
    ],
    attributes: [
      "account:1$public|boolean:true",
      "account:2$public|boolean:false",
      "post:1$restricted|boolean:false",
      "post:2$restricted|boolean:true",
    ],
    scenarios: [
      {
        name: "Account Viewing Permissions",
        description:
          "Evaluate account viewing permissions for 'kevin' and 'george'.",
        checks: [
          {
            entity: "account:1",
            subject: "user:kevin",
            assertions: {
              view: true,
            },
          },
        ],
      },
    ],
  };

  return (
    <div>
      <RunButton shape={JSON.stringify(shapeContent)} onResult={setResult} />
      <div>
        Results:
        <ul>
          {result.map((item, index) => (
            <li key={index}>{item}</li>
          ))}
        </ul>
      </div>
    </div>
  );
}

In this example, App is a component that contains the RunButton. When the button is clicked, the result from the WebAssembly function is displayed in a list below the button.

Conclusion

Throughout this exploration, the integration of WebAssembly with Go was unfolded, illuminating the pathway toward enhanced web development and optimal user interactions within browsers.

The journey involved setting up the Go environment, converting Go code to WebAssembly, and executing it within a web context, ultimately giving life to the interactive platform showcased at play.permify.co.

This platform stands not only as an example but also as a beacon, illustrating the concrete and potent capabilities achievable when intertwining these technological domains.

\"\"

WebAssembly with Go: Taking Web Apps to the Next Level was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/3ee5d41f81a4","link":"https://medium.com/better-programming/3-fundamental-concepts-to-fully-understand-how-the-fetch-api-works-3ee5d41f81a4?source=rss----d0b105d10f0a---4","title":"3 Fundamental Concepts to Fully Understand how the Fetch API Works","author":"Jay Cruz","updated":"2023-11-10T17:30:24.902Z","published":"Fri, 10 Nov 2023 17:30:24 GMT","categories":["fetch-api","software-development","javascript","web-development","programming"]},{"guid":"https://medium.com/p/48809a853fae","link":"https://medium.com/better-programming/deploy-coreml-models-on-the-server-with-vapor-48809a853fae?source=rss----d0b105d10f0a---4","title":"Deploy CoreML Models on the Server with Vapor","author":"Drew Althage","excerpt":"Get the benefits of Apple’s ML tools server-side. SwiftUI client showing image classification results Recently, at Sovrn , we had an AI Hackathon where we were encouraged to experiment with anything related to machine learning. The Hackathon yielded some fantastic projects from across the company. E","updated":"2023-11-10T17:30:15.819Z","published":"Fri, 10 Nov 2023 17:30:15 GMT","categories":["swift","programming","ios","machine-learning","apple"],"content_html":"

Get the benefits of Apple’s ML tools server-side.

\"\"
SwiftUI client showing image classification results

Recently, at Sovrn, we had an AI Hackathon where we were encouraged to experiment with anything related to machine learning. The Hackathon yielded some fantastic projects from across the company. Everything from SQL query generators to chatbots that can answer questions about our products and other incredible work. I thought this would be a great opportunity to learn more about Apple’s ML tools and maybe even build something with real business value.

A few of my colleagues and I teamed up to play with CreateML and CoreML to see if we could integrate some ML functionality into our iOS app. We got a model trained and integrated into our app in several hours, which was pretty amazing. But we quickly realized that we had a few problems to solve before we could actually ship this thing.

We didn’t have time to solve all of these problems. But the other day I was exploring the Vapor web framework and the thought hit me, “Why not deploy CoreML models on the server?”

Apple provides a few pre-trained models, so today we’ll deploy an image classification model on the server behind a REST API with Vapor and create a SwiftUI client to consume it.

Foreword

This prototype is just that, a prototype. It’s not meant to be a production-ready solution. It’s meant to be a proof of concept. There will be warnings in the console, and the code won’t be very clean, but it will work and hopefully get your wheels turning.

If you want to skip all this, or if you do want to follow along, you can find the source code for this project on GitHub.

Okay, disclaimers over. Let’s get started!

Requirements

Getting Started

First start by creating a new directory that will house our Xcode workspace. We’ll call it coreml-web-api .

cd ~/Desktop && mkdir coreml-web-api && cd coreml-web-api

Now let's install Vapor and bootstrap a brand new server. See the docs for more details.

brew install vapor
vapor new server -n
open Package.swift

We want our users to be able to upload images for classification so add a new route called classify that supports this. In server/Sources/App/routes.swift , clear out all that generated boilerplate, and add in the following:

import CoreImage
import Vapor

func routes(_ app: Application) throws {
    app.post("classify") { req -> [ClassifierResult] in
        let classificationReq = try req.content.decode(ClassificationRequest.self)
        let imageBuffer = classificationReq.file.data
        guard let fileData = imageBuffer.getData(at: imageBuffer.readerIndex, length: imageBuffer.readableBytes),
              let ciImage = CIImage(data: fileData)
        else {
            throw Errors.badImageData
        }

        let classifier = Classifier() // we'll add this in a sec

        return try classifier.classify(image: ciImage)
    }
}

enum Errors: Error {
    case badImageData // or whatever
}

struct ClassificationRequest: Content {
    var file: File
}

Also, bump up the max file size allowed for uploads in configure.swift :

import Vapor

// configures your application
public func configure(_ app: Application) async throws {
    app.routes.defaultMaxBodySize = "10mb"

    // register routes
    try routes(app)
}

Alright, now let's write up a Classifier API. First, head over to Apple’s ML page to download a pre-trained model of your choosing. In this demo, I’m using the Resnet50 model. We’ll add this to the package in just a moment.

Add a new file called Classifier and drop in the following:

import CoreImage
import Vapor
import Vision

struct Classifier {
    func classify(image: CIImage) throws -> [ClassifierResult] {
        let url = Bundle.module.url(forResource: "Resnet50", withExtension: "mlmodelc")!
        guard let model = try? VNCoreMLModel(for: Resnet50(contentsOf: url, configuration: MLModelConfiguration()).model) else {
            throw Errors.unableToLoadMLModel
        }

        let request = VNCoreMLRequest(model: model)

        let handler = VNImageRequestHandler(ciImage: image)

        try? handler.perform([request])

        guard let results = request.results as? [VNClassificationObservation] else {
            throw Errors.noResults
        }

        return results.map { ClassifierResult(label: $0.identifier, confidence: $0.confidence) }
    }

    enum Errors: Error {
        case unableToLoadMLModel
        case noResults
    }
}

struct ClassifierResult: Encodable, Content {
    var label: String
    var confidence: Float
}

Let’s break this down.

First, we load the model. Adding a CoreML model to a package is not super straightforward. We need to compile the .mlmodelourselves and add some files to Sources/. We’ll go over that in a few but this wonkiness explains why loading the model might look slightly different from adding one to a standard Xcode project.

Once the model is loaded, we prepare the request and the request handler; then we do the classification. To send the results as JSON to the client, we need to remap the results to a structure that conforms to Encodable and Content .

Adding the Model to the Package

This part definitely took me the longest to figure out. Unfortunately, this step is pretty manual; we can’t just drag and drop the model into the project. So, at the root of the server package, add a new folder called MLModelSource and add the Resnet50.mlmodel file here. Create another folder called Resourcesat server/Sources/App/Resources/ .

Now, we need to compile the model, add the Swift class to sources, and include the .mlmodelc in the package bundle. The compilation steps are repetitive so we’ll place them in a Makefile target. In the project root, create a Makefile:

# ~/Desktop/coreml-web-api/
touch Makefile

And add a compile_ml_modeltarget:

compile_ml_model:
   cd server/MLModelSource && \\
   xcrun coremlcompiler compile Resnet50.mlmodel ../Sources/App/Resources && \\
   xcrun coremlcompiler generate Resnet50.mlmodel ../Sources/App/Resources --language Swift

Next, add this to the executable target inPackage.swift file:

resources: [
    .copy("Resources/Resnet50.mlmodelc"),
]

The target should look like this:

.executableTarget(
    name: "App",
    dependencies: [
        .product(name: "Vapor", package: "vapor"),
    ],
    resources: [
        .copy("Resources/Resnet50.mlmodelc"),
    ]
),

Okay, now from the project root, run the compile_ml_model target:

make compile_ml_model

Awesome!!! Now, we have an amazing server that supports classifying uploaded images using the Resnet50 model. Before we move on to the creating the client, we need to adjust the App scheme to make the server available to a physical device on your network.

Open up the scheme editor, and add serve --hostname 0.0.0.0 to the run arguments.

\"\"

Sweet. Now, we’ll create a client to do the uploading.

iOS Client

OK, in Xcode go to File -> New -> Project and add an iOS app to the workspace. We only need SwiftUI, no tests or SwiftData. I’m giving mine a really clever name of CoreMLWebClient … poetic.

Great. Now, let's do a little config work. Since we’re going to be using the camera, we need to update the Info.plist with the Privacy — Camera Usage Description key.

\"\"

Nice! In our client, we want to give users the option of using the camera or selecting from the photo library. Create a new file called ImagePicker.swift and paste in the following:

import SwiftUI

struct ImagePicker: UIViewControllerRepresentable {
    @Binding var sourceType: UIImagePickerController.SourceType
    @Environment(\\.presentationMode) private var presentationMode
    var completion: (UIImage) -> Void

    func makeUIViewController(context: Context) -> some UIViewController {
        let picker = UIImagePickerController()
        picker.sourceType = sourceType
        picker.delegate = context.coordinator
        return picker
    }

    func updateUIViewController(_: UIViewControllerType, context _: Context) {}

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
        var parent: ImagePicker

        init(_ parent: ImagePicker) {
            self.parent = parent
        }

        func imagePickerController(_: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
            if let image = info[.originalImage] as? UIImage {
                parent.completion(image)
            }
            parent.presentationMode.wrappedValue.dismiss()
        }
    }
}

We’ll use the sourceType binding to switch between the camera and the library.

Now, we’ll add a Classifierto handle the image uploading and return the classification results. I’m jumping around a little, but all this will come together in a few. Create a new file called Classifier.swift and add this in:

import Foundation
import UIKit

struct Classifier {
    /// replace this with your dev machine IP address
    /// for testing with a physical device.
    private let host = "localhost"

    func classify(image: UIImage) async throws -> [ClassifierResult] {
        // Ensure the URL is valid
        guard let uploadURL = URL(string: "http://\\(host):8080/classify") else {
            throw URLError(.badURL)
        }

        // Convert the image to JPEG data
        guard let imageData = image.jpegData(compressionQuality: 1.0) else {
            throw URLError(.unknown)
        }

        // Generate boundary string using a unique per-app string
        let boundary = "Boundary-\\(UUID().uuidString)"

        // Create a URLRequest object
        var request = URLRequest(url: uploadURL)
        request.httpMethod = "POST"
        request.setValue("multipart/form-data; boundary=\\(boundary)", forHTTPHeaderField: "Content-Type")

        // Create multipart form body
        let body = createMultipartFormData(boundary: boundary, data: imageData, fileName: "photo.jpg")
        request.httpBody = body

        // Perform the upload task
        let (data, response) = try await URLSession.shared.upload(for: request, from: body)

        // Check the response and throw an error if it's not a HTTPURLResponse or the status code is not 200
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }

        // Decode the data into an array of ClassifierResult
        return try JSONDecoder().decode([ClassifierResult].self, from: data)
    }

    /// Creates a multipart/form-data body with the image data.
    /// - Parameters:
    ///   - boundary: The boundary string separating parts of the data.
    ///   - data: The image data to be included in the request.
    ///   - fileName: The filename for the image data in the form-data.
    /// - Returns: A `Data` object representing the multipart/form-data body.
    private func createMultipartFormData(boundary: String, data: Data, fileName: String) -> Data {
        var body = Data()

        // Add the image data to the raw http request data
        body.append("--\\(boundary)\\r\\n")
        body.append("Content-Disposition: form-data; name=\\"file\\"; filename=\\"\\(fileName)\\"\\r\\n")
        body.append("Content-Type: image/jpeg\\r\\n\\r\\n")
        body.append(data)
        body.append("\\r\\n")

        // Add the closing boundary
        body.append("--\\(boundary)--\\r\\n")
        return body
    }

    struct ClassifierResult: Decodable, Identifiable {
        let id = UUID()
        var label: String
        var confidence: Float
    }
}

// Helper function to append string data to Data object
private extension Data {
    mutating func append(_ string: String) {
        if let data = string.data(using: .utf8) {
            append(data)
        }
    }
}

Great! Now on to the UI. Back in ContentView , let's add an enum called RequestStatus to communicate to the user what is going on — this is an easy UX win.

enum RequestStatus {
    case loading, success, idle, error
}

Now, we’ll create a view model for ContentView that uses the newly created classifier to upload a photo to the server and share the results with the UI. This is also going to use the new Observation framework ⭐.

extension ContentView {
    @Observable
    class ViewModel {
        var requestStatus: RequestStatus = .idle
        var results: [Classifier.ClassifierResult] = []

        private var classifier = Classifier()

        func upload(_ image: UIImage) {
            Task { @MainActor in
                do {
                    requestStatus = .loading
                    results.removeAll()
                    results = try await classifier.classify(image: image)
                    requestStatus = .success
                } catch {
                    print(error.localizedDescription)
                    requestStatus = .error
                }
            }
        }
    }
}

Now we need to add some state. This stuff should probably go in the view model, but for now, I’m going to add these as member vars to ContentView …

// ContentView.swift
@State private var selectedImage: UIImage?
@State private var isImagePickerPresented = false
@State private var viewModel = ViewModel()
@State private var sourceType: UIImagePickerController.SourceType = .camera

Alright, now we’ll do some more UI building. Replace the body variable with this:

    var body: some View {
        VStack(spacing: 20) {
            HStack(spacing: 20) {
                if let image = selectedImage {
                    VStack {
                        Image(uiImage: image)
                            .resizable()
                            .scaledToFit()
                    }.padding()
                        .frame(maxHeight: 350)
                }
                List {
                    ForEach(viewModel.results, id: \\.id) { result in
                        VStack(alignment: .leading) {
                            Text(result.label)
                                .font(.callout)
                            Text(formatAsPercentage(result.confidence))
                                .font(.caption2)
                        }
                    }
                }
            }
            Divider()
            HStack(spacing: 20) {
                actionButton()
                if viewModel.requestStatus == .loading {
                    ProgressView()
                }
            }
        }
        .sheet(isPresented: $isImagePickerPresented) {
            ImagePicker(sourceType: $sourceType) { image in
                self.selectedImage = image
            }
        }
    }

And to address those compiler errors, add two new functions:

// ContentView.swift
@ViewBuilder
private func actionButton() -> some View {
    if let image = selectedImage {
        Button("Upload Image") {
            viewModel.upload(image)
        }.buttonStyle(.borderedProminent)
    } else {
        HStack(spacing: 20) {
            Button("Camera") {
                sourceType = .camera
                isImagePickerPresented = true
            }.buttonStyle(.bordered)
            Button("Photo Library") {
                sourceType = .photoLibrary
                isImagePickerPresented = true
            }.buttonStyle(.bordered)
        }.padding(.bottom, 20)
    }
}

// and

private func formatAsPercentage(_ value: Float) -> String {
    String(format: "%.2f%%", value * 100)
}

Heck yeah, you guys. If everything has gone according to plan, you should now be able to create/select a picture, upload it to the server, classify the dominant object in the picture, and then display the classification results in the UI!

If you run into issues, please feel free to reference the source code, or leave a comment below.

I hope this project inspires you and gets the gears turning for your next ML project.

Cheers!

\"\"

Deploy CoreML Models on the Server with Vapor was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/37afb7a6b26c","link":"https://medium.com/better-programming/full-stack-engineers-dont-exist-37afb7a6b26c?source=rss----d0b105d10f0a---4","title":"Full Stack Engineers Don’t Exist!","author":"Stephen Walsh","updated":"2023-11-10T17:28:33.460Z","published":"Fri, 10 Nov 2023 17:28:33 GMT","categories":["software-development","software-engineering","programming","careers","technology"]}]},"meta":{"timestamp":"2026-06-02T16:53:17.711Z","request_id":"48c08a68-e916-431c-88b0-5e8b335edfac"},"status":"ok","message":"Publication posts","success":true}}}},"401":{"description":"Missing or invalid x-oanor-key header"},"402":{"description":"Active subscription required"},"429":{"description":"Rate-limit or monthly quota reached"},"502":{"description":"Upstream did not respond"}}}},"/v1/tag":{"get":{"operationId":"get_v1_tag","tags":["Medium"],"summary":"Tag posts","description":"","parameters":[{"name":"tag","in":"query","required":true,"description":"Topic slug","schema":{"type":"string"},"example":"programming"}],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"feed":{"link":"https://medium.com/tag/programming/latest?source=rss------programming-5","image":"https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png","title":"Programming on Medium","description":"Latest stories tagged with Programming on Medium"},"count":9,"items":[{"guid":"https://medium.com/p/36024bdb36c6","link":"https://medium.com/techtofreedom/9-levels-of-profiling-python-apps-in-2026-from-cprofile-to-tachyon-36024bdb36c6?source=rss------programming-5","title":"9 Levels of Profiling Python Apps in 2026: From cProfile to Tachyon","author":"Yang Zhou","updated":"2026-06-02T16:38:28.436Z","published":"Tue, 02 Jun 2026 16:38:28 GMT","categories":["technology","python","software-engineering","programming","coding"]},{"guid":"https://medium.com/p/62467e5d41df","link":"https://medium.com/@kp9810113/the-day-our-2-week-sprint-became-a-6-week-death-march-62467e5d41df?source=rss------programming-5","title":"The Day Our 2-Week Sprint Became a 6-Week Death March","author":"The Concurrent Mind","updated":"2026-06-02T16:37:59.027Z","published":"Tue, 02 Jun 2026 16:37:58 GMT","categories":["programming","technology","software-development","tech","agile"]},{"guid":"https://medium.com/p/df5f5dc124b1","link":"https://medium.com/@folajeff/rhapsody-of-realities-2nd-june-2026-righteousness-is-the-nature-of-god-that-reveals-his-df5f5dc124b1?source=rss------programming-5","title":"RHAPSODY OF REALITIES - 2ND JUNE 2026\n\"Righteousness is the nature of God that reveals His…","author":"STARYLX","updated":"2026-06-02T16:37:56.400Z","published":"Tue, 02 Jun 2026 16:37:56 GMT","categories":["programming","design","productivity","self-improvement","creativity"]},{"guid":"https://medium.com/p/f21e6c82937b","link":"https://ottomancoder.medium.com/flutter-3-44-looks-like-a-minor-update-its-quietly-one-of-the-biggest-in-years-f21e6c82937b?source=rss------programming-5","title":"Flutter 3.44 Looks Like a Minor Update. It’s Quietly One of the Biggest in Years.","author":"Muhammad Usman","updated":"2026-06-02T16:20:29.095Z","published":"Tue, 02 Jun 2026 16:20:29 GMT","categories":["mobile-development","software-development","dart","flutter","programming"]},{"guid":"https://medium.com/p/36df887e70ef","link":"https://blog.cubed.run/i-built-an-ai-assistant-that-turns-messy-human-requests-into-real-tasks-36df887e70ef?source=rss------programming-5","title":"I Built an AI Assistant That Turns Messy Human Requests Into Real Tasks","author":"Ahmad Tariq","updated":"2026-06-02T16:14:41.161Z","published":"Tue, 02 Jun 2026 16:14:41 GMT","categories":["programming","technology","artificial-intelligence","machine-learning","coding"]},{"guid":"https://medium.com/p/581834f48f3c","link":"https://medium.com/javarevisited/9-powerful-java-apis-that-save-development-time-581834f48f3c?source=rss------programming-5","title":"9 Powerful Java APIs That Save Development Time","author":"Gopi C K","updated":"2026-06-02T16:00:16.647Z","published":"Tue, 02 Jun 2026 16:00:16 GMT","categories":["software-development","java","coding","programming"]},{"guid":"https://medium.com/p/c7a719846e47","link":"https://medium.com/javarevisited/i-misused-spring-boot-for-2-years-heres-what-finally-made-it-click-c7a719846e47?source=rss------programming-5","title":"I Misused Spring Boot for 2 Years — Here’s What Finally Made It Click","author":"Pushpak Raut","updated":"2026-06-02T16:00:08.676Z","published":"Tue, 02 Jun 2026 16:00:08 GMT","categories":["java","software-engineering","spring-boot","backend-development","programming"]},{"guid":"https://medium.com/p/3a1d3857692d","link":"https://medium.com/javarevisited/stop-writing-code-youll-regret-dry-kiss-yagni-and-the-law-of-demeter-explained-with-java-3a1d3857692d?source=rss------programming-5","title":"Stop Writing Code You’ll Regret: DRY, KISS, YAGNI, and the Law of Demeter Explained with Java","author":"Sumit Kumar Singh","updated":"2026-06-02T16:00:06.690Z","published":"Tue, 02 Jun 2026 16:00:06 GMT","categories":["system-design-interview","software-development","programming","design","software-engineering"]},{"guid":"https://medium.com/p/1a0385cfbb5a","link":"https://medium.com/javarevisited/command-design-pattern-in-java-a-practical-guide-to-undo-queues-retries-and-clean-architecture-1a0385cfbb5a?source=rss------programming-5","title":"Command Design Pattern in Java: A Practical Guide to Undo, Queues, Retries, and Clean Architecture","author":"Sumit Kumar Singh","updated":"2026-06-02T16:00:04.779Z","published":"Tue, 02 Jun 2026 16:00:04 GMT","categories":["software-engineering","software-development","design","system-design-interview","programming"]}]},"meta":{"timestamp":"2026-06-02T16:53:18.010Z","request_id":"8dfd41c7-b5f1-44aa-b966-7efe6e948129"},"status":"ok","message":"Tag posts","success":true}}}},"401":{"description":"Missing or invalid x-oanor-key header"},"402":{"description":"Active subscription required"},"429":{"description":"Rate-limit or monthly quota reached"},"502":{"description":"Upstream did not respond"}}}},"/v1/user":{"get":{"operationId":"get_v1_user","tags":["Medium"],"summary":"User posts","description":"","parameters":[{"name":"user","in":"query","required":true,"description":"Medium @handle (without @)","schema":{"type":"string"},"example":"medium"}],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"feed":{"link":"https://medium.com/@Medium?source=rss-504c7870fdb6------2","image":"https://cdn-images-1.medium.com/fit/c/150/150/1*8E6Laeaz-zMfU_rkpZUyKw.png","title":"Stories by Medium on Medium","description":"Stories by Medium on Medium"},"count":10,"items":[{"guid":"https://medium.com/p/62edea66ffa4","link":"https://medium.com/blog/updating-our-rules-june-2023-62edea66ffa4?source=rss-504c7870fdb6------2","title":"Updating Our Rules — June 2023","author":"Medium","excerpt":"Updating Our Rules — June 2023 This month, we are updating our Rules . As the world evolves, so do the ways in which people use Medium. To accommodate this, we regularly assess our rules, and adjust them accordingly. We believe that through helping people share their experiences and viewpoints, we c","updated":"2023-06-28T18:01:22.039Z","published":"Wed, 28 Jun 2023 18:01:22 GMT","categories":["rules","medium"],"content_html":"

Updating Our Rules — June 2023

This month, we are updating our Rules. As the world evolves, so do the ways in which people use Medium. To accommodate this, we regularly assess our rules, and adjust them accordingly.

We believe that through helping people share their experiences and viewpoints, we can foster greater levels of understanding, education, and acceptance. We realize that, at various moments in the larger cultural conversation, certain underrepresented groups become targeted, and our rules need to quickly evolve in order to maintain our mission of moving conversation forward. You can read more in our in post “Medium stands for LGBTQIA+ rights.”

New changes to our rules include expanding and improving the language around how we define hateful conflict to include slurs, deadnaming, and intentional misgendering.

Additionally, please note that accounts who plagiarize or commit copyright infringement will not be warned, and are not eligible for appeal. Please only post content to Medium which you own or have clear permission to use. If you are unsure if you can use someone else’s content, please see the EFF’s article on “Intellectual Property.”

We also did some general editing clean up, and removed redundant sections to make the rules page cleaner and easier to read.

The Medium Rules are available here. We track changes to our rules on Github so you can see how they evolve.

If you find content or accounts you feel violate our rules, please report it. You can use this form to provide more detail or to report other conduct. Additionally, you can always send an email to trust@medium.com.

\"\"

Updating Our Rules — June 2023 was originally published in The Medium Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/cccf29534bf4","link":"https://policy.medium.com/email-import-terms-of-use-cccf29534bf4?source=rss-504c7870fdb6------2","title":"Email Import Terms of Use","author":"Medium","excerpt":"Effective as of November 8th, 2021 By using this feature to import any email addresses (the “Email Import”), you represent and agree that: You have collected all email addresses that you will import through the Email Import in accordance with all applicable local, state, provincial, national, intern","updated":"2021-11-08T17:24:26.374Z","published":"Mon, 08 Nov 2021 17:24:26 GMT","categories":[],"content_html":"

Effective as of November 8th, 2021

By using this feature to import any email addresses (the “Email Import”), you represent and agree that:

Please note that your use of the Email Import is part of Medium services, and you must comply with our legal terms, including the Terms of Service, Privacy Policy, and Rules at all times. Medium reserves the right to suspend or terminate your access to Medium and its services with or without notice in Medium’s sole discretion

If you have any questions about this Email Import, please review our Help Center article.

\"\"

Email Import Terms of Use was originally published in Medium Policy on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/fcfe9cf777b8","link":"https://policy.medium.com/medium-partner-program-terms-fcfe9cf777b8?source=rss-504c7870fdb6------2","title":"Medium Partner Program Terms","author":"Medium","excerpt":"Effective as of June 1, 2026. These terms (the “Partner Program Terms”) govern A Medium Corporation’s (“Medium”) partner program (“Partner Program”). If you apply, meet the eligibility criteria, and are accepted into Medium’s Partner Program, you can (i) put a story from your user account behind Med","updated":"2026-06-01T20:09:10.689Z","published":"Wed, 11 Aug 2021 23:38:00 GMT","categories":["medium","terms-of-service"],"content_html":"

Effective as of June 1, 2026.

These terms (the “Partner Program Terms”) govern A Medium Corporation’s (“Medium”) partner program (“Partner Program”). If you apply, meet the eligibility criteria, and are accepted into Medium’s Partner Program, you can (i) put a story from your user account behind Medium’s paywall (“locking” a story) and receive revenue based on its performance among Medium members, and (ii) subject to your further evaluation and acceptance by Medium, to participate in the Editor Partner Program, as more specifically defined and described below. Medium reserves the right to modify, suspend, or discontinue the Partner Program, or any portion thereof, at any time and without advance notice to you. Medium will not be liable to you or any third party for any such modification, suspension, or termination.

By participating in the Partner Program, you agree to these Partner Program Terms, as well as Medium’s Terms of Service, Privacy Policy, Rules, and all other terms and conditions that apply to the Medium website, mobile applications, and any other Medium service or product (collectively, the “Terms”). Please read the Partner Program Terms carefully. If you don’t understand them, or don’t accept any part of them, then you can’t participate in the Partner Program. Your acceptance of Medium’s Partner Program Terms forms a binding agreement between you and Medium and shows your intent to be bound by them.

Eligibility & Application

To participate in the Partner Program, you must meet the Eligibility Requirements, apply, and be accepted into the Partner Program. Medium reserves the right to admit writers to the Partner Program at Medium’s sole discretion. Eligibility requirements are subject to change.

Existing Partner Program Participants: If you are a participant in the Partner Program as of August 1, 2024, you will remain in the program. However, to continue to participate in the Partner Program, you’ll need to meet the Eligibility Requirements by December 31, 2024. Medium will use reasonable efforts to contact you before removing you from the Partner Program if you no longer meet the Eligibility Requirements. If you are removed from the Partner Program, your locked stories will be removed from behind the paywall.

Ongoing Eligibility for all Partner Program participants: To remain in the Partner Program, you must continue to meet the Eligibility Requirements. In the event that we disable your ability to receive any revenue under the Partner Program and we subsequently determine that you meet the requirements to remain in the Partner Program, we may re-enable your ability to receive revenue under the Partner Program without requiring a reapplication from you for the Partner Program.

Earning on Locked Stories

User Stories
For each locked story associated with your account, you have the opportunity to receive revenue based on various performance factors, including reader engagement. Based on the performance and assessed quality of a story, Medium will pay you a portion of revenues received by Medium from membership fees, as determined by Medium. Medium will send you payment for any revenues above $10 USD accrued as described in the Payment section below. Medium reserves the right to adjust at any time the factors by which story performance and revenue are determined.

User Stories & Medium Publications
A locked story may be included in a Medium publication. The writer chooses whether to lock a story and will receive the same amount of funds through the Partner Program regardless of whether the story is included in a publication. As with any story, either the writer or the publication owner or editors may choose to remove a locked story from a publication at any time.

The above arrangement may be modified on a case-by-case basis, such as for publications operating on Medium that commission or own their content. For any such publication planning to receive proceeds from a story’s performance, this arrangement must be made clear to any writer potentially affected and agreed upon in advance with a given story’s writer.

Earning on Editing Activities

As a participant in the Partner Program, you will be eligible to apply to participate in Medium’s Editor Partner Program (the “EPP”). Medium reserves the right to admit or reject any applicant to the EPP at Medium’s sole discretion. Eligibility requirements for the EPP are described here and may be changed by Medium at any time without notice.

If Medium accepts your application to participate in the EPP, you will be permitted to edit eligible stories submitted to Medium publications of which you are an owner or an editor, in accordance with Medium’s editorial guidelines and policies. For each story you edit, you may earn compensation based on that story’s performance, as described in Medium’s EPP Pay Structure here. Medium retains sole discretion to determine which stories are eligible for editing under the EPP. Medium reserves the right to modify, suspend, or discontinue the EPP, or any portion thereof, at any time and without advance notice to you.

Note to Writers
Stories submitted to Medium may be edited by an editor participating in EPP. EPP editors may receive compensation from Medium based on the performance of stories they edit. Editor compensation is paid by Medium and does not affect the author’s earnings. By submitting a story to Medium, you acknowledge that your story may be edited by an EPP editor who may earn compensation in connection with your story’s performance.

Necessary Rights

You may only lock a story (i.e. place it behind Medium’s paywall) if you have sufficient rights to make commercial use of the content in it, including text, video, and audio elements. Medium may require you to provide documentation proving you own sufficient rights to lock a story.

The consequences of locking stories when you lack the rights to do so or failing to provide adequate documentation upon request include unlocking stories, withholding revenue, suspension, or termination from the Partner Program, and suspension or termination of your Medium account.

You are not entitled to earn or receive any revenue in connection with your content if one or more third parties claim rights to any element(s) of your content.

These Partner Terms are not legal advice. If you plan to lock and earn revenue on a story containing any content you did not create, you may want to talk to a lawyer first to ensure you own all rights required to do so.

Termination

Medium reserves the right to unlock a story at any time, which will end that story’s ability to generate revenue. Medium reserves the right in its sole discretion to disable your ability to receive any revenue under the Partner Program, suspend your participation in the Partner Program, or terminate your participation in the Partner Program at any time for any reason, including but not limited to the failure to meet the Eligibility Requirements, sustained inactivity in the Partner Program, or violation of any terms contained herein.

If your participation in the Partner Program is terminated for any reason, your locked stories will be unlocked and can no longer generate revenue, and you will no longer be eligible to earn from Medium’s deprecated Referral Earnings program.

Payment

To accrue or receive payment of any revenues under the Partner Program, you must be a Partner Program participant in good standing (meaning for example, your monetization is not currently disabled, you are not currently suspended, you are not violating Terms or have not violated the Terms, or have not been terminated), have at all times an active Medium account, and have at all times an active payout method associated with your Medium account. Medium does not owe you any revenue that may be associated with your content during any period when you are not in good standing in the Partner Program, do not have a valid Medium account, or do not have an active payout method. You will not receive any revenue if you do not have a payout account in a geographic region where the Partner Program is available. The list of available geographic regions is available here.

Medium reserves the right to require that your revenue meet a $10 minimum payout threshold before Medium disburses payment. In the event that you quit or are removed from the Partner Program and have not met the minimum payout threshold OR have not completed your payout settings, Medium reserves the right to forfeit the payment.

Changes or Discontinuation of Partner Program

Medium reserves the right to modify, suspend, or discontinue the Partner Program. Medium will not be liable to you or any third party for any such modification, suspension, or termination. Medium may change these Partner Program Terms from time to time so we encourage you to periodically review this page for the most up-to-date version.

Taxes

If required by law, you are responsible for reporting and paying any applicable taxes in connection with your participation in the Partner Program. Such taxes may include duties, customs fees, or other taxes (other than income tax), along with any related penalties or interest.

Governing Law & Forum

The governing law, mandatory forum, and dispute resolution provisions of Medium’s Terms of Service also apply to these Partner Program Terms and any dispute arising under them.

Miscellaneous

You participate in the Partner Program at your own risk. You agree that you are solely responsible for your actions in connection with the Partner Program, any breach of your obligations under the Partner Program Terms, and for the consequences of any such breach.

Any capitalized terms used but not defined in these Partner Program Terms have the meanings given to them in Medium’s Terms of Service. Except as modified by these Partner Program Terms, Medium’s Terms of Service remain in effect. Medium’s right to modify or revise the Terms of Service also applies to these Partner Program Terms.

Contact Us

If you have questions or feedback about the Partner Program, you can submit a request at help.medium.com.

\"\"

Medium Partner Program Terms was originally published in Medium Policy on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/30e5502c4eb4","link":"https://policy.medium.com/medium-rules-30e5502c4eb4?source=rss-504c7870fdb6------2","title":"Medium Rules","author":"Medium","excerpt":"Medium is an open platform that exists to share ideas and perspectives from the world’s most insightful writers, thinkers, and storytellers. We welcome thoughtful and civil discussion from a broad spectrum of viewpoints. To maintain a safe, respectful, and welcoming environment for a wide range of p","updated":"2024-09-24T17:46:09.785Z","published":"Wed, 26 May 2021 07:00:00 GMT","categories":["terms","medium","rules"],"content_html":"

Medium is an open platform that exists to share ideas and perspectives from the world’s most insightful writers, thinkers, and storytellers.

We welcome thoughtful and civil discussion from a broad spectrum of viewpoints. To maintain a safe, respectful, and welcoming environment for a wide range of people to engage in meaningful conversations, we prohibit certain conduct.

In deciding whether there has been a violation of the rules, we will take into consideration things like newsworthiness, the context and nature of the posted information, the likelihood and severity of actual or potential harms, account history, and applicable laws.

Violations of our rules may result in consequences such as account restrictions or suspension of your content. Medium has the sole authority and final decision as to whether content or behavior violates our rules.

To report a violation:

If you find a post or account on Medium that you believe violates these rules, please report it. You can find the report button in the 3-dot menu on every post, response, and account page.

You can use this form to provide more detail or to report other conduct you believe violates our rules. Additionally, you can send an email to trust@medium.com.

Block and mute:

If you find yourself in conflict with another user, we encourage the following:

Rules

Capitalized terms here have the same meaning as defined in the Medium Terms of Service.

Threats of violence and incitement
We do not allow content or actions that threaten, encourage, or incite violence against anyone, directly or indirectly.

Hateful content
We do not allow content that constitutes or promotes violence, harassment, or hatred against people based on characteristics like race, ethnicity, national origin, religion, caste, disability, disease, age, sexual orientation, gender, or gender identity.

We do not allow posts or accounts that glorify, celebrate, downplay, or trivialize violence, suffering, abuse, or deaths of individuals or groups. This includes the use of scientific or pseudoscientific claims or misleading statistics to pathologize, dehumanize, or disempower others. We do not allow calls for intolerance, exclusion, or segregation based on protected characteristics, nor do we allow the glorification of groups which do any of the above.

We do not allow posts or accounts that target others with slurs, tropes, or other content that intends to dehumanize, degrade or reinforce negative or harmful stereotypes about a protected category. For example, this may include targeted or intentional misgendering or deadnaming of transgender individuals, or harmfully ableist language.

We do not allow hateful text, images, symbols, or other content, including in your username, profile, or bio.

Harassment
Medium exists to share and discuss ideas. We don’t tolerate harassment, which includes:

Privacy and Reputation
We do not allow the following:

Restricted categories
We do not allow posts or accounts that engage in the following restricted categories of activity:

Related conduct
We do not allow content or accounts that engage in on-platform, off-platform, or cross-platform campaigns of targeting, harassment, hate speech, violence, or disinformation. We may consider off-platform actions in assessing a Medium account, and restrict access or availability to that account.

Graphic content
We do not allow posting, linking to, or otherwise promoting pornographic images or videos. We do allow erotic writing and non-graphic erotic images.

Medium is a large network, and posts can travel in front of all different types of readers. We ask that you be mindful of unintentional viewers when selecting your images.

We do not allow gratuitously graphic or disturbing media, regardless of subject matter.

Exploitation of minors
We do not allow content promoting the sexual, violent, or other exploitation of minors, including the sexualization of fictional minors.

Promotion and glorification of self-harm
We do not allow content or activities that encourage, promote or glorify acts of self-harm, such as cutting, eating disorders like anorexia or bulimia, and suicide. If you encounter users contemplating or threatening self-harm, please report it.

Duplicate Content
We do not allow posting duplicate copies of the same content to Medium, whether from a single account or across multiple accounts, either publicly or as an unlisted story. (You are allowed to cross-post content from your blog to Medium, provided you own the rights for the content.)

Spam or Site Misuse
We do not allow spam or misuse of Medium. All spam or misuse will be immediately removed from Medium without notification. Examples of spam or misuse include:

For each of these behaviors, when we talk about “content,” we mean not only posts but also any other feature that allows you to add your own text or media. When we talk about “interactions,” we mean any feature that allows one user to interact with another person or post.

Copyright and trademark infringement
Respect the copyrights and trademarks of others. Per our Terms of Service, we require users to have permission to post the content they publish on Medium. Additionally, we have specific policies around plagiarism, to which all Medium accounts are held. Users found in violation of our copyright rules are not eligible for warning, appeal, or restoration. Deletion of copyright violations is not grounds for reinstatement.

We respond to notices of alleged infringement as described in our Terms of Service, Copyright and DMCA Policy, and Trademark Policy.

Deceptive conduct
We do not allow deceptive conduct on Medium. This includes:

Ads, Promotions, and Marketing

Embedded Content and Collection of Personal Information
To ensure the data privacy and security of our users, embedded content must comply with the following requirements. An “embed” includes a link, form, or a request for information or other content.

Embeds directly collecting data through Medium form fields, comments or other onsite means are not allowed. This includes embeds that facilitate the submission of email addresses, credit card information or other personal information. If you want to collect information from your readers, you will need to follow these requirements:

Paid, automatic, bulk, or non-genuine interactions
Medium depends on various user behaviors — like follows and claps — to determine what content to feature and make the site work well for everyone. We don’t allow artificial behaviors that skew this system and as a result degrade or distort other users’ experiences.

This includes:

Cryptocurrency Accounts, Posts, and Publications
Posts and accounts that are focused on launching, announcing, or providing information on cryptocurrencies must meet the requirements listed in our Cryptocurrency Policy. Medium does not endorse or verify any coin, token, financial advice, or similar announcement.

Prohibitions on Use of the Services

You agree not to do, try to do, or cause a third party to do any of the following, except without the express written consent of Medium:

(1) access or tamper with non-public areas of the Services, our computer systems, or the systems of our technical providers;

(2) access or search the Services by any means other than the currently available, published interfaces (e.g., APIs) that we provide;

(3) forge any TCP/IP packet header or any part of the header information in any email or posting, or in any way use the Services to send altered, deceptive, or false source-identifying information;

(4) use the Services in any manner that could disable, overburden, damage, or impair the Services, or interfere with any other use of the Services;

(5) use any software, script, robot, spider or other automatic device, process or means (including crawlers, browser plugins and add-ons or any other technology) to access the Services for any purpose, including without limitation to scrape or otherwise copy any of the data or content on the Services;

(6) use any manual process to monitor or copy any of the data or content on the Services, or to engage in any other unauthorized purpose;

(7) otherwise use any device, software or routine that interferes with the proper working of the Services; or

(8) otherwise attempt to interfere with the proper working of the Services.

Use of custom domain features

Medium provides the ability to point a domain name that you control to a publication on Medium. If you use this custom domain feature, you understand that your publication will still be hosted on Medium and will still be subject to Medium’s Terms of Service. If you use this custom domain feature, you may not do, try to do, or cause a third party to do the following:

(1) Alter the look and feel or transform the content of the webpage, including by injecting ads, inserting tracking code, or altering the Medium look or feel;

(2) Use proxy servers or any other means to short-circuit our rules or circumvent user protections; or

(3) Mislead users about what site they are on or what their actions will do.

Your use of the custom domain feature must comply with our Privacy Policy. Please note that our rules around storing, transferring, and using user data are more user-protective than some other sites’. We do not sell user data or allow tracking of our users across the web. We expect you to uphold these same rules and policies in connection with operating your custom domain.

How to report a violation

If you find a post or account on Medium that violates these rules, please report it in product. You can use this form to provide more detail or to report other conduct you believe violates our rules. Additionally, you can send us an email to trust@medium.com.

If you break the rules

We strive to be fair, but we reserve the right to suspend accounts or remove content, without notice, for any reason, particularly to protect our services, infrastructure, users, or community. If you attempt to evade suspension by creating new accounts or posts, we will suspend your new accounts and posts.

Notice

Upon investigating or disabling content associated with your account, we will notify you, unless we believe your account is automated or operating in bad faith, or that notifying you is likely to cause, maintain or exacerbate harm to someone.

Appeals

If you believe your content or account has been restricted or disabled in error, or believe there is relevant context we were not aware of in reaching our determination, you can write to us at trust@medium.com. We will consider all good faith efforts to appeal.

Government Takedown Requests

If Medium receives a request from a government actor to restrict access to content associated with your account, we will notify you unless we are prohibited by law or believe doing so may endanger others. Where applicable, we will work to limit legally-ordered content restrictions to jurisdictions where we have a good faith belief that we are legally required to restrict the content. Medium submits to the Lumen database government requests to restrict access to content (redacted where appropriate to protect privacy or prevent harm to a person).

We may enforce, or not enforce, these policies at our sole discretion. These policies don’t create a duty or contractual obligation for us to act.

We also may change these rules at any time. We track changes to our rules on Github so you can see how they evolve.

Medium is committed to providing a transparent, open platform for expression and therefore supports the goals and spirit of The Santa Clara Principles on Transparency and Accountability in Content Moderation as a starting point for further discussion.

Updated June 2023

\"\"

Medium Rules was originally published in Medium Policy on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/f03bf92035c9","link":"https://policy.medium.com/medium-privacy-policy-f03bf92035c9?source=rss-504c7870fdb6------2","title":"Medium Privacy Policy","author":"Medium","excerpt":"Effective date: March 24, 2022 You can see our previous Privacy Policy here . This Privacy Policy explains how A Medium Corporation ( “ Medium ,” “ we ,” or “ us ” ) collects, uses, and discloses information about you. This Privacy Policy applies when you use our websites, mobile applications, and o","updated":"2026-05-07T20:03:52.753Z","published":"Tue, 01 Sep 2020 22:57:00 GMT","categories":["medium","privacy"],"content_html":"

Effective date: March 24, 2022

You can see our previous Privacy Policy here.

This Privacy Policy explains how A Medium Corporation (“Medium,” “we,” or “us”) collects, uses, and discloses information about you. This Privacy Policy applies when you use our websites, mobile applications, and other online products and services that link to this Privacy Policy (collectively, our “Services”), contact our customer service team, engage with us on social media, or otherwise interact with us.

We may change this Privacy Policy from time to time. If we make changes, we will notify you by revising the date at the top of this policy and, in some cases, we may provide you with additional notice (such as adding a statement to our website or providing you with a notification). We encourage you to review this Privacy Policy regularly to stay informed about our information practices and the choices available to you.

CONTENTS

COLLECTION OF INFORMATION

Information You Provide to Us

We collect information you provide directly to us. For example, you share information directly with us when you create an account, fill out a form, submit or post content through our Services, purchase a membership, communicate with us via third-party platforms, request customer support, or otherwise communicate with us. The types of personal information we may collect include your name, display name, username, bio, email address, business information, your content, including your avatar image, photos, posts, responses, and series published by you, and any other information you choose to provide.

In some cases, we may also collect information you provide about others, such as when you purchase a Medium membership as a gift for someone. We will use this information to fulfill your request and will not send communications to your contacts unrelated to your request, unless they separately consent to receive communications from us or otherwise engage with us.

We do not collect payment information through our Services. We rely on third parties to process payments in connection with our Services. Any information you provide to facilitate such a payment is subject to the third-party payment processor’s privacy policy, and we encourage you to review this policy before you provide any information to the payment processor.

Information We Collect Automatically When You Interact with Us

In some instances, we automatically collect certain information, including:

Information We Collect from Other Sources

We obtain information from third-party sources. For example, we may collect information about you from social networks, accounting services providers and data analytics providers. Additionally, if you create or log into your Medium account through a third-party platform (such as Apple, Facebook, Google, or Twitter), we will have access to certain information from that platform, such as your name, lists of friends or followers, birthday, and profile picture, in accordance with the authorization procedures determined by such platform.

Information We Derive

We may derive information or draw inferences about you based on the information we collect. For example, we may make inferences about your location based on your IP address or infer reading preferences based on your reading history.

USE OF INFORMATION

We use the information we collect to provide, maintain, and improve our Services, which includes publishing and distributing user-generated content, personalizing the posts you see and operating our metered paywall. We also use the information we collect to:

SHARING OF INFORMATION

We share personal information in the following circumstances or as otherwise described in this policy:

HELPING YOU CONNECT WITH PEOPLE YOU KNOW

When you use our address book feature, we process contact information from your device to help you discover people you know who are on Medium.

Why we do this: We rely on legitimate interests to offer this feature — specifically, our interest in helping you connect with people you know, and our mission to deepen collective understanding through writing, which supports your fundamental right to freedom of expression and information.

How it works: When you opt in, we convert contact names and email addresses into encrypted, non-reversible identifiers and match them against our member database. We don’t store names or emails in plain text. For contacts who aren’t Medium members, we delete their encrypted identifiers immediately after checking. We delete all encrypted identifiers within 30 days.

THIRD-PARTY EMBEDS

Medium does not host some of the content displayed on our Services. Users have the ability to post content that is actually hosted by a third party, but is embedded in our pages (an “Embed”). When you interact with an Embed, it can send information about your interaction to the hosting third party just as if you were visiting the third party’s site directly. For example, when you load a Medium post page with a YouTube video Embed and watch the video, YouTube receives information about your activity, such as your IP address and how much of the video you watch. Medium does not control what information third parties collect through Embeds or what they do with the information. This Privacy Policy does not apply to information collected through Embeds. The privacy policy belonging to the third party hosting the Embed applies to any information the Embed collects, and we recommend you review that policy before interacting with the Embed.

TRANSFER OF INFORMATION TO THE UNITED STATES AND OTHER COUNTRIES

Medium is headquartered in the United States, and we have operations and service providers in the United States and other countries. Therefore, we and our service providers may transfer your personal information to, or store or access it in, jurisdictions that may not provide levels of data protection that are equivalent to those of your home jurisdiction. For example, we transfer personal data to Amazon Web Services, one of our service providers that processes personal information for us in various data center locations across the globe, including those listed here. We will take steps to ensure that your personal information receives an adequate level of protection in the jurisdictions in which we process it.

YOUR CHOICES

Account Information

You may access, correct, delete and export your account information at any time by logging into the Services and navigating to the Settings page. Please note that if you choose to delete your account, we may continue to retain certain information about you as required by law or for our legitimate business purposes.

Cookies

Most web browsers are set to accept cookies by default. If you prefer, you can usually adjust your browser settings to remove or reject browser cookies. Please note that removing or rejecting cookies could affect the availability and functionality of our Services.

Communications Preferences

You may opt out of receiving certain communications from us, such as digests, newsletters, and activity notifications, by following the instructions in those communications or through your account’s Settings page. If you opt out, we may still send you administrative emails, such as those about your account or our ongoing business relations.

Mobile Push Notifications

With your consent, we may send push notifications to your mobile device. You can deactivate these messages at any time by changing the notification settings on your mobile device.

YOUR CALIFORNIA PRIVACY RIGHTS

The California Consumer Privacy Act or “CCPA” (Cal. Civ. Code § 1798.100 et seq.) affords consumers residing in California certain rights with respect to their personal information. If you are a California resident, this section applies to you.

In the preceding 12 months, we have collected the following categories of personal information: identifiers, commercial information, internet or other electronic network activity information, and inferences. For details about the precise data points we collect and the categories of sources of such collection, please see the Collection of Information section above. We collect personal information for the business and commercial purposes described in the Use of Information section above. In the preceding 12 months, we have disclosed the following categories of personal information for business purposes to the following categories of recipients:

\"\"

Link to a text version of this table

Medium does not sell your personal information.

Subject to certain limitations, you have the right to (1) request to know more about the categories and specific pieces of personal information we collect, use, and disclose about you, (2) request deletion of your personal information, (3) opt out of any sales of your personal information, if we engage in that activity in the future, and (4) not be discriminated against for exercising these rights. You may make these requests by emailing us at privacy@medium.com or by completing this webform. We will verify a webform request by asking you to provide identifying information. We will not discriminate against you if you exercise your rights under the CCPA.

If we receive your request from an authorized agent, we may ask for evidence that you have provided such agent with a power of attorney or that the agent otherwise has valid written authority to submit requests to exercise rights on your behalf. This may include requiring you to verify your identity. If you are an authorized agent seeking to make a request, please contact us.

ADDITIONAL DISCLOSURES FOR INDIVIDUALS IN EUROPE

If you are located in the European Economic Area (“EEA”), the United Kingdom, or Switzerland, you have certain rights and protections under applicable law regarding the processing of your personal data, and this section applies to you.

Legal Basis for Processing

When we process your personal data, we will do so in reliance on the following lawful bases:

Data Retention

We store personal data associated with your account for as long as your account remains active. If you close your account, we will delete your account data within 14 days. We store other personal data for as long as necessary to carry out the purposes for which we originally collected it and for other legitimate business purposes, including to meet our legal, regulatory, or other compliance obligations.

Data Subject Requests

Subject to certain limitations, you have the right to request access to the personal data we hold about you and to receive your data in a portable format, the right to ask that your personal data be corrected or erased, and the right to object to, or request that we restrict, certain processing. To exercise your rights:

Questions or Complaints

If you have a concern about our processing of personal data that we are not able to resolve, you have the right to lodge a complaint with the Data Protection Authority where you reside. Contact details for your Data Protection Authority can be found using the links below:

CONTACT US

If you have any questions about this Privacy Policy, please contact us at privacy@medium.com.

If you are from the EEA or the United Kingdom and have questions about this Privacy Policy, please contact us at privacy@medium.com or our privacy representatives as follows:

Privacy representative for EEA

Unit 3D North Point House
North Point Business Park
New Mallow Road
Cork T23AT2P
Ireland

Or here.

Privacy representative for the United Kingdom

37 Albert Embankment
London SE1 7TL
United Kingdom

Or here.

\"\"

Medium Privacy Policy was originally published in Medium Policy on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/9db0094a1e0f","link":"https://policy.medium.com/medium-terms-of-service-9db0094a1e0f?source=rss-504c7870fdb6------2","title":"Medium Terms of Service","author":"Medium","excerpt":"Effective: September 1, 2020 You can see our previous Terms here . Thanks for using Medium. Our mission is to deepen people’s understanding of the world and spread ideas that matter. These Terms of Service (“ Terms ”) apply to your access to and use of the websites, mobile applications and other onl","updated":"2026-05-12T19:40:11.374Z","published":"Tue, 01 Sep 2020 22:54:00 GMT","categories":["medium","terms","terms-and-conditions"],"content_html":"

Effective: September 1, 2020

You can see our previous Terms here.

Thanks for using Medium. Our mission is to deepen people’s understanding of the world and spread ideas that matter.

These Terms of Service (“Terms”) apply to your access to and use of the websites, mobile applications and other online products and services (collectively, the “Services”) provided by A Medium Corporation (“Medium” or “we”). By clicking your consent (e.g. “Continue,” “Sign-in,” or “Sign-up,”) or by using our Services, you agree to these Terms, including the mandatory arbitration provision and class action waiver in the Resolving Disputes; Binding Arbitration Section.

Our Privacy Policy explains how we collect and use your information while our Rules outline your responsibilities when using our Services. By using our Services, you’re agreeing to be bound by these Terms and our Rules. Please see our Privacy Policy for information about how we collect, use, share and otherwise process information about you.

If you have any questions about these Terms or our Services, please contact us at legal@medium.com.

Your Account and Responsibilities

You’re responsible for your use of the Services and any content you provide, including compliance with applicable laws. Content on the Services may be protected by others’ intellectual property rights. Please don’t copy, upload, download, or share content unless you have the right to do so.

Your use of the Services must comply with our Rules.

You may need to register for an account to access some or all of our Services. Help us keep your account protected. Safeguard your password to the account, and keep your account information current. We recommend that you do not share your password with others.

If you’re accepting these Terms and using the Services on behalf of someone else (such as another person or entity), you represent that you’re authorized to do so, and in that case the words “you” or “your” in these Terms include that other person or entity.

To use our Services, you must be at least 13 years old.

If you use the Services to access, collect, or use personal information about other Medium users (“Personal Information”), you agree to do so in compliance with applicable laws. You further agree not to sell any Personal Information, where the term “sell” has the meaning given to it under applicable laws.

For Personal Information you provide to us, you represent and warrant that you have lawfully collected the Personal Information and that you or a third party has provided all required notices and collected all required consents before collecting the Personal Information. You further represent and warrant that Medium’s use of such Personal Information in accordance with the purposes for which you provided us the Personal Information will not violate, misappropriate or infringe any rights of another (including intellectual property rights or privacy rights) and will not cause us to violate any applicable laws.

User Content on the Services

Medium may review your conduct and content for compliance with these Terms and our Rules, and reserves the right to remove any violating content.

Medium reserves the right to delete or disable content alleged to be infringing the intellectual property rights of others, and to terminate accounts of repeat infringers. We respond to notices of alleged copyright infringement if they comply with the law; please report such notices using our Copyright Policy.

Rights and Ownership

You retain your rights to any content you submit, post or display on or through the Services.

Unless otherwise agreed in writing, by submitting, posting, or displaying content on or through the Services, you grant Medium a nonexclusive, royalty-free, worldwide, fully paid, and sublicensable license to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, publicly perform and display your content and any name, username or likeness provided in connection with your content in all media formats and distribution methods now known or later developed on the Services.

Medium needs this license because you own your content and Medium therefore can’t display it across its various surfaces (i.e., mobile, web) without your permission.

This type of license also is needed to distribute your content across our Services. For example, you post a story on Medium. It is reproduced as versions on both our website and app, and distributed to multiple places within Medium, such as the homepage or reading lists. A modification might be that we show a snippet of your work (and not the full post) in a preview, with attribution to you. A derivative work might be a list of top authors or quotes on Medium that uses portions of your content, again with full attribution. This license applies to our Services only, and does not grant us any permissions outside of our Services.

So long as you comply with these Terms, Medium gives you a limited, personal, non-exclusive, and non-assignable license to access and use our Services.

The Services are protected by copyright, trademark, and other US and foreign laws. These Terms don’t grant you any right, title or interest in the Services, other users’ content on the Services, or Medium trademarks, logos or other brand features.

Separate and apart from the content you submit, post or display on our Services, we welcome feedback, including any comments, ideas and suggestions you have about our Services. We may use this feedback for any purpose, in our sole discretion, without any obligation to you. We may treat feedback as nonconfidential.

We may stop providing the Services or any of its features within our sole discretion. We also retain the right to create limits on use and storage and may remove or limit content distribution on the Services.

Termination

You’re free to stop using our Services at any time. We reserve the right to suspend or terminate your access to the Services with or without notice.

Transfer and Processing Data

In order for us to provide our Services, you agree that we may process, transfer and store information about you in the US and other countries, where you may not have the same rights and protections as you do under local law.

Indemnification

To the fullest extent permitted by applicable law, you will indemnify, defend and hold harmless Medium, and our officers, directors, agents, partners and employees (individually and collectively, the “Medium Parties”) from and against any losses, liabilities, claims, demands, damages, expenses or costs (“Claims”) arising out of or related to your violation, misappropriation or infringement of any rights of another (including intellectual property rights or privacy rights) or your violation of the law. You agree to promptly notify Medium Parties of any third-party Claims, cooperate with Medium Parties in defending such Claims and pay all fees, costs and expenses associated with defending such Claims (including attorneys’ fees). You also agree that the Medium Parties will have control of the defense or settlement, at Medium’s sole option, of any third-party Claims.

Disclaimers — Service is “As Is”

Medium aims to give you great Services but there are some things we can’t guarantee. Your use of our Services is at your sole risk. You understand that our Services and any content posted or shared by users on the Services are provided “as is” and “as available” without warranties of any kind, either express or implied, including implied warranties of merchantability, fitness for a particular purpose, title, and non-infringement. In addition, Medium doesn’t represent or warrant that our Services are accurate, complete, reliable, current or error-free. No advice or information obtained from Medium or through the Services will create any warranty or representation not expressly made in this paragraph. Medium may provide information about third-party products, services, activities or events, or we may allow third parties to make their content and information available on or through our Services (collectively, “Third-Party Content”). We do not control or endorse, and we make no representations or warranties regarding, any Third-Party Content. You access and use Third-Party Content at your own risk. Some locations don’t allow the disclaimers in this paragraph and so they might not apply to you.

Limitation of Liability

We don’t exclude or limit our liability to you where it would be illegal to do so; this includes any liability for the gross negligence, fraud or intentional misconduct of Medium or the other Medium Parties in providing the Services. In countries where the following types of exclusions aren’t allowed, we’re responsible to you only for losses and damages that are a reasonably foreseeable result of our failure to use reasonable care and skill or our breach of our contract with you. This paragraph doesn’t affect consumer rights that can’t be waived or limited by any contract or agreement.

In countries where exclusions or limitations of liability are allowed, Medium and Medium Parties won’t be liable for:

(a) Any indirect, consequential, exemplary, incidental, punitive, or special damages, or any loss of use, data or profits, under any legal theory, even if Medium or the other Medium Parties have been advised of the possibility of such damages.

(b) Other than for the types of liability we can’t limit by law (as described in this section), we limit the total liability of Medium and the other Medium Parties for any claim arising out of or relating to these Terms or our Services, regardless of the form of the action, to the greater of $50.00 USD or the amount paid by you to use our Services.

Resolving Disputes; Binding Arbitration

We want to address your concerns without needing a formal legal case. Before filing a claim against Medium, you agree to contact us and attempt to resolve the claim informally by sending a written notice of your claim by email at legal@medium.com or by certified mail addressed to A Medium Corporation, 3500 South DuPont Highway Suite IQ-101 Dover, DE 19901. The notice must (a) include your name, residence address, email address, and telephone number; (b) describe the nature and basis of the claim; and (c) set forth the specific relief sought. Our notice to you will be sent to the email address associated with your online account and will contain the information described above. If we can’t resolve matters within thirty (30) days after any notice is sent, either party may initiate a formal proceeding.

Please read the following section carefully because it requires you to arbitrate certain disputes and claims with Medium and limits the manner in which you can seek relief from us, unless you opt out of arbitration by following the instructions set forth below. No class or representative actions or arbitrations are allowed under this arbitration provision. In addition, arbitration precludes you from suing in court or having a jury trial.

(a) No Representative Actions. You and Medium agree that any dispute arising out of or related to these Terms or our Services is personal to you and Medium and that any dispute will be resolved solely through individual action, and will not be brought as a class arbitration, class action or any other type of representative proceeding.

(b) Arbitration of Disputes. Except for small claims disputes in which you or Medium seeks to bring an individual action in small claims court located in the county where you reside or disputes in which you or Medium seeks injunctive or other equitable relief for the alleged infringement or misappropriation of intellectual property, you and Medium waive your rights to a jury trial and to have any other dispute arising out of or related to these Terms or our Services, including claims related to privacy and data security, (collectively, “Disputes”) resolved in court. All Disputes submitted to JAMS will be resolved through confidential, binding arbitration before one arbitrator. Arbitration proceedings will be held in San Francisco, California unless you’re a consumer, in which case you may elect to hold the arbitration in your county of residence. For purposes of this section a “consumer” means a person using the Services for personal, family or household purposes. You and Medium agree that Disputes will be held in accordance with the JAMS Streamlined Arbitration Rules and Procedures (“JAMS Rules”). The most recent version of the JAMS Rules are available on the JAMS website and are incorporated into these Terms by reference. You either acknowledge and agree that you have read and understand the JAMS Rules or waive your opportunity to read the JAMS Rules and waive any claim that the JAMS Rules are unfair or should not apply for any reason.

(c) You and Medium agree that these Terms affect interstate commerce and that the enforceability of this section will be substantively and procedurally governed by the Federal Arbitration Act, 9 U.S.C. § 1, et seq. (the “FAA”), to the maximum extent permitted by applicable law. As limited by the FAA, these Terms and the JAMS Rules, the arbitrator will have exclusive authority to make all procedural and substantive decisions regarding any Dispute and to grant any remedy that would otherwise be available in court, including the power to determine the question of arbitrability. The arbitrator may conduct only an individual arbitration and may not consolidate more than one individual’s claims, preside over any type of class or representative proceeding or preside over any proceeding involving more than one individual.

(d) The arbitration will allow for the discovery or exchange of non-privileged information relevant to the Dispute. The arbitrator, Medium, and you will maintain the confidentiality of any arbitration proceedings, judgments and awards, including information gathered, prepared and presented for purposes of the arbitration or related to the Dispute(s) therein. The arbitrator will have the authority to make appropriate rulings to safeguard confidentiality, unless the law provides to the contrary. The duty of confidentiality doesn’t apply to the extent that disclosure is necessary to prepare for or conduct the arbitration hearing on the merits, in connection with a court application for a preliminary remedy, or in connection with a judicial challenge to an arbitration award or its enforcement, or to the extent that disclosure is otherwise required by law or judicial decision.

(e) You and Medium agree that for any arbitration you initiate, you will pay the filing fee (up to a maximum of $250 if you are a consumer), and Medium will pay the remaining JAMS fees and costs. For any arbitration initiated by Medium, Medium will pay all JAMS fees and costs. You and Medium agree that the state or federal courts of the State of California and the United States sitting in San Francisco, California have exclusive jurisdiction over any appeals and the enforcement of an arbitration award.

(f) Any Dispute must be filed within one year after the relevant claim arose; otherwise, the Dispute is permanently barred, which means that you and Medium will not have the right to assert the claim.

(g) You have the right to opt out of binding arbitration within 30 days of the date you first accepted the terms of this section by sending an email of your request to trust@medium.com. In order to be effective, the opt-out notice must include your full name and address and clearly indicate your intent to opt out of binding arbitration. By opting out of binding arbitration, you are agreeing to resolve Disputes in accordance with the next section regarding “Governing Law and Venue.”

(h) If any portion of this section is found to be unenforceable or unlawful for any reason, (1) the unenforceable or unlawful provision shall be severed from these Terms; (2) severance of the unenforceable or unlawful provision shall have no impact whatsoever on the remainder of this section or the parties’ ability to compel arbitration of any remaining claims on an individual basis pursuant to this section; and (3) to the extent that any claims must therefore proceed on a class, collective, consolidated, or representative basis, such claims must be litigated in a civil court of competent jurisdiction and not in arbitration, and the parties agree that litigation of those claims shall be stayed pending the outcome of any individual claims in arbitration. Further, if any part of this section is found to prohibit an individual claim seeking public injunctive relief, that provision will have no effect to the extent such relief is allowed to be sought out of arbitration, and the remainder of this section will be enforceable.

Governing Law and Venue

These Terms and any dispute that arises between you and Medium will be governed by California law except for its conflict of law principles. Any dispute between the parties that’s not subject to arbitration or can’t be heard in small claims court will be resolved in the state or federal courts of California and the United States, respectively, sitting in San Francisco, California.

Some countries have laws that require agreements to be governed by the local laws of the consumer’s country. This paragraph doesn’t override those laws.

Amendments

We may make changes to these Terms from time to time. If we make changes, we’ll provide you with notice of them by sending an email to the email address associated with your account, offering an in-product notification, or updating the date at the top of these Terms. Unless we say otherwise in our notice, the amended Terms will be effective immediately, and your continued use of our Services after we provide such notice will confirm your acceptance of the changes. If you don’t agree to the amended Terms, you must stop using our Services.

Severability

If any provision or part of a provision of these Terms is unlawful, void or unenforceable, that provision or part of the provision is deemed severable from these Terms and does not affect the validity and enforceability of any remaining provisions.

Miscellaneous

Medium’s failure to exercise or enforce any right or provision of these Terms will not operate as a waiver of such right or provision. These Terms, and the terms and policies listed in the Other Terms and Policies that May Apply to You Section, reflect the entire agreement between the parties relating to the subject matter hereof and supersede all prior agreements, statements and understandings of the parties. The section titles in these Terms are for convenience only and have no legal or contractual effect. Use of the word “including” will be interpreted to mean “including without limitation.” Except as otherwise provided herein, these Terms are intended solely for the benefit of the parties and are not intended to confer third-party beneficiary rights upon any other person or entity. You agree that communications and transactions between us may be conducted electronically.

Other Terms and Policies that May Apply to You

- Medium Rules
- Partner Program Terms
- Membership Terms of Service
- Username Policy
- Amendment to Medium Terms of Service Applicable to U.S. Government Users

\"\"

Medium Terms of Service was originally published in Medium Policy on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/bad566e3f7da","link":"https://medium.com/blog/clarifying-mediums-new-terms-of-service-bad566e3f7da?source=rss-504c7870fdb6------2","title":"Clarifying Medium’s new Terms of Service","author":"Medium","excerpt":"We appreciate the feedback about the language in our updated Terms of Service that focuses on your content rights. We first responded by preparing a short blog post explaining the updates. We’ve now edited the Terms of Service to more clearly reflect what we said in that post. Here’s the passage we’","updated":"2020-08-20T01:43:17.837Z","published":"Thu, 20 Aug 2020 01:21:16 GMT","categories":["ｍedium","terms-of-service"],"content_html":"

We appreciate the feedback about the language in our updated Terms of Service that focuses on your content rights. We first responded by preparing a short blog post explaining the updates.

We’ve now edited the Terms of Service to more clearly reflect what we said in that post.

Here’s the passage we’ve updated:

Rights and Ownership
You retain your rights to any content you submit, post or display on or through the Services.
Unless otherwise agreed in writing, by submitting, posting, or displaying content on or through the Services, you grant Medium a nonexclusive, royalty-free, worldwide, fully paid, and sublicensable license to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, publicly perform and display your content and any name, username or likeness provided in connection with your content in all media formats and distribution methods now known or later developed on the Services.
Medium needs this license because you own your content and Medium therefore can’t display it across its various surfaces (i.e., mobile, web) without your permission.
This type of license also is needed to distribute your content across our Services. For example, you post a story on Medium. It is reproduced as versions on both our website and app, and distributed to multiple places within Medium, such as the homepage or reading lists. A modification might be that we show a snippet of your work (and not the full post) in a preview, with attribution to you. A derivative work might be a list of top authors or quotes on Medium that uses portions of your content, again with full attribution. This license applies to our Services only, and does not grant us any permissions outside of our Services.

This license doesn’t give Medium permission to sell your content to a third party, and we’ll never do that. You’re not granting us permission to use your content outside of Medium. You’re also not granting us copyright to, or ownership of, your content. So, for example, we’ll never claim the right to develop your content into materials such as books, films, or television shows without your knowledge and express consent.

You’ll notice this license is royalty-free. This means posting to our services doesn’t involve any compensation to you (unless you’re in our Partner Program), just as you wouldn’t get compensated for posting to Twitter, Facebook, or LinkedIn.

And speaking of our Partner Program, these Terms of Service (just like the previous version of Medium’s Terms of Service) do not alter, modify, or supersede that program. All content you decide to put behind our paywall for monetization still earns you money based on subscribed Medium Member engagement. We’re not de-monetizing that content or changing the Partner Program terms.

To restate:

If you have any further questions, the best way to contact us is by emailing yourfriends@medium.com.

\"\"

Clarifying Medium’s new Terms of Service was originally published in The Medium Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/d03bed9978d8","link":"https://medium.com/blog/our-updated-terms-and-privacy-policy-d03bed9978d8?source=rss-504c7870fdb6------2","title":"Our Updated Terms and Privacy Policy","author":"Medium","excerpt":"**Edit 8/19/20: We have updated the language in the terms for more clarification. You can read more here: Clarifying Medium’s new Terms of Service You may have noticed a banner across all of Medium notifying you of our upcoming new Terms of Service and Privacy Policy. We’ve received some questions a","updated":"2020-08-20T01:34:01.849Z","published":"Tue, 18 Aug 2020 20:21:17 GMT","categories":["privacy","ｍedium","medium","terms"],"content_html":"

**Edit 8/19/20: We have updated the language in the terms for more clarification. You can read more here:

Clarifying Medium’s new Terms of Service

You may have noticed a banner across all of Medium notifying you of our upcoming new Terms of Service and Privacy Policy. We’ve received some questions about the updates, so we’d like to give you more context and information about them.

While some of the language in these policies has changed, Medium’s fundamental beliefs (and behaviors) have not. Here’s the deal:

Here are links to our latest Terms of Service and Privacy Policy. These go into effect on September 1st, 2020. Until that date, our existing Terms and Privacy Policy remain in effect. The purpose of the banner you’ve seen is to give you a heads-up about upcoming changes plus an opportunity to think about them and ask questions.

The following section in the new Terms of Service does have updated, but not materially new, language:

Rights and Ownership
You retain your rights to any content you submit, post or display on or through the Services.
Unless otherwise agreed in writing, by submitting, posting, or displaying content on or through the Services, you grant Medium a nonexclusive, royalty-free, worldwide, fully paid, and sublicensable license to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, publicly perform and display your content and any name, username or likeness provided in connection with your content in all media formats and distribution methods now known or later developed without compensation to you.

This is the same as the permissions in our Terms’ previous version. It’s just written in different language that’s more precise.

What this term means is that you’re granting us a license to reproduce the content you post on Medium within the surfaces and products served by Medium only. These are the referenced “Medium Services.” These services include our website, our official apps, and any other future product or service that is powered by the Medium network.

You are NOT granting us permission to use your content outside of the Medium network. You also are NOT granting us copyright to or ownership of your content. For example, we would make no claim of ownership over your copyright content for development into any other materials such as books, films, or television shows without your permission and participation.

Additionally, nothing about our updated Terms changes or overrides your ability to monetize any content you choose to publish into our Partner Program. Nothing is changing with the Partner Program.

In short, you still 100% own your content, and you remain in control of it.

You’re just granting us permission to display it on Medium. If you don’t agree to that, you’re free to export your content at any time from your Settings Page, and you retain complete ownership over it. You can also delete your account on that same page.

Additionally, we have moved the language regarding sale of your information from the Terms to our Privacy Policy. But it remains the same:

Medium does not sell your personal information.

Ever. Full stop. We have made a commitment to be an ad-free platform and, as such, we will not sell your information.

Additionally, we have clarified CCPA compliance and rights for California residents to our Privacy Policy, and added the option for all users to opt-out of binding arbitration in our Terms of Service.

Medium continues to respect and promote the rights of creators and users, and we stand firm in our commitment that you alone own and control your work and your data.

If you have any further questions, please send us an email to yourfriends@medium.com.

\"\"

Our Updated Terms and Privacy Policy was originally published in The Medium Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/503dd91c2edd","link":"https://medium.com/blog/medium-the-diversity-report-503dd91c2edd?source=rss-504c7870fdb6------2","title":"Medium: The Diversity Report","author":"Medium","excerpt":"2018 Edition We believe that having diverse perspectives and voices within our workforce is vital for us to offer diverse perspectives and voices to our readers, and the only way to have meaningful diversity at work is to foster an inclusive environment. Diversity for us includes, but is not limited","updated":"2019-01-25T20:36:51.935Z","published":"Fri, 25 Jan 2019 18:14:07 GMT","categories":["diversity","company-culture","inclusion"],"content_html":"

2018 Edition

\"\"

We believe that having diverse perspectives and voices within our workforce is vital for us to offer diverse perspectives and voices to our readers, and the only way to have meaningful diversity at work is to foster an inclusive environment. Diversity for us includes, but is not limited to, gender, ethnicity, race, culture, socio-economic background, religion, age, physical ability, veteran status, country of origin, primary language, sexuality, political preference, education, and family makeup.

The Data

Every year, we send an optional survey to our staff to gather demographic information and give employees a chance to voice whether they feel our workplace is diverse and inclusive. We sent the survey to staff hired up until November 13, 2018 and the responses are valid as of November 30, 2018. A few notes on the data:

Who We Are

As of November 13, 2018, we are comprised of 98 employees that identify mostly as introverts and ambiverts. We enjoy both outdoor and indoor activities, with a slight preference for staying indoors. Our current employees are based all over the US, with 75% of the company in San Francisco, 15% in New York and the rest working remotely. The largest team is engineering (46% of Medium) followed by Editorial (13%) and Product (11%).

Gender

The overall gender split for Medium is 39.6% (-0.6 percentage points from 2017) female and 60.4% male. For the tech roles, the split is 31.5% (-6.5pp from 2017) female and 68.5% male, while for non-tech roles, the ratio of female and male employees is even at 50% (+14pp for female held positions from 2017). In senior positions, we have 27.5% (+4.7pp from 2017) of the positions filled by female employees and the remaining 72.5% filled by male employees.

\"\"
\"\"

Race & Ethnicity

The current makeup of Medium is 63% of employees that identify as White. That’s an increase of +5pp from the previous year. There are also 24% of employees identifying as Asian, which represents an increase of +2pp from 2017. We have 9% of employees that identify as Black or African American and that’s a decrease of -2pp from last year. Other groups saw a marginal increase of +1–2pp from 2017.

We do not have any Black, African American, Hispanic, or Latinx employees at the senior level.

\"\"

Age, LGBTQ+ & Origin

There are other areas of diversity that we measure:

\"\"
\"\"
\"\"

Inclusion

We asked employees who they felt should be better represented at Medium. Combining direct answers to this question with free-form comments, 61% of respondents expressed a desire for a more diverse leadership team. Other areas where people felt Medium lacks diverse representation include: race & ethnicity, age, and political views.

\"\"

The free form comments also capture that as we continue to grow and become increasingly distributed as a workforce, we have an opportunity to ensure better parity around benefits and social events between remote worker and workers in our San Francisco office.

\"\"

Medium: The Diversity Report was originally published in The Medium Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

"},{"guid":"https://medium.com/p/aeee8ef5dacf","link":"https://medium.com/blog/ad-free-medium-aeee8ef5dacf?source=rss-504c7870fdb6------2","title":"Ad-Free Medium","author":"Medium","excerpt":"We’ve been putting our energy at Medium into improving quality — hosting more thoughtful and carefully written content, and improving the reading experience. We want to eliminate distractions that get in the way of reading flow and reduce distortions that could undermine your trust in what you read ","updated":"2018-07-17T18:37:47.385Z","published":"Tue, 17 Jul 2018 18:37:47 GMT","categories":["medium","policy"],"content_html":"

We’ve been putting our energy at Medium into improving quality — hosting more thoughtful and carefully written content, and improving the reading experience. We want to eliminate distractions that get in the way of reading flow and reduce distortions that could undermine your trust in what you read on Medium.

To that end, we‘re adjusting our policies related to commercial content.

Ads, Promotions, and Marketing

First, we’ll be restricting some kinds of commercial activity that have been allowed in the past, such as sponsorships and links that are mainly promotional. Medium’s business has been ad-free for more than a year now. But some “ad-like” remnants that had value in the past are now less aligned with Medium’s model of using subscriptions and a metered paywall to provide the best quality user experience. This means eliminating certain features that are superficially free, but for which you pay with attention.

So, as of September 1, 2018, our policies will include:

Embedded Content

Second, in preparing to comply with GDPR (the European Union’s new General Data Protection Regulation), it led us to step back, take a fresh look at our privacy practices, and renew our efforts to make Medium trustworthy. It raised questions about what types of data collection we should and should not allow through Medium. And in other cases, it led us to think about how to channel third-party data collection on Medium to make sure our users understand as clearly as possible what information about them is captured, by whom, where it winds up, and how it might be used.

As of September 1, 2018:

This includes embeds that facilitate the submission of email addresses and other personally identifying information through forms (such as Upscribe or Rabbut) and the submission of credit card information (such as Gumroad). We understand that this might make life harder for writers and publications who want to collect information directly from users. But, we believe this change is necessary to ensure that Medium readers know where their data is going and how it will be used.

Going forward, if you want to collect information from your users, you will need to link out from your post on Medium to a form hosted elsewhere that makes it clear to a user that they are no longer in the Medium network. We are working with Upscribe, Rabbut, and Gumroad so that their services function in line with these Medium policies.

We will continue to allow embeds that display content, such as YouTube, Vimeo, Soundcloud, GitHub, and others, as explained in our Help Center. Our Privacy Policy discusses in more detail how we treat this type of embed.

Thank you. We’re grateful for your continued use of Medium and appreciate your working with us to make Medium a place for thoughtful, high-quality stories.

\"\"

Ad-Free Medium was originally published in The Medium Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

"}]},"meta":{"timestamp":"2026-06-02T16:53:18.677Z","request_id":"4a4bca42-587d-4120-837e-7ab6f87a6765"},"status":"ok","message":"User posts","success":true}}}},"401":{"description":"Missing or invalid x-oanor-key header"},"402":{"description":"Active subscription required"},"429":{"description":"Rate-limit or monthly quota reached"},"502":{"description":"Upstream did not respond"}}}},"/v1/meta":{"get":{"operationId":"get_v1_meta","tags":["Meta"],"summary":"Spec","description":"","parameters":[],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"auth":"none upstream; gateway requires x-api-key","name":"Medium API","note":"Live, no cache. Returns recent posts (RSS-limited, typically up to 10) with title, author, link, categories and full content HTML. user = @handle, tag = topic slug, publication = publication slug.","source":"Medium public RSS feeds (medium.com/feed/...)","endpoints":4},"meta":{"timestamp":"2026-06-02T16:53:18.818Z","request_id":"0730090c-9cd6-48bf-9e55-c174374c75db"},"status":"ok","message":"Meta","success":true}}}},"401":{"description":"Missing or invalid x-oanor-key header"},"402":{"description":"Active subscription required"},"429":{"description":"Rate-limit or monthly quota reached"},"502":{"description":"Upstream did not respond"}}}}},"x-oanor-pricing":[{"slug":"free","name":"Free","price_cents_month":0,"monthly_call_quota":3500,"rps_limit":2,"hard_limit":true},{"slug":"starter","name":"Starter","price_cents_month":680,"monthly_call_quota":67000,"rps_limit":8,"hard_limit":true},{"slug":"pro","name":"Pro","price_cents_month":1950,"monthly_call_quota":335000,"rps_limit":20,"hard_limit":true},{"slug":"mega","name":"Mega","price_cents_month":4650,"monthly_call_quota":1640000,"rps_limit":50,"hard_limit":true}],"x-oanor-marketplace-url":"https://www.oanor.com/api/medium-api"}