thomasrognon

  "noUncheckedIndexedAccess": true

  type OddNumber = number & { __BRAND_ODD_NUMBER: true }

  OddNumber[]

  const isOddNumber = (x: unknown): x is OddNumber => typeof x === 'number' && x % 2 === 1

We do video transfers and workflows. Our team is small and selective. We're looking for a meticulous and methodical engineer to develop a custom video codec. FFMPEG and GPU expertise is a huge plus. Comp is top of market.

Please email me directly (it's in my profile).

It's like AirTable/Lists/etc but for big organizations.

So the focus is on a more useful permission system, handling lots of data, dead simple data entry for tech-phobic employees, and getting the information you need quickly (as opposed to spending time fiddling around with how data is displayed, this isn't an "app builder").

The intent is to replace the hundreds of untracked, out of sync, insecure Excel files being used as a database in most large orgs.

Cool tech note - people learn to use a graph database with Cloudternal, even if they never know what a graph is.

I'm not sure why you think this. "Banking the unbanked" was a huge Bitcoin mantra back in the day. If anything, it's disappeared more recently as speculation has taken over and the narrative has moved from "p2p cash" to "store of value".

This is exactly a major problem I'm solving with https://www.cloudternal.com. I would absolutely love to show it to you and get your feedback on it if you have time (my email is in my profile).

Everyone has different fitting issues. My main one is waist length/width and shoulder width. I'm 6'2" and fit so the waist of most shirts barely go below the top of my jeans and getting the shoulders to fit often means having a parachute around my waist. It looks dumb and clothing fit is extremely important to overall appearance. There's a lot of disruption to be had in this space.

Edit: to be slightly more clear, I'm thinking of technology to replacing the incumbent infrastructure/processes/consumer experience, as opposed to just creating a new specialty brand.

Edit for the curious, here's the monster type that caused such pathological build times...

  type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
  export type Immutable<T> =
    T extends ImmutablePrimitive ? T :
    T extends [infer U]                                     ? readonly [Immutable<U>] :
    T extends [infer U, infer V]                            ? readonly [Immutable<U>, Immutable<V>] :
    T extends [infer U, infer V, infer X]                   ? readonly [Immutable<U>, Immutable<V>, Immutable<X>] :
    T extends [infer U, infer V, infer X, infer Y]          ? readonly [Immutable<U>, Immutable<V>, Immutable<X>, Immutable<Y>] :
    T extends [infer U, infer V, infer X, infer Y, infer Z] ? readonly [Immutable<U>, Immutable<V>, Immutable<X>, Immutable<Y>, Immutable<Z>] :
    T extends readonly [infer U]                                     ? readonly [Immutable<U>] :
    T extends readonly [infer U, infer V]                            ? readonly [Immutable<U>, Immutable<V>] :
    T extends readonly [infer U, infer V, infer X]                   ? readonly [Immutable<U>, Immutable<V>, Immutable<X>] :
    T extends readonly [infer U, infer V, infer X, infer Y]          ? readonly [Immutable<U>, Immutable<V>, Immutable<X>, Immutable<Y>] :
    T extends readonly [infer U, infer V, infer X, infer Y, infer Z] ? readonly [Immutable<U>, Immutable<V>, Immutable<X>, Immutable<Y>, Immutable<Z>] :
    T extends Array<infer U> ? ImmutableArray<U> :
    T extends ReadonlyArray<infer U> ? ImmutableArray<U> :
    T extends Map<infer K, infer V> ? ImmutableMap<K, V> :
    T extends ReadonlyMap<infer K, infer V> ? ImmutableMap<K, V> :
    T extends Set<infer M> ? ImmutableSet<M> :
    T extends ReadonlySet<infer M> ? ImmutableSet<M> :
    ImmutableObject<T>;
  type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
  type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
  type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
  type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };