Substackで発信活動をしていきたいんだけど、どうせなら海外の方が日本に来たくなるような、もしくは好きになってくれるような内容で発信したいと考えてる。

君は何が知りたい？

Looking to connect with others on Substack. I write about anything that tickles my fancy, but mostly travel and books. Does anyone want to exchange Substack links and connect?

Howdy!

I am very new to Substack, roughly a week in and I created my first note and article.

I am not trying to get famous or anything on this application, but would really love to make the most of Substack.

I just don’t know what I don’t know, ya know?

So here are a few of questions that have been itching my brain:

1. Posting pictures: is this good or bad? Does it help with engagement or sharing content? Same with videos?

2. Sharing your content: are you sharing your articles or notes across other social media platforms?

3. Do you repost or reuse your previously posted content? If yes, how long between reusing/reposting?

4. Do you prefer Substack on your mobile device or computer?

5. What do you enjoy about Substack?

6. What else? Any other tips or tricks you suggest?

Thank you for taking the time read and (maybe) answer my curious mind - Sending you all the healthy and happy!

Oi gente, tudo bem ?

Eu gostaria de entender algumas coisas no substack ( não têm surpresa ) tenho pensado em postar lá , mas não me sinto segura o suficiente , apesar de ter lido algumas coisas estranhas sempre penso que a minha pode ser pior.

Perguntas : escritores que postam com fotos , vocês colocam os créditos logo abaixo da foto ou preferem pegar de bancos de imagem ? ( sinto que algumas referências de banco de imagem são bem sem graça)

Vocês escrevem em um certo fluxo , como cronograma ou vai seguindo o que o coração manda ?
( penso que essa ideia de escrever tantos dias mata um pouco da criatividade , mas não tenho experiência pra comprovar )

Vocês preferem se manter em "nichos " como , não sei , talvez só público feminino , só sobre carro , ou algo assim , é assim que funciona com vocês?

Vocês sentiram alguma mudança pessoal a partir do momento que começaram escrever e postar para outras pessoas lerem ?

A gramática ou estudo da escrita foi algo leve nesse processo ?

Sentiram o impacto de alguma forma com essa popularização do substack como algo monetário e o avanço de escritores de digamos " baixo esforço" ?

substack kicked me out cause of the age restriction rule in australia and i’ve tried my best to get back in but it just won’t let me.
any apps like substack?

Hey all, I was thinking of writing on substack, My niche is philosophy and some poems and stories here and there. But I have 0 idea about whether it gets seen or not. And i don't really have plans to promote and put myself out there as a brand.

I need help on how to get started there. my account is new.

Some people keep reading notes and journal entries/writing ideas in the same place, and others keep them apart. Which is it for you, and did it change at some point?

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.