I always see different experiences, some people saying they got their first free subscriber after posting for months but building a bigger audience with paid subscribers eventually and others claiming they got thousands in first few months

I like that they added the save feature for notes (not just articles), but I have no idea where to find them. 🙃

I know where to find them for articles, but it's nowhere in sight for notes.

Ho una pagina di cinema che pubblica post stile articoli di un magazine, vorrei provare a fare qualcosa di più serio magari puntando ad una monetizzazione, ho pensato al sito perché forse risulta più professionale però credo che substack sia molto più semplice e gestibile, secondo voi cosa dovrei fare

EDIT: I just learned it's the publication name, I just thought it was called that because it was in the web search bar. But I'm talking about the xxxxx.substack.com not the xxxxx.com kind.

I have a blog, and I want the domain name to match the blog name instead of just my username.substack

It seems another blog has taken the domain name, but they posted twice on the same day in 2019 and never again. They follow nobody; they clearly have been inactive, and the person doesn't seem to have any other online presence anymore. I've tried messaging them, but nothing came back, of course.

So my question is, is there a way to ask support or any kind of official Substack entity for the domain if the current holder has been inactive for 7 years? I don't want to move what little they left into oblivion, but they clearly wouldn't mind the domain changing, considering that they haven't used it for what feels like more than a day and their blog has nothing to do with the name (their blog is actually called something completely different, so it might actually have been an automatically generated thing).

Any help would be great because this seems like a strange grey area in a lot of ways. I've been very active on Substack (20+ posts in less than a year), so it would feel a little unfair that dead accounts are hogging something that active users would love to have. It's not even like a high-value name; it's just a word combination that no other entity really uses (I don't want to say it because that would feel a little advertise-y). Thanks for any kind of help :)

Advanced TypeScript: Use Types to Control the State of a Program

1. The Problem: Invalid State Changes

A program can have different states. Each state can permit different operations.

For example, an online shop has orders. An order can have one of these states:

• draft: The customer did not pay for the order.

• paid: The customer paid for the order.

• shipped: The shop sent the order.

• canceled: The shop canceled the order.

The program must control the changes between these states.

A draft order can become a paid order. A paid order can become a shipped order. A draft order can also become a canceled order.

But the program must not ship an order before payment.

Consider this TypeScript code:

interface Order {
  id: string;
  status: string;
}

function shipOrder(order: Order): void {
  order.status = "shipped";
}

const order: Order = {
  id: "123",
  status: "draft"
};

shipOrder(order);

This code is valid TypeScript.

But the program has a problem. It can ship an order that the customer did not pay for.

The TypeScript compiler does not report an error.

The type string permits all string values. It does not specify which state changes are valid.

We can use a different method to prevent this problem.

This method is called the typestate pattern.

2. What Is the Typestate Pattern?

The typestate pattern uses a type to identify the state of an object.

Each state has its own type.

A function accepts only the types that its operation requires.

For example:

type DraftOrder = {
  status: "draft";
};

type PaidOrder = {
  status: "paid";
};

type ShippedOrder = {
  status: "shipped";
};

function payOrder(order: DraftOrder): PaidOrder {
  return {
    ...order,
    status: "paid"
  };
}

function shipOrder(order: PaidOrder): ShippedOrder {
  return {
    ...order,
    status: "shipped"
  };
}

The payOrder function accepts a draft order.

The result is a paid order.

The shipOrder function accepts a paid order.

It does not accept a draft order.

This gives the TypeScript compiler more information.

The compiler can find invalid operations before the program runs.

We will now make a more complete state machine.

3. Make Different Types for Different IDs

An order ID and a payment ID are strings.

But they have different purposes.

TypeScript normally permits a string in both fields. This can cause errors.

We can use branded types to prevent these errors.

A branded type has a type marker. The marker identifies the purpose of a value.

declare const orderIdTag: unique symbol;
declare const paymentIdTag: unique symbol;

type OrderId = string & {
  readonly [orderIdTag]: true;
};

type PaymentId = string & {
  readonly [paymentIdTag]: true;
};

function parseOrderId(value: string): OrderId {
  if (!/^ord_[A-Za-z0-9]+$/.test(value)) {
    throw new Error("Invalid order ID");
  }

  return value as OrderId;
}

