{"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"},{"name":"Feeds"}],"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":"Tag/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","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"}}}},"/v1/publication-tag":{"get":{"operationId":"get_v1_publication_tag","tags":["Feeds"],"summary":"A publication's posts filtered to one tag","description":"","parameters":[{"name":"publication","in":"query","required":true,"description":"Publication slug","schema":{"type":"string"},"example":"better-programming"},{"name":"tag","in":"query","required":true,"description":"Tag slug","schema":{"type":"string"},"example":"programming"}],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"feed":{"link":"https://betterprogramming.pub/tagged/programming?source=rss----d0b105d10f0a--programming","image":"https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png","title":"Programming in Better Programming on Medium","description":"Latest stories tagged with Programming in Better Programming on Medium"},"count":10,"items":[{"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--programming","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--programming","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--programming","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"]},{"guid":"https://medium.com/p/d36df47f051d","link":"https://medium.com/better-programming/what-isomorphic-types-are-and-why-you-might-need-them-developing-with-swift-d36df47f051d?source=rss----d0b105d10f0a--programming","title":"What Isomorphic types are and why you might need them developing with Swift.","author":"Maksym Teslia","excerpt":"Image by author. A bit of general math * Note: we are not going to dive deep into theoretical definitions, instead will just discuss the conception using common terms. An isomorphism is a correspondence (relation) between objects or systems of objects expressing the equality of their structures in s","updated":"2023-11-10T17:27:51.075Z","published":"Fri, 10 Nov 2023 17:27:51 GMT","categories":["programming","math","swift","ios","debugging"],"content_html":"
\"\"
Image by author.

A bit of general math

* Note: we are not going to dive deep into theoretical definitions, instead will just discuss the conception using common terms.

An isomorphism is a correspondence (relation) between objects or systems of objects expressing the equality of their structures in some sense. — Encyclopedia of Mathematics.

Isomorphism is a core mathematical concept which is used for comparing various entities, such as groups, graphs, or vector spaces. It involves examination of their fundamental structure on order to determine if there is a correlation between their essential systemic properties. The presence of such correlation implies the isomorphism existence, confirming that these objects share a deep, intrinsic similarity.

In simple words, types are isomorphic when their properties are fundamentally related to each other. If we consider isomorphism from a practical perspective, we can describe it as a state when objects of different types can be converted to each other with no data loss. Actually, mathematical proof of this concept describes it very well. Let’s see how it looks like (very simplified and non-math-human readable):

Types A and B are isomorphic if there are two functions F: A -> B and G: B -> A, and for all objects (x) of type A calling G(F(x)) is equal to x as well as for all objects (y) of type B the result of calling F(G(y)) is equal to y.

“Very simplified and non-math-human readable”, but still does not look understandable enough? Well, let’s try to implement it in Swift, that should help to figure the above statement out, so you are able to fully grasp that knowledge.

Swift representation of this logic

In order to observe an example of Isomorphic behaviour in Swift, we would need to create a custom BoolImitation enumeration, which will have just two cases, pseudoTrue and pseudoFalse:

Now, you can construct two functions, one will accept BoolImitation instance and will return real Bool and second one will vice versa accept Bool and return BoolImitation:

For those who want to throw a rock in me due to “f” and “g” naming, I know it is not to be done this way, just want to be closer to math declarations, provided earlier.

Now, if you want to prove Bool and BoolImitation are isomorphic, you can call those functions in the manner, which has been described above:

As you can see, in both cases the resulting value of a call is gonna be the same as the value, which has been initially passed into a function chain. Let me explain how that works to enlighten it just in case. Will consider the first example.

When true is being passed inside of a g function, its inner logic transforms it into pseudoTrue along with returning it into an input parameter of function f. After that, f’s internal logic converts this pseudoTrue into true and returns it, so that it can be written into an fResult property. Logic of a second assignment is going to be operating in the same way.

If we shift closer to math and try to describe it using its language, we can state that “There are functions f of type (BoolImitation) -> Bool and g of type (Bool) -> BoolImitation, and for any object x of type BoolImitation calling g(f(x)) will result in returning x as well as for any object y if type Bool calling f(g(y)) will result in returning y”.

Therefore, remembering what we’ve studied in the first part, we can state that types can be transformed from one to another without losing any details, so, they are isomorphic!

How you can apply that knowledge

Issue

I bet you’ve seen such an example during your career path. You have two enumerations in your application, and both of them have identical cases naming. More than likely, they were represented as submodels of bigger view or data models.

That usually happens in applications which include ‘Buy-Use’ pattern of product handling, when you can order or purchase some product inside an application and then utilise in there. Typically, you receive the list of “available product” models from the server and then, once user purchases one of them, you construct “bought product” model, including “the type” of the product being secured. Let’s look closer into this pattern in order to check an example out.

So, we have two enums inside of our application, one is responsible for available product type and second one is responsible for purchased product type:

In the real world you’d have them inside of other bigger “AvailableProduct” and “PurchasedProduct” models, but let’s at that point ignore this for the sake of simplicity.

At some point, more than likely when the product is finally bought, you will have to transform “AvailableProduct” into a “PurchasedProduct”, including the type of it. Particularly for this, you’d need to construct this kind of function (other conditional checking approach can be used of course, but the conceptual idea would remain the same):

Generally, there is nothing wrong about it, but adding more products will make you to produce more cases, which will result in cyclomatic complexity increase, so your code becomes less readable and analysable.

Solution

If we inspect what happens inside getPurchasedProductType function, one specific behaviour can be spotted: in all the scenarios AvailableProductType instance will be transformed into a same name case of PurchasedProductType, therefore, in other words, they will be converted with no data loss.

Based on the above, we can state that those types are isomorphic, hence, there is a mathematical statement under the hood of their transformation. If there is one, we can surely describe it somehow within our application. For that, we would need to find some fundamental relation between their properties, which can be used by us in code. But what would that be?

I won’t muddy the waters and will tell you right away. For two enums with identically named cases that fundamental relation is a hashValue — if you have two enum cases with same names, it will be the same for both of them. If by now it is not clear why we would need it, hang tight, we will get to the implementation shortly.

Let’s start implementing our transforming functionality by establishing a protocol, which will describe any enum, which can be transformed through our custom isomorphic-related mechanism:

Protocol conformances are required to:

You will see why both of those protocols are required a bit further.

In order to conduct a transformation, we would need to create an “isomorphic context”, which is going to handle converting of one Isomorphicable instance into another one. In order to make this context reusable for any protocol conformant, we need to stick around generics and create a structure with two abstract types:

Instance of a structure will accept only one value into initialiser, that will be actual enum case of F type, which is then to be transformed into identical case of S type.

After we have the structure, we need the API which will return transformed case of type S to us. Not thinking of the name for a long time, we create it this way:

I promised you will see where Hashable and CaseIterable protocols come into play, so here they are.

First, we need to check if both enums have equal cases. If they don’t, we produce an error. Conceptually, ‘fatalError’ pattern for handling errors isn’t really suitable for production applications, but if the functionality is covered by tests and you are sure that potential crash isn’t going to leak into production, it is acceptable. This approach has been chosen here for the sake of simplicity, however, if you implement this mechanism in your app, you can either throw an error or use Result type, depending on your preferences.

If during the check we did not receive an error, we then iterate over all of the cases of “Second” enum to see which of them has the same hashValue as the one which was passed as an initialValue. Once such case is found, we return it to a final consumer. Force-unwrap is fully safe here, cause we know for sure that such a case exists after conducting an error check.

So, as we have everything settled, we can now use our Isomorphic structure to get rid of a switch inside getPurchasedProductType function and substitute it by the following call:

Voilà! Now if product count increases, you won’t have to care about that, cause this transformation is gonna be handled automatically, with help of isomorphic context we’ve created.

There are a few important points to keep in mind though. Firstly, you have to always be sure that cases of enums, placed into Isomorphic instance, are the same, otherwise, the error will be produced. Secondly, you can not use it on enums with different raw and associated values, cause it will influence hash values for their cases.

In this article we went through a mathematical concept of isomorphism and investigated in which cases it might be helpful in your daily development routine. There is a potential improvements wiggle room in that pattern of generic types transformation, you can be establishing this kind of approach for other cases of similar types conversion.

\"\"

What Isomorphic types are and why you might need them developing with Swift. 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/3049cf50a992","link":"https://medium.com/better-programming/exploring-rusts-option-type-a-guide-to-optional-value-handling-3049cf50a992?source=rss----d0b105d10f0a--programming","title":"Exploring Rust’s Option Type: A Guide to Optional Value Handling","author":"John Philip","updated":"2023-11-10T17:25:05.789Z","published":"Fri, 10 Nov 2023 17:25:05 GMT","categories":["programming","technology","rust-programming-language","rustlang","rust"]},{"guid":"https://medium.com/p/88a7c3b4f04d","link":"https://medium.com/better-programming/modern-data-is-a-painting-88a7c3b4f04d?source=rss----d0b105d10f0a--programming","title":"Modern Data is a painting","author":"Ievgenii Spitsyn (E. Fogwalker)","updated":"2023-11-10T17:24:53.269Z","published":"Fri, 10 Nov 2023 17:24:53 GMT","categories":["data-visualization","programming","virtual-reality","augmented-reality","web-development"]},{"guid":"https://medium.com/p/5be52e97fff0","link":"https://medium.com/better-programming/localisation-in-xcode-15-5be52e97fff0?source=rss----d0b105d10f0a--programming","title":"Localisation in Xcode 15","author":"Jacob Bartlett","updated":"2024-03-11T09:52:34.127Z","published":"Wed, 08 Nov 2023 11:31:57 GMT","categories":["programming","ios","apple","software-engineering","technology"]},{"guid":"https://medium.com/p/1ebd2d5005ec","link":"https://medium.com/better-programming/geometryreader-blessing-or-curse-1ebd2d5005ec?source=rss----d0b105d10f0a--programming","title":"GeometryReader: Blessing or Curse?","author":"fatbobman ( 东坡肘子)","updated":"2024-11-28T03:39:58.002Z","published":"Wed, 08 Nov 2023 02:06:15 GMT","categories":["programming","swiftui","mobile-app-development","swift","ios-development"]},{"guid":"https://medium.com/p/40bdaadbc22f","link":"https://medium.com/better-programming/everything-you-can-do-with-pythons-bisect-module-40bdaadbc22f?source=rss----d0b105d10f0a--programming","title":"Everything You Can Do With Python’s Bisect Module","author":"Martin Heinz","excerpt":"Learn how to optimize search and keep your data sorted in Python with the "bisect" module Photo by Jason Leung on Unsplash While Python’s bisect module is very simple - containing really just 2 functions - there's a lot one can do with it, including searching data efficiently, keeping ","updated":"2023-11-08T02:04:23.042Z","published":"Wed, 08 Nov 2023 02:04:23 GMT","categories":["data-science","technology","programming","python","software-engineering"],"content_html":"

Learn how to optimize search and keep your data sorted in Python with the "bisect" module

\"\"
Photo by Jason Leung on Unsplash

While Python’s bisect module is very simple - containing really just 2 functions - there's a lot one can do with it, including searching data efficiently, keeping any data sorted, and much more - and in this article we will explore all of it!

What is Bisect(ion)?

Before we start playing with the module, let’s first explain what bisect(ion) actually is. An official definition:

Bisection is the division of a given curve, figure, or interval into two equal parts (halves).

Which in plain English means that it implements a binary search. In practice that means that we can use it to — for example — insert elements into a list while maintaining the list in sorted order:

import bisect

some_list = [0, 6, 1, 5, 8, 2]
some_list.sort()
print(some_list) # [0, 1, 2, 5, 6, 8]

i = bisect.bisect_left(some_list, 4)
print(i)  # 3

some_list.insert(i, 4)
print(some_list)  # [0, 1, 2, 4, 5, 6, 8]
# OR
bisect.insort_left(some_list, 4)
print(some_list)  # [0, 1, 2, 4, 5, 6, 8]

In this basic example, we first sort a list because we can only use functions from bisect on sorted iterable. We then use bisect_left on the list to find an index where the second argument ( 4) should be inserted to maintain sorted order. We then proceed to do just that - insert the number 4 at index 3. Alternatively, we can directly use insort_left function which first uses bisect_left internally and then does the insert too.

Well, that’s cool, but why should you care about this module, though? Well, let me show you all the useful things you can do with it…

Binary Search

As already mentioned, bisect implements binary search so the most obvious use for it is just that:

from bisect import bisect_left

def binary_search(a, x, lo=0, hi=None):
    if hi is None:
        hi = len(a)
    pos = bisect_left(a, x, lo, hi)  # find insertion position
    return pos if pos != hi and a[pos] == x else -1  # don't walk off the end

print(binary_search([0, 1, 2, 5, 6, 8], 5))  # 3
print(binary_search([0, 1, 2, 5, 6, 8], 4))  # -1

The parameters of binary_search function above follow the same pattern as the functions in bisect module. That is - we look for value x in the list a between index lo and hi.

The only interesting line is the return statement, where we test whether the value x is actually in the list, if yes we return its position, otherwise we return -1.

Successive Equal Values

There are however more interesting things we can do with bisect module, for example finding successive equal values in a list:

from bisect import bisect_left, bisect_right

some_list = [5, 10, 15, 15, 15, 20, 25, 40]
# Find all the 15's
value = 15
start = bisect_left(some_list, value)
end = bisect_right(some_list, value)
print(f'Successive values of {value} from index {start} to {end}: {some_list[start:end]}')
# Successive values of 15 from index 2 to 5: [15, 15, 15]

We’ve already seen bisect_left, so here we also introduce bisect_right which does the same thing, but from the other end. This way we can locate both start and end of the span of successive values we're looking for.

Mapping from Intervals to Values

Now, let’s imagine that we have a series of intervals/ranges, and we want to return corresponding ID/value. A naive, ugly solution could look something like:

def interval_to_value(val):
    if val <= 100:
        return 0
    elif 100 < val <= 300:
        return 1
    elif 300 < val <= 500:
        return 2
    elif 500 < val <= 800:
        return 3
    elif 800 < val <= 1000:
        return 4
    elif val > 1000:
        return 5

But, there’s a much nicer solution using bisect_left:

def interval_to_value(val):
    return bisect_left([100, 300, 500, 800, 1000], val)

This isn’t just very clean solution but also super fast. It can be also extended in case you’d need a non-natural ordering or, for example, if you wanted to return something different, like a string:

i = interval_to_value(325)
a = ['absent', 'low', 'average', 'high', 'very high', 'extreme']
print(a[i])  # average

Closest Key in Dictionary

Now, let’s say we have a mapping in form of a dictionary, and we want to lookup values for a specified key. If the key exist then cool, but if it doesn’t, then we want to return the value of the closest key:

import collections
some_dict = collections.OrderedDict(
    [(0, 0), (2, 1), (4, 4), (6, 9), (8, 16), (10, 25), (12, 36), (14, 49), (16, 64), (18, 81)]
)

target = 10.5
index = bisect_left(list(some_dict.keys()), target)  # 6

items = list(some_dict.items())

# Check which one is closer:
print(f'Distance for to index {index}: {distance1}')    # Distance for to index 6: 1.5
print(f'Distance for to index {index-1}: {distance2}')  # Distance for to index 5: 0.5

print('Closest value:')
if distance1 < distance2:
    print(items[index])
else:
    print(items[index-1])

# Closest value: (10, 25)

Here we use OrderedDict to make sure that we have the keys in correct order. We then use bisect_left on them to find insertion point. Finally, we need to check whether the next or the previous index is closer to the target.

Prefix Search

Another thing you can use bisect for is prefix search - let's assume we have a very large word list and want to lookup words based on a given prefix:

def prefix_search(wordlist, prefix):
    try:
        index = bisect_left(wordlist, prefix)
        return wordlist[index].startswith(prefix)
    except IndexError:
        return False


words = ['another', 'data', 'date', 'hello', 'text', 'word']

print(prefix_search(words, 'dat'))  # True
print(prefix_search(words, 'xy'))  # False

The function above only check whether a word with specified prefix exists in the list, but this could be easily modified to loop from the index and return all the words starting with prefix.

If you have large enough word list, using bisect becomes much faster in comparison to just iterating the list from the start.

Sorted Custom Objects

So far we’ve only used built-in types, but functions from bisect module can be also applied to custom types. Let's say that we have a list of custom objects, and we want to maintain their order in the list based on some attribute:

from bisect import insort_left

class CustomObject:
    def __init__(self, val):
        self.prop = val  # The value to compare

    def __lt__(self, other):
        return self.prop < other.prop

    def __repr__(self):
        return 'CustomObject({})'.format(self.prop)

some_objects = sorted([CustomObject(7), CustomObject(1), CustomObject(3), CustomObject(9)])

insort_left(some_objects, CustomObject(2))
print(some_objects)  # [CustomObject(1), CustomObject(2), CustomObject(3), CustomObject(7), CustomObject(9)]

This code snippet uses the fact that bisect uses __lt__ magic method to compare objects. However, having to use bisect functions all the time might be a bit inconvenient, to avoid that you could implement a SortedCollection described in this more complete example/recipe.

Key Function

Functions in bisect module also support more complicated comparison/search using the the key function parameter:

some_list = [1, 3, 7, 16, 25]
some_list.reverse()
insort_left(some_list, 10, key=lambda x: -1 * x)
print(some_list)  # [25, 16, 10, 7, 3, 1]

Here we use the key function to implement a reverse order binary search, just remember that the list also has to be sorted in reverse order to begin with.

Similarly to reverse ordering, one might be also inclined to use key function for searching list of tuples, it’s however possible to do just:

list_of_tuples = [(1, 3), (3, 8), (5, 4), (10, 12)]

index = bisect_left(list_of_tuples, (5, ))  # 2
print(list_of_tuples[2])  # (5, 4)

Omitting the second value in the tuple forces bisect_left to compare only based on the first value. If you wanted to be explicit and use the key function anyway, then key=lambda i: i[0] would work too.

With that said, the key function is somewhat unintuitive — one would expect it to work like e.g. sorted function:

some_tuples = [
    (0, 10),
    (2, 12),
    (3, 15),
    (5, 20),
]

print(sorted(some_tuples, key=lambda t: t[0] + t[1]))  # Works

But it doesn’t:

index = bisect_left(some_tuples, (4, 17), key=lambda t: t[0] + t[1])  # Doesn't work
# Expectation: index = 3
# Reality: "TypeError: '<' not supported between instances of 'int' and 'tuple'"

def key_func(t):
    return t[0] + t[1]

index = bisect_left(some_tuples, key_func((4, 17)), key=key_func)
print(index)  # 3

Instead, we have to define a key function, pass it as a key argument and invoke it on the second argument, too.

That’s because (from docs):

key specifies a key function of one argument that is used to extract a comparison key from each element in the array. To support searching complex records, the key function is not applied to the x value.

Also see this GitHub issue in cpython repository for reasoning behind this design decision.

In my opinion, for such a tiny module, that’s a lot of things you can use it for.

Conclusion

Also, besides all the above useful things you can do with bisect, I want to highlight how fast this is - especially if you have a list that's already sorted. For example, consider this example on Stack Overflow showing that bisect_left is much faster than in operator.

It being binary search naturally means that it runs in O(log(n)), but it's further helped by being precompiled in C, so it's always going to be faster than anything you write yourself.

Python “Features” That Might Catch You By Surprise

Want to Connect?

This article was originally posted at martinheinz.dev.
\"\"

Everything You Can Do With Python’s Bisect Module 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/bf99876e985f","link":"https://medium.com/better-programming/ram-and-vram-profiling-in-python-bf99876e985f?source=rss----d0b105d10f0a--programming","title":"RAM and VRAM Profiling in Python","author":"Thomas Rouch","excerpt":"Efficiently monitor RAM and GPU VRAM simultaneously with a single powerful function decorator. Photo by John Cameron on Unsplash 1. Why profile memory usage? Introduction While the specific motivations for memory profiling in your code application may vary, the ultimate goal is always to enhance its","updated":"2023-11-08T02:02:05.695Z","published":"Wed, 08 Nov 2023 02:01:22 GMT","categories":["software-engineering","programming","data-science","machine-learning","artificial-intelligence"],"content_html":"

Efficiently monitor RAM and GPU VRAM simultaneously with a single powerful function decorator.

\"\"
Photo by John Cameron on Unsplash

1. Why profile memory usage?

Introduction

While the specific motivations for memory profiling in your code application may vary, the ultimate goal is always to enhance its speed and robustness. Here are some memory patterns that are useful to detect:

Don’t forget the GPU

When discussing memory constraints in a runtime application, it’s essential to distinguish between two specific types of memory:

Resource-constrained environments

In Computer Vision projects, the risk of running out of memory is prevalent due to the memory-intensive nature of image and video processing. The complex algorithms and deep learning models, along with large datasets, can overload the memory. Effective memory management and hardware configurations are crucial to prevent such issues.

The screenshot below shows the memory consumption (RAM) when an application ran out of of memory and got killed. This is precisely the scenario we aim to prevent when conducting memory profiling.

\"\"
Application got killed because it ran out of memory — Screenshot by the author

Here are possible causes of an Out-Of-Memory error:

\"\"
Photo by Bermix Studio on Unsplash

2. Choose the tool’s purpose

Goal

There isn’t a one-size-fits-all memory profiling tool. The choice depends on what you want to observe, as explained in the previous section.

In my case, I have a pipeline made of algorithmic blocks and I’d like to know the memory peak of each block in terms of RAM and VRAM.

\"\"
Example of RAM and VRAM Profiling on a pipeline of Photogrammetry (The displayed memory curves are for illustration and may not reflect an actual pipeline.) — Diagram by the author

For instance, taking into consideration the peak RAM and VRAM consumption of your pipeline is essential when choosing an Amazon EC2 instance. It ensures that you can align your application’s memory needs with the available resources of the selected EC2 instance, resulting in a well-balanced and cost-effective computing environment.

Existing memory profiling tools

There are amazing memory profiling tools available for free, like the two below:

Data collected by heaptrack might be too low-level in my case, since I’ve already identified in my pipeline the scopes that I want to profile.

The memory-profiler library provides an easy-to-use @profile decorator. Even though it profiles only RAM, we will draw inspiration from its logic to develop our own version that also monitors VRAM.

Let’s see how to implement our custom profiling decorator that tracks the peak RAM and VRAM consumption of a given function. (This will be a nice addition to the time profiling introduced in a previous Medium article Profiling and Multiprocessing in Python )

\"\"
Photo by Nick Karvounis on Unsplash

3. Basic Memory utilities

Psutil

The Python library psutil (process and system utilities) is used to retrieve information on running processes and system utilization.

The code below illustrates how to use it to retrieve (in bytes):

Nvidia-smi

If you’ve had prior experience with a GPU, you’ve certainly encountered the challenge of installing the right Nvidia drivers. Once everything is correctly set up, the nvidia-smi command-line tool provides real-time monitoring and management of Nvidia GPU devices.

\"\"
nvidia-smi command — Screenshot by the author

Python bindings for the Nvidia Management Library can be installed via pip3 install nvidia-ml-py3 .

Just like our approach with psutil, we can also obtain information about the used and total VRAM.

It makes sense to check beforehand whether or not the GPU is available so that the profiling decorator doesn’t raise an exception and just skips the VRAM profiling. Caching with the @lru_cache decorator prevents unnecessary calls to ‘nvidia-smi’.

I omitted it here for the sake of readability, but feel free to modify the upcoming functions in the following sections to incorporate a mechanism for bypassing VRAM-related tasks in case a GPU is unavailable.

Kilobytes or Kibibytes?

Now that we’ve figured out how to check the RAM and VRAM memory status, let’s talk about the units they use. They’re usually in bytes, which are quite small. We’re more familiar with kilobytes (kB), megabytes (MB), or gigabytes (GB).

But sometimes, in tools like the Ubuntu System Monitor or nvidia-smi, you’ll see ‘i’ added to the units, like GiB or MiB. These stand for Mebibytes and Gibibytes, not the same as Megabytes and Gigabytes. So, it’s important not to mix them up.

\"\"
Memory and Swap History part of the Resources section of the Ubuntu System Monitor (Left) and GPU Memory part displayed by the nvidia-smi command (Right) — Screenshot by the author

As explained in the tables below, Kilobytes use a decimal unit system, whereas kibibytes operate on a binary unit system.

\"\"
Decimal and Binary unit systems to count bytes — Tables by the author

The psutil library already provides a bytes2human method that converts a number of bytes into a human-readable string. However, I don’t like the fact that you can’t choose between the decimal or binary systems, so here’s my version. We compute the number of bytes corresponding to each symbol, e.g. K, M, or G, and then generate a string with the more appropriate unit to express the input memory quantity.

\"\"
Photo by Shane Aldendorff on Unsplash

4. Implement a RAM+VRAM profiling decorator

Context Manager

Using the utility tools defined in the previous section, we can now implement a single-function decorator for memory profiling.

As said earlier, we will draw inspiration from the logic of the @profile decorator of the memory-profiler library. The idea is quite simple: we launch a parallel process alongside the target function, periodically monitoring memory status until the function completes.

The class defined below is a context manager that implements the mechanism we’ve just described. When entering the context, the __enter__ method is called to launch a memory monitoring process (The definition of the _memory_monitor function comes right after), while the __exit__ method sends an event to stop the monitoring process. Finally, the memory peak is displayed in the console.

Core memory profiling function

As described earlier, the _memory_monitor function is pretty straight-forward and merely calls nvidia-smi and psutil at regular time intervals to keep track of the RAM/VRAM memory peak.

Function Decorator

Once we have the context manager, we can implement a function decorator at no cost. We just need to infer a pretty function name.

Conclusion

I hope you enjoyed reading this article and that it gave you more insights on how to monitor your code!

See more of my code on GitHub.
\"\"

RAM and VRAM Profiling in Python was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

"}]},"meta":{"timestamp":"2026-06-13T14:37:06.871Z","request_id":"7ffcd7eb-96ad-45d7-af02-1e247e13ad4e"},"status":"ok","message":"Publication posts by tag","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/recommended":{"get":{"operationId":"get_v1_recommended","tags":["Feeds"],"summary":"Stories a user has applauded for (their curation)","description":"","parameters":[{"name":"user","in":"query","required":true,"description":"Medium @handle","schema":{"type":"string"},"example":"quincylarson"}],"security":[{"oanorKey":[]}],"responses":{"200":{"description":"OK","content":{"application/json":{"example":{"data":{"feed":{"link":"https://medium.com/@quincylarson?source=rss-17756313f41a------3","image":"https://cdn-images-1.medium.com/fit/c/150/150/1*R0u5NcfQM5JfNjFNUMdVcw.jpeg","title":"Stories applauded for by Quincy Larson on Medium","description":"Latest stories applauded for by Quincy Larson on Medium"},"count":9,"items":[{"guid":"https://medium.com/p/0fb7bf339400","link":"https://medium.com/@takafumi.endo/prompt-requirements-document-prd-a-new-concept-for-the-vibe-coding-era-0fb7bf339400?source=rss-17756313f41a------3","title":"Prompt Requirements Document (PRD): A New Concept for the Vibe Coding Era","author":"Takafumi Endo","excerpt":"In conventional product development, the established approach has been to create a Product Requirements Document (PRD) to clearly outline product requirements for the development team. As agile development has gained popularity, the significance of PRDs has only grown. Historically, the PRD served a","updated":"2025-04-08T04:43:17.793Z","published":"Mon, 07 Apr 2025 15:45:51 GMT","categories":["startup","vibe-coding","model-context-protocol","cursor","ai"],"content_html":"

In conventional product development, the established approach has been to create a Product Requirements Document (PRD) to clearly outline product requirements for the development team. As agile development has gained popularity, the significance of PRDs has only grown. Historically, the PRD served as a blueprint to align stakeholders, developers, and designers under a unified vision. This alignment helped teams address issues like shifting specifications and misaligned expectations.

However, in what I call the Vibe Coding era — where AI and humans work side by side — I believe a new concept is necessary: the Prompt Requirements Document (PRD). Whereas traditional PRDs deal mostly with unstructured information for human-to-human alignment, this new PRD focuses on generating, editing, and managing structured prompts (including text, images, videos, and more) that both AI and humans can understand and use effectively.

This shift reflects our transition from an era where documentation preceded development to one where we first implement prototypes and then use them to define specifications or as input for AI to guide subsequent feature development.

Current AI-Assisted Development Environment

If you’ve used AI development tools like Cursor or Cline, you might be familiar with the .rules directory and mdc files used to prevent AI from generating unintended code. You can think of that as an early-stage precursor to what I’m calling the Prompt Requirements Document.

Anyone who’s embraced Vibe Coding or works on a team that leverages AI tools has probably gone through the trial-and-error process of figuring out good prompts. That’s because, without proper instructions and guidelines, AI can easily produce results that are off the mark — something developers experience on a daily basis.

Indeed, for teams using Claude or other AI tools, managing prompts has become a key challenge for effective communication. Today, it’s not just about code generation; AI is also used for defining requirements, testing, and documentation across the entire development lifecycle. To handle this scope successfully, a systematic approach is crucial.

\"\"
A sample of my .rules

Observed Limitations in AI Rule-Setting

I’ve been experimenting with various approaches to rule-setting. Lately, I’ve settled on a cycle of feature implementation → refactoring → rule updates. I let the AI implement a feature, then look for improvements and rework the design, and finally update the rules to capture our new insights. I use tools like Cursor, Cline, and Claude to keep this cycle moving swiftly.

Of course, there are still challenges. One main issue is that no matter how refined your rules are, you can’t fully control AI output. It’s heavily dependent on the constraints of the context window as well as the quality of the information you provide.

Over longer sessions, many developers have experienced how the AI’s focus can drift away from the original intent. This echoes the traditional problem of shifting requirements in software development, but in an AI-driven setting, it tends to appear even more pronounced.

Developing Optimal Starting Prompts for AI Collaboration

To address these challenges, many teams now leverage modes like “Plan” in Cline or “Architect” in Roo Code. They conduct a thorough review of the entire project, collaborate with AI to devise requirements and implementation plans upfront, and then execute development. This type of planning helps maintain clear alignment between humans and AI throughout the process.

In addition to rules, the quality of your initial prompt is incredibly important. Just like people, AI struggles to produce quality results when instructions are vague. That’s why the Prompt Requirements Document is so vital.

Even when utilizing Cursor with comprehensive .rules files and properly structured code, many developers have experienced how significantly initial instructions can influence outcomes. No matter how intelligent the AI, if the initial direction misses the mark, you can fall into unproductive response loops, accumulating implementations bloated with unnecessary context. It’s as if the team development atmosphere gradually deteriorates, making effective work increasingly challenging.

The Nature of Vibe Coders

Vibe Coders are typically brimming with enthusiasm and energy. They crave rapid development cycles and immediate results, preferring a “learn-as-you-go” style. They believe that by using AI, they can shortcut portions of the traditional process while still producing solid outcomes.

However, for this pace to be sustainable and truly efficient, it’s essential to raise the quality of AI interactions and ensure consistent output — and that’s precisely where the Prompt Requirements Document comes in.

By introducing a Prompt Requirements Document, even junior developers or non-technical contributors can leverage AI support to actively participate in complex projects. This, in turn, promotes diversity and creativity within the team.

The Prompt Requirements Document I envision holds this transformative potential. Ideally, such documentation shouldn’t create additional burden for developers or slow down the rapid cycle that Vibe Coders thrive in. Rather than requiring explicit documentation efforts, I believe PRDs will evolve to be automatically generated from the implementation traces left by Vibe Coders as they work.

These automatically generated documents would capture valuable patterns and insights that benefit both humans and AI, creating a virtuous learning cycle. This way, the documentation becomes an organic byproduct of the development process itself — enhancing collaboration without sacrificing the speed and spontaneity that defines the Vibe Coding approach.

G3 Framework of a Prompt Requirements Document

A well-crafted Prompt Requirements Document typically includes:

  1. Guideline: Shared AI-Human Understanding
    A comprehensive knowledge base that establishes the project context, technical rationale, and architectural decisions. This foundation ensures both AI assistants and human team members operate from the same understanding, creating consistency in approach and direction — similar to how a traditional PRD aligns stakeholders around product requirements.
  2. Guidance: Methodology for Evolving Prompt
    A structured approach designed to help developers evolve abstract ideas into precise instructions that AI systems can accurately interpret and execute. This system includes annotated prompt examples, pattern libraries, contextual best practices, and common pitfall warnings — enabling even those new to AI collaboration to create effective prompts that produce consistent, high-quality results.
  3. Guardrails: AI-Assisted Code Reviews
    A defined set of automated evaluation standards and quality checkpoints specifically tailored to address known project risks and recurring pain points. These guardrails enable AI systems to perform preliminary code reviews on pull requests, identifying basic issues before human review begins. This systematic approach reduces the cognitive load on human reviewers, allowing them to focus on more complex architectural concerns while ensuring consistent enforcement of code quality standards.

With these elements in place, Vibe Coders can take part in more advanced development processes and collaborate effectively with seasoned engineers.

Comparing Conventional PRDs and AI-Driven PRDs

Traditional PRDs and AI-driven PRDs — Prompt Requirements Documents — differ in several significant ways.

Rather than replacing traditional PRDs entirely, AI-driven PRDs are complementary. A hybrid approach that combines the strengths of both can be especially effective in modern development environments.

Where Prompt Requirements Documents Are Headed

While still in an experimental phase, Prompt Requirements Documents have the potential to become a foundational element of AI-driven development. My team’s products, Giselle (AI App Builder) and Liam (Database Builder), are already exploring ways to integrate these concepts into more tangible services and features. Ultimately, they’re all working toward the same goal: establishing a common language that makes it easier for humans and AI to cooperate.

Here are a few potential directions for the future:

An Ideal PRD Workflow

The ideal workflow for utilizing Prompt Requirements Documents might look like this:

  1. Initial Setup
    Define the basic rules and project overview.
  2. Requirements Design
    Clarify features in collaboration with AI.
  3. Refining Instructions
    Translate those features into machine-friendly prompts (like special “magic prompts”).
  4. Implementation
    Co-create code with AI and perform verification.
  5. Refactoring
    Improve quality and maintain coherence.
  6. PRD Updates
    Integrate lessons learned and new information back into the PRD.

In AI-assisted development case studies, teams have managed to drastically shorten development time by integrating requirements, implementation, and testing in a single streamlined process. In each of these success stories, a well-defined PRD and systematized AI communication were critical factors.

AI-driven PRD is a concept well-suited for the Vibe Coding era, but I believe it’s essential that the document itself can be updated with the same tempo and “vibe”. Teams and environments that can facilitate this kind of flexible updating will become stronger in the AI era.

The recent boom in Model Context Protocol (MCP) is further accelerating this trend. AI systems capable of performing a wide range of tasks from document analysis to read/write operations are making information increasingly accessible. As these technologies advance, the occasions where humans need to manually create documentation will likely diminish significantly.

Why Model Context Protocol (MCP) is Essential for Next-Generation Vibe Coding

PRDs as the Human-AI Bridge

Of course, adopting and using Prompt Requirements Documents comes with its own set of challenges:

Addressing these issues requires ongoing experimentation, learning within each team, and sharing best practices with the broader community.

In the Vibe Coding era, the skill of communicating effectively with AI can be just as crucial as coding prowess itself. Prompt Requirements Documents are poised to be a key resource for enhancing this communication, and I believe they will become central to future AI-driven development processes.

By focusing on the quality of prompts and leveraging AI tools, PRDs can introduce a more rapid, efficient, and collaborative style of development. Yet they also bring about new challenges — such as the need for better context and a drive toward standardization. As AI continues to evolve, PRDs will form the bridge between human creativity and machine efficiency.

I’m hopeful that this new methodology will gain broader acceptance, helping pave the way for a future in which humans and AI can work together in truly creative and productive ways.

\"\"
\"\""},{"guid":"https://medium.com/p/a443a2c0127c","link":"https://medium.com/@donna.m.ware/the-guardian-angel-of-my-post-pandemic-career-change-is-freecodecamp-org-a443a2c0127c?source=rss-17756313f41a------3","title":"The Guardian Angel of My Post Pandemic Career Change is freeCodeCamp.org","author":"Donna M Ware","excerpt":"Why I Changed My Career Post-Covid I had been fantasizing about how I would escape the toxic relationship that was sucking the air from my lungs and killing me from the inside out. Then one night, my dream finally became a reality. When I got home, I was greeted by the cold eyes of my ex. I could te","updated":"2022-08-08T12:57:53.470Z","published":"Mon, 08 Aug 2022 12:26:57 GMT","categories":["coding","career-change","quincy-larson","freecodecamp","post-pandemic"],"content_html":"

Why I Changed My Career Post-Covid

\"\"

I had been fantasizing about how I would escape the toxic relationship that was sucking the air from my lungs and killing me from the inside out. Then one night, my dream finally became a reality. When I got home, I was greeted by the cold eyes of my ex. I could tell he was drunk and geared up to punish me for some crazy shit he’d concocted in his mind. I had had enough and decided that motherfucker wasn’t going to hit me that night. I packed three bags and bought a one-way train ticket from Detroit to Rhode Island.

That was about seven years ago, jump start to 2020 and the seeds of my risky jump were finally beginning to sprout. I had miraculously saved enough money to open my own hair salon, my business was starting to grow and I could see the light at the end of the tunnel. Then the Goddamned pandemic hit…

Covid, The Catalyst of Change

I was mandated to temporarily close my salon. The CDC(Centers of Disease Control and Prevention) and Dr. Fauci determined hair care was a nonessential convenience. Over the course of those bizaare times, the Coronavirus pandemic changed everything, including me.

Working from home felt safe. I weighed my options and made a career shift. I now have a home-based business doing copy/content writing and website development.

\"\"

The Absurd Amount of Free Training I am Devouring at freeCodeCamp.org

As a website developer coding is essential for my success. But how was I going to learn coding? Surprisingly, I discovered many free options, the one I chose was freeCodeCamp.org. freeCodeCamp’s specific and concise curriculum is designed for clueless newbies like me.

I had zilch coding experience and didn’t know where to start. freeCodeCamp.org solved that problem with its building block design. I am forever grateful to Quincy Larson’s well thought out program that’s walking me through coding step-by-step. I am also beyond thankful for the insane amount of tutorials freeCodeCamp.org provides on YouTube. So many people have put their time and expertise into easy to understand videos that help me when I get stuck on a lesson.

I am feeling especially blessed for this awesome program because academia didn’t offer me anymore options. Like many other Americans, I am maxed out on my student loans.

I already have a bachelor’s of arts degree in philosophy and tons of credits towards my master’s. But due to my poor choice in a spouse, I quickly exasperated my student loan limits. Attending school while I was in an unstable marriage destroyed any chances of properly using my student loan money.

I was constantly on academic probation, re-taking classes, dropping classes and basically fucking up. I thank God for freeCodeCamp.org and the many other free training opportunities available for people like me; who have found themselves in tough financial positions. Especially concerning the building of new skill sets, they are essential in this post-pandemic era.

\"\"

Don’t Give Up on Your Dreams

If you are reading this and are in any way inspired, take the next step! The Covid-19 pandemic has forever reshaped the way we work. People want change and are taking control of how and where they work. There are so many free training options available and inspirational stories of people beating the odds.

Technology isn’t the only transitional career path that offers free education. Believe in yourself and start Googling the things you find interesting. YouTube is another platform that offers an incredible amount of how to information. Here are some cool things I’ve found that might interest you:

The New Frontier of Careers and Education

freeCodeCamp.org has been my educational guardian angel, navigating me through the changing landscape of technology. There are many educators available, in other fields. They are just waiting for your arrival.

\"\""},{"guid":"https://medium.com/p/ab1a14538684","link":"https://darrellsilver.medium.com/ive-started-a-company-company-ab1a14538684?source=rss-17756313f41a------3","title":"I’ve started a company company!","author":"Darrell Silver","excerpt":"Frustration is the better mother of invention so 18 months ago I backed Ben to start Union . Mostly it was to shut him up. Ben is Thinkful’s former Head of People where he scaled us from 30 to 130 FTEs and played a critical role in our acquisition. But he spent 2020 complaining that the companies he","updated":"2022-07-07T15:25:35.897Z","published":"Thu, 07 Jul 2022 15:25:35 GMT","categories":[],"content_html":"
\"\"

Frustration is the better mother of invention so 18 months ago I backed Ben to start Union. Mostly it was to shut him up. Ben is Thinkful’s former Head of People where he scaled us from 30 to 130 FTEs and played a critical role in our acquisition. But he spent 2020 complaining that the companies he was excited to work for were headed toward avoidable mistakes without the will to avoid them. For my part I had just left Chegg and was heading for some lived-through-M&A-and-integration-worked-full-time-since-2004-about-to-turn-40 time off.

My time off really was mostly time off: building a woodshop, traveling, all that good stuff. But backing Ben was so rewarding I found myself repeating it two more times with two other underappreciated founders, supporting two non-profits (Donate to Child Advocacy! Donate to freeCodeCamp!), advising and/or investing in 20 Seed to D-stage companies, and trying but failing to get excited about crypto.

Union is a recruiting firm that gets companies to hire better, retain longer, and manage performance without bias. Because of Ben in 10 years no one will hire in-house HR. I’ve backed him with early customer intros, a budget in case it wasn’t quickly profitable, and a promise to collaborate on how to grow.

The last 18 months taught me something stupidly unexpected: There’s boundless fulfillment in helping someone else succeed. That’s weird, right? Have I mentioned I was the CEO of Thinkful, an entire school based on mentoring? Yes, well, perhaps Ben, Blake, Parniyan, and Arlyss have just shown me how to mix co-founding (which I’ve loved since 2009!) and mentoring (which I fell in love with thanks to Dan in 2012!) and investing (which is nearly criminally not time consuming…).

Which brings us to starting a company company. Three days a week I’m now working as a co-founder on three companies under the arbitrarily named holding company “503 Corp”. Union is profitable, growing 10% monthly, isn’t saas (yet) and as a result can’t yet be a monopoly (and so isn’t yet raising money). The others are earlier, but like Union, need to exist. Aside from their great co-founders, each share a belief that companies and careers will be better with fewer cost centers. Instead of reluctantly hiring cost center FTEs then slowly integrating software together, companies by 2030 will hire great experts that come bundled with best in class software that can be piloted cheaply, turned on quickly, and scaled endlessly. 503 is testing where that thesis proves most true. Put another way, 503 is creating companies like Pilot, which already bundles bookkeeping with QuickBooks. Union is Pilot for HR, the second company is Pilot for FP&A, and the third, GoodGig, is Pilot for subcontracting.

My other days are spent researching, maybe another company, we’ll see.

\"\""},{"guid":"https://medium.com/p/fe53909aca8b","link":"https://medium.com/@jaybhaskar/collaborative-workflows-under-the-ka%E1%B9%87%C4%81da-open-source-initiative-kosi-fe53909aca8b?source=rss-17756313f41a------3","title":"Collaborative Workflows under The Kaṇāda Open Source Initiative (KOSI)","author":"Bhaskar Jayaraman","excerpt":"Collaborative Workflows Collaborative Workflows — Making document reviews easier With Collaborative Workflows you can prevent accidental sharing and usage of docs by capturing and displaying their workflow state, so the document collaborator knows, whether the author of the doc is requesting for doc","updated":"2022-09-27T15:23:13.467Z","published":"Sun, 30 Aug 2020 23:05:13 GMT","categories":["g-suite","apps-script","civilization","science","history"],"content_html":"

Collaborative Workflows

Collaborative Workflows — Making document reviews easier

With Collaborative Workflows you can prevent accidental sharing and usage of docs by capturing and displaying their workflow state, so the document collaborator knows, whether the author of the doc is requesting for document approval, whether they have all necessary approvals, whether they’ve made all changes requested, look up the list of reviewers, and if it’s been published.

The document state is saved within the document’s key value store so you don’t need any external database to save state. You may extend it’s functionality further with the source code shared.

Installation

Use this github repo link to get a copy of this project — https://github.com/lotusbaba/Collaborative-Workflows

The first step in running this project is to open a google apps script project on https://script.google.com and creating your first apps script project.

Google doesn’t let you publish the project on the G Suite Marketplace so you can make it work you in one of the following ways -

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

The drawback to the above approach is that the app wont be available on other doc files or on any other G-docs suite such as spreadsheets and slides.

Installing the app on every doc one by one by opening the script editor is not a scalable approach but it helps you test the app

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

Usage

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

Closing Remarks

This project is published under the Kaṇāda Open Source Initiative (KOSI). This is an initiative to spread awareness about unrecognized individuals or peoples whose important contributions in science, technology, philosophy, language, politics, art, architecture, and culture continue to have an impact to this day.

Kaṇāda’s writings lead us to conclude that he was what we would call a theoretical physicist who validated several thought experiments.
His postulations of the laws of motion predate any other modern day scientist.

Simple rules to follow while contributing with Kaṇāda Open Source Initiative (KOSI)
1. Please use primary or secondary sources of reference such as yours or someone else’s research on the topic, via writings, pictures, or videos
2. Please avoid tertiary sources of reference (i.e. to wikipedia, quora etc.)
3. Please make an effort to publish code which is useful and not just snippets
4. You may use the preamble or inline description for your stories and references e.g. to the Incas and their art or architecture
5. Please include this preamble to your project and if it’s an HTML file you will notice the preamble is enclosed within the <script> element

\"\"
\"\""},{"guid":"https://medium.com/p/ffb7ff4ae828","link":"https://darrellsilver.medium.com/why-im-donating-150k-to-freecodecamp-to-help-fund-their-next-big-curriculum-ffb7ff4ae828?source=rss-17756313f41a------3","title":"Why I’m donating $150k to freeCodeCamp to help fund their next big curriculum","author":"Darrell Silver","excerpt":"Why I’m donating $150k to freeCodeCamp to help fund their advanced math & machine learning curriculum freeCodeCamp is a non-profit unicorn: It delivered 1.3 billion minutes of free coding education last year, grows 60% every year, and is sustainably run by just 12 full time staff and hundreds of","updated":"2021-02-02T17:31:53.788Z","published":"Tue, 02 Feb 2021 17:31:53 GMT","categories":["coding","freecodecamp","education","non-profit-organization"],"content_html":"

Why I’m donating $150k to freeCodeCamp to help fund their advanced math & machine learning curriculum

freeCodeCamp is a non-profit unicorn: It delivered 1.3 billion minutes of free coding education last year, grows 60% every year, and is sustainably run by just 12 full time staff and hundreds of volunteers. That’s a smaller team than when Facebook acquired Instagram for $1b.

\"freeCodeCamp

A few weeks ago I saw a tweet offering a way to support them for just $5 / month. I wondered if there was a way to help accelerate them toward the second.

I wrote Quincy, the founder. “If you could raise tens of thousands all at once, what would you do with it?”

His reply:

Math. You can get a developer job without a strong background in math. But you’ll need to learn statistics and linear algebra before you can do a lot of software engineering and data science tasks. Traditionally developers have learned these by going back to school to get a graduate degree. But what if developers had a linear curriculum to learn math, data science, and machine learning at their own pace, for free?

The more I learned the more I fell in love.

First, non-profit giving is super expensive. For every dollar you give most well respected non-profits spend 20 cents on raising more dollars (and best practice allow up to 35 cents!). By comparison, freeCodeCamp spends $0.00 on fundraising. Instead, it maintains a SaaS-like donation system. This means for every dollar donated to freeCodeCamp, one hundred pennies go toward providing more minutes of learning to people around the world.

Second, large-dollar donors make non-profits’ budgets unpredictable, making attracting top talent very difficult. But freeCodeCamp is funded almost entirely by a broad coalition of $5 / month supporters. So its future cash flows are far more predictable — similar to the most robust B2C businesses. This stability means Quincy attracts the best talent, which creates — you guessed it — even more minutes of (free!) learning.

Third, after 5 years of running their YouTube ad-free, freeCodeCamp just turned on YouTube ads. But instead of going on a big spending spree they’re saving all that ad revenue for a rainy day, giving them even more long-term stability. Again, while most non-profits spend money on ads for fundraising, freeCodeCamp earns money from ads, instead growing through reputation and SEO.

Put it all together and freeCodeCamp represents the rarest of rare opportunities: self-sustaining non-profit unicorn. The staff, the tools, the servers, the community … it’s already self-sustaining because monthly donations grow in tandem with usage. So, when we expand curriculum in math and machine learning it’ll increase use, which will increase the donor base. This one-time donation will sustainably increase both baseline usage and monthly donations.

That’s where you and I come in. I’m 100% matching all donations to freeCodeCamp, up to a total raised of $300k. If you’ve ever considered giving $50 to the the most efficient education non-profit on the web, now’s your chance to make it double: Your $50 automatically becomes $100.

Donate now.

And after eight years in online coding education I’ve come to greatly respect what Quincy is building and how he’s building it. Education and entrepreneurship take passion and patience. For most of us it takes money, too. Quincy has shown how to build a unicorn.

\"\"
\"\""},{"guid":"https://medium.com/p/9699a2e1132f","link":"https://darrellsilver.medium.com/departing-thinkful-a-new-call-to-code-9699a2e1132f?source=rss-17756313f41a------3","title":"Departing Thinkful & A New Call to Code","author":"Darrell Silver","excerpt":"When we founded Thinkful in 2012 it was labeled “alternative” education second to degrees and 4-year college. Eight years later 62% of Americans prefer non-degree skills training over degrees. In 2019 we sold to Chegg for $100m , lowered prices for students, integrated, hit plan , and hired for the ","updated":"2020-10-28T21:31:46.497Z","published":"Tue, 27 Oct 2020 20:35:59 GMT","categories":[],"content_html":"

When we founded Thinkful in 2012 it was labeled “alternative” education second to degrees and 4-year college. Eight years later 62% of Americans prefer non-degree skills training over degrees. In 2019 we sold to Chegg for $100m, lowered prices for students, integrated, hit plan, and hired for the experience necessary to scale inside a public company. Chegg also nearly tripled in value. Chegg and Thinkful are shaping the future of education.

But America’s recovery from COVID will accelerate wealth and opportunity injustices: In 2021 I fear a lucky few will continue getting richer, while debt and uncertainty will suffocate most Americans’ ambition. This delays and destroys millions of families and careers. 44% of American workers earn $10 / hour. The average American is $90k in debt. We already live four fewer years than our peers.

Those of us trained to rethink large systems must see this as a “Call to Code”. Lucky risk-takers (and yes, my success is mostly luck) must figure out how to better distribute luck. Education will be one solution. Others surely include answering how gig and frontline work can engender economic mobility, and what replaces the social safety net. To play on a phrase, opportunity is already here — it’s just not very evenly distributed. Let’s fix that.

Thinkful now has the best leadership, brand, team, educators, and in Chegg, steward, that it’s ever had. So, it’s time for me to move on. My transition out offers me the privilege of asking big questions, again. I’ll be contributing some answers soon enough. But first, I’ll spend a bit of time with my husband, our family, our friends, and our native NYC.

\"\""},{"guid":"https://medium.com/p/a8d60aa3dbf1","link":"https://darrellsilver.medium.com/founding-year-eight-a8d60aa3dbf1?source=rss-17756313f41a------3","title":"Founding Year Eight","author":"Darrell Silver","excerpt":"Today we’re founding the next era in Thinkful history: an era where our mission to build the world’s next workforce truly begins. For seven years we’ve known, deep down in our soul, that all adults should learn the way we teach. We’ve proven it works with our audited results. Now we get the chance t","updated":"2020-12-11T14:37:48.154Z","published":"Wed, 04 Sep 2019 19:34:12 GMT","categories":["bootcamp","education","startup"],"content_html":"

Today we’re founding the next era in Thinkful history: an era where our mission to build the world’s next workforce truly begins. For seven years we’ve known, deep down in our soul, that all adults should learn the way we teach. We’ve proven it works with our audited results. Now we get the chance to deliver not just for the thousands who choose us today, but for the millions who’ll choose us next.

“Bootcamps” were started as an alternative to expensive and slow higher ed programs, but prices have ticked up every single year since 2012, now crossing $20k. High cost is bad for students (even when you pay later). High cost limits access, and is a slow ooze toward the status quo. This year Dan & I came to realize that to build the world’s next workforce prices need to go way, way down. And this must be done without compromise to quality, support, and extraordinary student outcomes.

That’s why we’re ecstatic to join Chegg. They’re the adults in the room bootcamps need. Chegg is a massive company in education, and today we’ve announced it will acquire Thinkful for $100m. Together we share a deep belief that the future of adult education must be accountable for student outcomes, low-risk, high impact, and incredibly affordable. Our values are deeply aligned: Student-first, intellectually honest, transparent, and approaching everything we do with an unreasonable passion. Chegg chose Thinkful as a platform to reach adult learners, perfectly complementing its existing learner base of millions of college students. And we’re hiring.

\"\"
“Learning is not a four-year thing, it’s a forever thing” in Chegg’s NYC office

We’ve been working on this for months — plenty of time to consider and plan, course correct and discuss. Above all I’ve realized that today we become life partners. We’re creating something so few get to experience, and that this experience will bind everyone at Thinkful in job, career, friendship, mission, and for the rest of our lives no matter what. I think that’s also called family. To the Thinkful community of students, alumni, educators, team: Welcome to the Chegg family. Congratulations on getting us to today and congratulations on making tomorrow possible.

This morning we’re very, very proud, and we’ll enjoy it. This afternoon we’re back to work.

Read more

\"\""},{"guid":"https://medium.com/p/1c27eca49f50","link":"https://paulo-pereira.medium.com/newsletters-to-follow-in-2021-1c27eca49f50?source=rss-17756313f41a------3","title":"Newsletters to follow in 2021","author":"Paulo Pereira","excerpt":"Newsletters can be a great source of information — if you follow the right ones. For the past few years, newsletters have been my go to for news and interesting information. I found out that newsletters will stay in your inbox, so even if you have a busy schedule one week, the next week you can go b","updated":"2021-01-24T22:18:34.773Z","published":"Sat, 23 Jan 2021 22:37:21 GMT","categories":["business","education","newsletter","technology","life"],"content_html":"
\"\"

Newsletters can be a great source of information — if you follow the right ones.

For the past few years, newsletters have been my go to for news and interesting information. I found out that newsletters will stay in your inbox, so even if you have a busy schedule one week, the next week you can go back and see the major events that happened and you won’t miss out on the news cycle.

\"\"

#1 - The Hustle

The Hustle is a fairly young daily newsletter that touches major news and smaller quirky stories. Their language is mostly directed at millennials and there’s an irreverence to it that makes it quite appealing.

Check them out: https://thehustle.co/home/

\"\"

#2 - Term Sheet

Mostly financial information digested by Lucinda Shen, Term Sheet has a grown up vibe to it. Very informative and in the right amount, this newsletter is more East coast focused and allows you to get a glimpse into the world of high finance.

Check it out: https://mynewsletters.fortune.com/subscribe (look for Term Sheet)

\"\"

#3 - Ideas at TED

From the creators of TED talk, Ideas at TED newsletter is a round up of articles written on the Ideas.TED platform. Interesting and informative, the articles cover a broad range of topics from work to race.

Check it out: https://ideas.ted.com/

\"\"

#4 - Winning the Internet

Data driven newsletter that compiles the most shared articles in newsletters during the past week. Really interesting retro visuals!

Check it out: https://pudding.cool/projects/newsletter/

\"\"

#5 - Quincy Larson

Quincy Larson is the creator of FreeCodeCamp and he puts a (mostly) weekly newsletter to share articles that he finds interesting. The focus is on coding, learning and overall tech and the curation is excellent.

Check it out:

https://www.freecodecamp.org/signin

\"\"

Check out any of these newsletters and you’ll get information of great quality!

\"\""},{"guid":"https://medium.com/p/5f5c1b577ef5","link":"https://codeburst.io/introducing-customertestsexcel-5f5c1b577ef5?source=rss-17756313f41a------3","title":"Introducing CustomerTestsExcel","author":"cedd burge","excerpt":"A BDD framework to round trip Excel Customer Tests to C# NUnit Tests specialized to numerical/analytical contexts. The problem BDD involves focusing collaborative work around concrete, real-world examples that illustrate how a system should behave. The examples are executable as tests and can be und","updated":"2022-03-14T15:56:09.760Z","published":"Mon, 09 Nov 2020 22:07:04 GMT","categories":["excel","csharp","bdd","living-documentation","specification-by-example"],"content_html":"

A BDD framework to round trip Excel Customer Tests to C# NUnit Tests specialized to numerical/analytical contexts.

The problem

BDD involves focusing collaborative work around concrete, real-world examples that illustrate how a system should behave. The examples are executable as tests and can be understood by the whole team (programmers, testers, business analysts, subject matter experts, and so on). This means that the examples are always up to date; serving as the Single Source of Truth and as living documentation. Cucumber is the most widely used tool for creating these examples/tests, using Gherkin syntax.

This all works extremely well for specifying business-centric code, such as Given I am logged in as Greg, When I try to post to 'Expensive Therapy', Then I should see 'Your article was published'. However, the code I work with is mostly calculation centric, and all the existing tools are much less useful when trying to specify complex physics, statistics, or maths. In these cases, there can be a lot of input and output data for a calculation, and it is also important to see the intermediate steps. For example, Given I use the sample ERA5 data, When I run the roughness calculation, Then the result should be 5 doesn’t communicate very much.

So for calculation heavy code, we need a different way to communicate. This communication is necessarily calculation-centric, so the whole team needs to have some mathematical skills, but in the context of technical software, this is very likely to be the case.

The framework

The CustomerTestsExcel framework aims to solve this problem by using Microsoft Excel to define the examples/calculations, which has a number of advantages:

The framework then generates C# Unit tests from Excel, which can be run just like normal and integrate well with build servers and code coverage and similar. The framework has two other features that serve to strengthen the link between Excel and C#.

Round tripping: The C# tests can optionally round trip back to Excel, recreating the Excel files as they are run. This allows you to use automated refactoring tools in C# to say rename a function, and then to recreate the Excel files with the new name.

Auto Generating Setup Files: The framework can scan assemblies / DLLs, and match interfaces with entities found in Excel.

These features mean that only limited mapping code is required and that there is a strong incentive to keep the names consistent, which aids communication between programmers and non-programmers.

This brings the well-known benefits of BDD to the previously out of reach world of calculation centric code.

Getting Started

The easiest way to get started is to clone/download the scaffolding project. It has numerous examples, and everything supported by the framework is represented at least once (the examples also function as an end to end tests of the framework). The projects in it can be used independently or can be added to your own solutions, as a starting point, and as a reference.

Writing Excel test cases

Each sheet that has “Specification” in A1 becomes a test. Other sheets can be used for supporting data/calculations. Primitives, objects, and lists/tables are supported to any level of nesting (except that tables can’t be nested within tables, and objects within tables can’t round trip).

The example Vermuelen wake length spreadsheet is a good example of a physics calculation based on tabular data, with tabular expected values. The excerpt below shows a table of data being set up, where one of the columns (TurbineGeometry) is an object (as opposed to a primitive).

\"\"

The example Anova spreadsheet is a good example of a statistics calculation, using the power of Excel to show all the intermediate steps. The excerpt below shows supporting calculations alongside each row of a table. The framework requires a blank cell after the values you are setting up, but after that you can use the power of Excel as you wish.

\"\"

Generating the C# NUnit tests

The tests themselves depend on the CustomerTestsExcel NuGet package, which also contains GenerateCodeFromExcelTest.exe to create the C# from Excel. This is installed to “<nuget folder>\\customertestsexcel\\2.0.4\\tools\\GenerateCodeFromExcelTest”, and takes the following parameters:

You can see an example of this in the scaffolding repo.

When run, the tool will generate the following:

Adding Custom C# Code

Test Classes do not require any custom modifications.

Setup Classes may not have matched everything in Excel, in which case you can add a partial class to fill in the gaps. The convention is to name the file “<Filename>Partial.cs”, like ClassWithCustomPropertyPartial.cs in the scaffolding repo. This allows you to perform complex custom setup in code without exposing the complexity in Excel. This is obviously a double-edged sword so use with due awareness.

Example Setup Classes don’t set anything up in your system under test, but they do record all the things that have been set up on them (which might be all you need in some contexts).

Root Setup Classes always require custom code in order to exercise the system under test, and to return the results (The “When” and “Then” sections of BDD tests). VermeulenNearWakeLengthCalculatorPartial.cs in the example repo is a good example of this.

You can override any of the generated code by creating an “Override<Filename>.cs” file in the “setup” folder, like OverrideAnything.cs in the scaffolding repo. This allows you to completely replace the generated code (instead of just adding to it). In this case, the framework generates an OverrideAnything.cs.txt so that you can see what it would have generated, and potentially copy and paste things from it.

The framework does not generate the .csproj file so that you can easily add your own dependencies and suchlike. You should create your own one, or use the scaffolding project example. Dotnet Core is recommended.

Round tripping Excel spreadsheets from the C# tests

Round tripping isn’t required to use the framework but is worth doing if you want to use C# refactoring tools. It is especially helpful when renaming functions in Visual Studio and pushing the changes back to Excel.

To do this, set a couple of environment variables. “CUSTOMER_TESTS_EXCEL_WRITE_TO_EXCEL” should be set to “true”. “CUSTOMER_TESTS_RELATIVE_PATH_TO_EXCELTESTS” should be set to the relative location of the Excel files from the location where the tests run (“…\\SampleTests\\ExcelTests” for a standard setup). Then whenever you run the tests (either from the command line or through the visual studio), they will recreate their associated Excel file/sheet.

Running on a build server

It’s probably a good idea to regenerate the C# from the Excel on the build server. That way you can be completely sure that they are synchronized with each other. The framework auto generates setup files by scanning the assemblies you specify. This means that the assembly has to exist and, due to a restriction in C# Reflection, you need to provide an absolute path to it.

The upshot of this is that you need to build your code (to create the assemblies to be scanned), then generate the C#, and then build/test again, in case the C# has changed. You also need to pass in the absolute path of these assemblies.

You can see this in action in the appveyor.yml of the scaffolding repo, and below.

- dotnet build CustomerTestsExcelScaffolding.sln   
 - AppveyorGenerateTests.bat
 - dotnet test

Conclusion

Existing BDD frameworks are not well suited to calculation centric code. The CustomerTestsExcel framework fills this niche in C# by using Excel as a ubiquitous technology, which is well known to most technical people. By round tripping and auto generating setup files, it strongly incentivizes the same names to be used in code and Excel; strengthening the ubiquitous language of the calculations.

\"\"

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

"}]},"meta":{"timestamp":"2026-06-13T14:37:07.428Z","request_id":"cb764226-5a96-4ef4-9416-899b0f245b1d"},"status":"ok","message":"Stories a user applauded","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"}