Skip to content

Instantly share code, notes, and snippets.

Avatar

Jorge Villalobos JorgeVV

View GitHub Profile
@hirbod
hirbod / app-release.md
Last active Jan 3, 2023
How to get your App through the App/Play store safely
View app-release.md

How to Successfully Publish Your App on the App Store or Google Play

As someone who has released many apps starting in 2015 using frameworks such as Cordova and Ionic, and more recently using React Native and Expo, I have learned that the rules for publishing apps can change frequently and can sometimes be challenging to navigate. With that in mind, I want to provide a brief guide to help others navigate the process. While this guide may not cover every aspect of publishing an app, it does cover general tips and information that should be useful for anyone looking to release their app on the App Store or Google Play.

Metadata

Keywords, Description, Screenshots, App Name, Promo Videos

There are significant differences between Apple and Google when it comes to metadata. Apple is generally stricter than Google, so it is advisable to follow Apple's guidelines to ensure the best chances of success on both platforms. Here are some tips to keep in mind:

  1. Keep your screenshots and promo videos separat
@dgcoffman
dgcoffman / require-named-effect.js
Created May 23, 2022
libs/eslint-rules/require-named-effect.js
View require-named-effect.js
const isUseEffect = (node) => node.callee.name === 'useEffect';
const argumentIsArrowFunction = (node) => node.arguments[0].type === 'ArrowFunctionExpression';
const effectBodyIsSingleFunction = (node) => {
const { body } = node.arguments[0];
// It's a single unwrapped function call:
// `useEffect(() => theNameOfAFunction(), []);`
if (body.type === 'CallExpression') {
View flat-file-system-routing.md

Idea: Flat file system for file-based routing

Personally I've never liked how tools like Remix or NextJS have mapped a nested file system to routes. Simple things like "I want to put this component in its own file" become annoying tasks.

I've always been a fan of "flatter" file systems, my files often look like this:

/App/
@EvanBacon
EvanBacon / RootViewBackgroundColor.tsx
Created Dec 10, 2021
A stack based Expo component for setting the background color of the root view. Useful for changing the background color on certain screens or inside of native modals. Updates based on Appearance and AppState.
View RootViewBackgroundColor.tsx
import * as SystemUI from 'expo-system-ui';
import * as React from 'react';
import { Appearance, AppState, AppStateStatus, ColorSchemeName, ColorValue } from 'react-native';
type ThemedColorValue = { light: ColorValue, dark: ColorValue };
type Props = { backgroundColor: ColorValue | ThemedColorValue }
const propsStack: Props[] = [];
@tannerlinsley
tannerlinsley / createCrudHooks.js
Created Nov 29, 2020
A naive, but efficient starter to generate crud hooks for React Query
View createCrudHooks.js
export default function createCrudHooks({
baseKey,
indexFn,
singleFn,
createFn,
updateFn,
deleteFn,
}) {
const useIndex = (config) => useQuery([baseKey], indexFn, config)
const useSingle = (id, config) =>
@UberMouse
UberMouse / createDataStream.ts
Created Oct 29, 2020
GraphQL + Apollo + XState dump
View createDataStream.ts
type QueryResult<TTransformedData> =
| { type: "success"; data: TTransformedData }
| { type: "error"; errors: readonly GraphQLError[] };
type ParentEvents<TData, TId extends string = "dataLoader"> =
| { type: "dataStream.NEW_DATA"; data: TData; id: TId }
| { type: "dataStream.ERROR"; id: TId };
export function createDataStream<
TObservableFactory extends (...args: $YesReallyAny[]) => Observable<QueryResult<$YesReallyAny>>,
View dataLoader.ts
import { Observable } from "rxjs";
import { map } from "rxjs/operators";
import { Required } from "utility-types";
import { createMachine, sendParent, assign, spawn, Actor } from "xstate";
import { $YesReallyAny, assert } from "../";
import { QueryResult } from "../gql/queryResultHandler";
let id = 0;
enum Actions {
@tstellanova
tstellanova / state_of_rust_fc_2020.md
Last active Aug 5, 2020
Current State of Embedded Rust for Flight Controllers
View state_of_rust_fc_2020.md

Introduction

A wide variety of widely-available flight controllers and associated robotics boards have been released in the past five years. These boards incorporate a careful selection of sensors and actuator outputs useful for robotics-- not just for flying vehicles, but also rovers and underwater vehicles. This living document analyzes briefly the compatibility of embedded Rust with these inexpensive and powerful boards.

Overall Utility Issues

General issues that impact the usefulness of embedded Rust with these kinds of boards:

  • No (or fragmented) DMA support. Some embedded HAL crates have DMA support already, but many do not. Almost none of the DMA APIs resemble each other. There is at least one effort underway to unify the DMA APIs
@slikts
slikts / advanced-memo.md
Last active Jan 13, 2023
Advanced memoization and effects in React
View advanced-memo.md

nelabs.dev

Advanced memoization and effects in React

Memoization is a somewhat fraught topic in the React world, meaning that it's easy to go wrong with it, for example, by [making memo() do nothing][memo-pitfall] by passing in children to a component. The general advice is to avoid memoization until the profiler tells you to optimize, but not all use cases are general, and even in the general use case you can find tricky nuances.

Discussing this topic requires some groundwork about the technical terms, and I'm placing these in once place so that it's easy to skim and skip over:

  • Memoization means caching the output based on the input; in the case of functions, it means caching the return value based on the arguments.
  • Values and references are unfortunately overloaded terms that can refer to the low-level implementation details of assignments in a language like C++, for example, or to memory
@derekstavis
derekstavis / FastList.tsx
Last active Jan 12, 2023 — forked from vishnevskiy/FastList.js
Discord's FastList, but in TypeScript
View FastList.tsx
import { forEachObjIndexed } from "ramda";
import * as React from "react";
import {
Animated,
ScrollView,
View,
ViewStyle,
LayoutChangeEvent,
NativeScrollEvent,
} from "react-native";