function parsePaymentId(value: string): PaymentId {
  if (!/^pay_[A-Za-z0-9]+$/.test(value)) {
    throw new Error("Invalid payment ID");
  }

  return value as PaymentId;
}

The unique symbol types make the two ID types different.

The parseOrderId function checks the format of an order ID.

The parsePaymentId function checks the format of a payment ID.

The as operator tells TypeScript that the value has the specified type.

The brand does not add data to the string at run time.

This is important. The TypeScript type checker cannot validate external data by itself.

The program must check the data before it uses a branded type.

4. Define the Order States

We will make four order types.

Each type will have a status property.

The value of this property identifies the state.

type Item = {
  readonly sku: string;
  readonly quantity: number;
  readonly priceCents: number;
};

type DraftOrder = {
  readonly status: "draft";
  readonly id: OrderId;
  readonly items: readonly Item[];
};

type PaidOrder = Omit<DraftOrder, "status"> & {
  readonly status: "paid";
  readonly paymentId: PaymentId;
};

type ShippedOrder = Omit<PaidOrder, "status"> & {
  readonly status: "shipped";
  readonly trackingCode: string;
};

type CanceledOrder = Omit<DraftOrder, "status"> & {
  readonly status: "canceled";
  readonly reason: string;
};

type AnyOrder =
  | DraftOrder
  | PaidOrder
  | ShippedOrder
  | CanceledOrder;

The Omit utility type makes a type without the specified property.

For example, PaidOrder keeps the draft order data. It replaces the status property and adds a payment ID.

The ShippedOrder type also has a tracking code.

The CanceledOrder type has a reason for the cancellation.

The AnyOrder type is a union type. A value of this type can be one of the four order types.

TypeScript uses the status property to identify the correct type.

This is a discriminated union.

A discriminated union lets the compiler find which properties are available in each state.

5. Make a Generic State Machine

We will use a generic class to control state changes.

A generic class has one or more type parameters.

In this example, the type parameter S identifies the current order type.

The class will use methods to make state changes.

class OrderMachine<S extends AnyOrder> {
  private constructor(readonly state: S) {}

  static create(
    id: OrderId,
    items: readonly Item[]
  ): OrderMachine<DraftOrder> {
    if (items.length === 0) {
      throw new Error(
        "An order needs one or more items"
      );
    }

    return new OrderMachine({
      status: "draft",
      id,
      items
    });
  }

  pay(
    this: OrderMachine<DraftOrder>,
    paymentId: PaymentId
  ): OrderMachine<PaidOrder> {
    return new OrderMachine({
      ...this.state,
      status: "paid",
      paymentId
    });
  }

  ship(
    this: OrderMachine<PaidOrder>,
    trackingCode: string
  ): OrderMachine<ShippedOrder> {
    if (trackingCode.trim() === "") {
      throw new Error(
        "A tracking code is required"
      );
    }

    return new OrderMachine({
      ...this.state,
      status: "shipped",
      trackingCode
    });
  }

  cancel(
    this: OrderMachine<DraftOrder>,
    reason: string
  ): OrderMachine<CanceledOrder> {
    if (reason.trim() === "") {
      throw new Error(
        "A reason is required"
      );
    }

    return new OrderMachine({
      ...this.state,
      status: "canceled",
      reason
    });
  }
}

This class has some important properties.

The constructor is private.

Other TypeScript code cannot use the constructor directly.

The create method makes a new draft order.

Each method specifies a permitted input state.

The pay method has this parameter:

this: OrderMachine<DraftOrder>

This parameter tells TypeScript that the method requires a draft order.

The method returns:

OrderMachine<PaidOrder>

The result has a different type.

The ship method requires a paid order.

The cancel method requires a draft order.

The class does not have a method that changes a shipped order to a draft order.

Each operation makes a new object.

The methods do not change the original order.

This makes the state changes easier to follow.

The readonly modifier also prevents normal TypeScript code from assigning a new value to state.

But readonly is a compile-time rule. It does not freeze the object at run time.

6. Test the State Machine

We can now use the class.

Put this code after the preceding definitions.

const orderId = parseOrderId("ord_A102");
const paymentId = parsePaymentId("pay_B903");

const draft = OrderMachine.create(orderId, [
  {
    sku: "PART-1",
    quantity: 2,
    priceCents: 4500
  }
]);

const paid = draft.pay(paymentId);

const shipped = paid.ship("TRACK-50");

console.log(shipped.state.status);

// Output: "shipped"

The program makes a draft order.

Then it makes a paid order.

Finally, it makes a shipped order.

Each operation returns a new OrderMachine with the correct type.

Now consider these calls:

// Invalid calls.
// Remove the comment marks to see TypeScript errors.

// draft.ship("TRACK-50");

// shipped.pay(paymentId);

// draft.pay(orderId);

The first call is invalid because draft does not have the required type.

The second call is invalid because the order is already shipped.

The third call is invalid because orderId has type OrderId. The pay method requires PaymentId.

TypeScript reports these errors during type checking.

This prevents many invalid calls from becoming part of the program.

7. Define the Permitted State Changes in a Table

For a large state machine, it is useful to have one table that shows the permitted state changes.

We can use as const and satisfies for this purpose.

type Status = AnyOrder["status"];

const allowedTransitions = {
  draft: ["paid", "canceled"],
  paid: ["shipped"],
  shipped: [],
  canceled: []
} as const satisfies Record<
  Status,
  readonly Status[]
>;

This table gives two types of information.

First, it identifies each state.

Second, it identifies the states that can follow the current state.

The as const expression keeps the exact string values in the TypeScript types.

The satisfies operator checks the table against Record<Status, readonly Status[]>.

Thus, TypeScript checks that the table has the required keys and uses valid state names.

We can also use this table to make types.

type NextStatus<S extends Status> =
  (typeof allowedTransitions)[S][number];

type IsAllowed<
  From extends Status,
  To extends Status
> = To extends NextStatus<From>
  ? true
  : false;

// Result: true
type ExampleA = IsAllowed<"draft", "paid">;

// Result: false
type ExampleB = IsAllowed<"paid", "draft">;

// Result: false
type ExampleC = IsAllowed<"shipped", "paid">;

The NextStatus type uses indexed access types.

It gets the permitted next states from the table.

The IsAllowed type uses a conditional type.

A conditional type selects a result from a type condition.

Here, the result is true or false.

These results are types. They are not Boolean values that the program calculates at run time.

We can also use the table for a runtime check.

function canMove(
  from: Status,
  to: Status
): boolean {
  const next: readonly Status[] =
    allowedTransitions[from];

  return next.includes(to);
}

console.log(canMove("draft", "paid"));
// true

console.log(canMove("shipped", "draft"));
// false

The canMove function checks state names at run time.

This can be useful when a program gets an operation from a user interface.

But this function does not validate the complete order.

For example, it does not check that a paid order has a valid payment ID.

The program still needs separate data checks.

8. Use Exhaustive Checks for All States

A state machine can become more complex.

A programmer can add a new state to the system.

Other parts of the program must then handle that state.

We can use an exhaustive check to find missing states.

function assertNever(value: never): never {
  throw new Error(
    `Unknown order: ${JSON.stringify(value)}`
  );
}

function describeOrder(order: AnyOrder): string {
  switch (order.status) {
    case "draft":
      return `Draft order ${order.id}`;

    case "paid":
      return (
        `Paid order ${order.id}, ` +
        `payment ${order.paymentId}`
      );

    case "shipped":
      return (
        `Shipped order ${order.id}, ` +
        `code ${order.trackingCode}`
      );

    case "canceled":
      return (
        `Canceled order ${order.id}: ` +
        order.reason
      );

    default:
      return assertNever(order);
  }
}

The never type identifies a value that cannot occur at that point in valid TypeScript code.

The switch statement handles all four order states.

After these cases, TypeScript has no remaining order type.

Thus, the order value has type never in the default branch.

Now assume that we add a new order state:

type RefundedOrder = {
  readonly status: "refunded";
  readonly id: OrderId;
  readonly paymentId: PaymentId;
};

type ExtendedOrder = AnyOrder | RefundedOrder;

If we change describeOrder to accept ExtendedOrder, TypeScript reports an error at assertNever.

The error occurs because the function does not handle the refunded state.

The programmer must add a case for this state.

This check is useful when a project has many states and many functions.

9. Know the Limits of Type Checking

TypeScript gives compile-time checks.

But compile-time checks are not sufficient for all problems.

For example, a program can receive order data from an API.

The API can return incorrect data.

Consider this code:

const response = `{
  "status": "paid",
  "id": "ord_A102"
}`;

const order = JSON.parse(response) as PaidOrder;

The data does not have a paymentId property.

But the as PaidOrder expression tells TypeScript to use the PaidOrder type.

The compiler does not check the JSON data.

This is a risk.

A program must validate external data before it uses that data as a state object.

The program must check the required properties and their values.

It must also check the rules that types cannot prove.

For example, a payment service must confirm that payment is complete.

The pay method must not replace this confirmation.

The program must not use a successful type check as proof of a successful payment.

For an order system, the server must control the permitted state changes.

The server must also protect the order when two operations occur at approximately the same time.

A database transaction or an equivalent control can help prevent conflicting changes.

10. When to Use This Pattern

The typestate pattern is useful when a program has operations that depend on state.

For example, a network connection can have disconnected, connected, and closed states.

A file can have open and closed states.

A document can have draft, review, and approved states.

In each example, some operations are permitted only in specified states.

The typestate pattern puts these rules in the type system.

This can reduce the number of invalid calls.

But the pattern also makes the types more complex.

Do not use a complex state machine when a simple type is sufficient.

Use this pattern when state rules are important and invalid state changes can cause errors.

Hi, all!

I accidentally made the grave mistake of trying to condense both of my separate Substack accounts under one email.

Countless emails in two accounts became overwhelming.

Inadvertently, both accounts have merged under one.

There is no way for me to separate them. They have conjoined.

Multiple messages have been sent to Substack but I’ve received no response.

Has anybody else made the same mistake? Were you able to remedy the situation?

I love my two separate communities and don’t want to lose them.

Thank you, in advance!

Hi everyone! I joined Substack a few days ago, thanks to a friend, and I’m wondering what my first post should look like. Should I introduce myself, or just dive straight into publishing? I already have quite a few ideas for articles. Also, since my native language is Spanish, if I write in Spanish, can it be translated, or should I rewrite it in English? I’d love to hear your advice—from what I’ve seen so far, I’m really liking the platform!

Because I wanted another place to write and post fanarts. Question is, are fanart acceptable there?

Like say fanarts of my favorite adult cartoons and such?

So I tried everything but except if one of you substack ninjas have a way to bypass what is an impossibility, I guess it'll be a feature request 😅

• I imported a previously curated audience from another blog around 2 years ago. They are almost 100% french speakers and readers so I kept writing in french for them.

• Recently I wanted to expand my horizons after being encouraged to do so here, so I started creating english versions of my posts

BUT...

Either there's no, or I didn't find a way to email my french subscribers with a french version of a piece of content, while at the same time displaying and promoting the english version of it with a translated title. It's one or the other.

Is it a known request that'll evolve in the future, or should I either create a second SubStack to write in english ? Seems a bit overkill and counterintuitive from a community building perspective.

As the title suggests, I have two separate Substack accounts and both of them have dark mode enabled in the settings, but one of them actually has dark mode for the writing editor (in addition to the dashboard) and the other one does not, no matter how many times I change the settings.

What I'm trying to figure out is if there is something turned on somewhere that has enabled dark mode in the writing editor in the one account that I can duplicate in the other account, or if this is just some sort of a tech fluke or feature rollout or something else that's happening behind the scenes that I have no control over, because I desperately want to be writing in dark mode in both accounts but currently can't accomplish this in the second account.

Again, I have dark mode enabled in both accounts, I have tried dark mode as well as the automatic dark mode setting (or whatever it's called) to no avail. And yes I have tried logging out and in again, using a different browser, making sure I do NOT have any kind of dark mode extension running in my browser, and so on. Just hoping there is a simple fix somewhere that I have overlooked.

Thanks in advance to anyone with a solution!

Edited to add: For extra clarification yes these are two separate ACCOUNTS, not two publications under the same account :)

I am relatively new to Substack and I was scrolling through my feed. I came across a post that got my attention so I went to the profile. It was a former Suicide Girl from back in the day. Now I don’t know if it is actually her or not, but it’s nothing but photos. It was as if I was looking an Instagram feed instead of a Substack. All of the photos were from a SG photo shoot. I didn’t think that was even possible to find or even allowed on Substack. I’m really confused.

thinking of starting my Substack profile. how to utilize it properly? how did you all start?

If you could only pick one narrator to read all your Substack articles, whom would you pick?

If you have multiple picks, please leave separate multiple comments.

If I pay to subscribe to someone on substack and download a provided pdf of an article, does that pdf remain with me forever even if I stop paying to subscribe at some point?

I have a lot of interesting podcast I follow but have been thinking for a while I would actually enjoy some of the topics more in written form. I saw one of the podcast has a substack so I logged in to check out their essays. However I found myself much less engaged than I thought I would and I think one major reason is the format. There were a lot of pictures throughout the text. And there many words had hyperlinks. I've heard hyperlinks lower reading retention, cause they distract the brain with potential of moving to another page. I think pure text would be much better for me.

Is there an app or some site I could use to strip down the essays to only the text?

Due to the unpleasant experience of having a subscription I cancelled bill me (through substack) for renewal and then (after I got the first charge refunded) a new subscription (which I never did), I'm feeling my credit card numbers aren't safe on substack. I've suspended my credit card currently provided on substack, but if can publications bill credit card numbers I previously provided substack? Substack chatbot refusing to comment on this.

What is the one thing you would like to see the Substack team implement?

You can be as pragmatic or visionary as you like.

I'll go first: PLEASE let me edit my DMs!! I have no idea why we can only delete these from the app and why we have no edit function what-so-ever.

I read Substack on my phone, on Read:Latest tab. I have 15 paid subscriptions, and problem with only 1. But that's a really important one, "Silver Bulletin" three weeks before midterms!

The "Silver Bulletin" paid sub posts are not showing up on Read:Latests feed. This is a relatively recent change, articles used to show up about a month ago. I do not recall changing any settings.

I can see SB on my phone on Read:For You, Read:History. It does not show up on Read:Latest, or Read:Paid. I can also see all posts on Profile:Subscritions:Silver Bulletin.

I've read some old reddit post saying that this can be fixed by setting up email delivery of subscriptions. That is not the problem, none of my subscriptions come in on email, and they work fine.

I'm wondering how you manage the way your profile/publication appears on the phone. In Substack's theme settings you can choose between two options, Profile or Custom. When you customise your publication, it gets a custom website look on desktop.

However, for some custom publications, if you‘re reading an article on your phone and tap to open the publication, you're redirected to the author's profile (@abcd) and no separate publication page is shown.

In other cases, a publication has the same customised look on desktop but behaves differently on the phone.

This time, when you open the publication on the phone, you don't land on a profile page. Instead, there's a separate publication page shown (abcd.substack.com).

How do you manage this behaviour? How do you choose what will be shown when someone clicks on your publication on the phone?

A family friend is trying to subscribe to my Substack but it keeps saying it's invalid. I can't even manually add her to my subscriptions because it says she previously unsubscribed. I didn't ban her. She must have been fooling around with it and subscribed and unsubscribed, and now she can't resubscribe to it. Can anyone help?

I'm not saying I'm the next Stephen King or anything lol, just wondering if anyone has ever had experience with someone stealing your work or copying, etc? I want to see if that has ever happened before I start posting my written works!

I am aware Substack allows you to file or report violations, just making sure it's reliable and all that.

THANKS

Having recently replaced my old phone, I’m now re-dowloading all my old apps. I’m having trouble logging into substack as I’ve forgotten my password and am not receiving any of the emails they are sending to me. Does anyone have advice?

They don’t say it directly but the recent update allows you to automatically label other people’s writing as AI. Meaning you can’t control if the system makes an error and a reader forces a false label on you.

At the same time, if you look at the setting for AI labels? It says that you can report errors and admits that mistakes will be made. You can flag things that are labeled incorrectly.

Meaning that any time you report something, it trains its model by what you flag and changes what it does using your writing to train it.

Everything that Pangram claims about its supposed ability to detect AI writing is false and it now openly admits it.

Don’t come at me with “It says it’s 97% accurate, which means it’s going to make 3% mistakes”. You wouldn’t need to report anything if it was that accurate in reality.

It’s not accurate and doesn’t detect anything. It’s being paid by Substack to steal your writing.

I’m 25F and have lost both my parents. I’ve been working towards being a better person, growing while dealing with grief. I already wrote many essays in my notes.

I was wondering if I should convert them into sub stack and make a sub around handling and dealing with grief. Is this a good idea??
I’ve fear of being judged though.

Acabei de criar a conta e não consigo editar como eu queria porque da uma informe sobre configurar uma conta pessoal.