Avant Arte

avantarte

Implementing a robust authentication system is crucial for mobile applications. In this guide, I'll walk you through setting up Auth0 authentication with Expo Router, creating a seamless and secure user experience. Prerequisites Before starting, ensure you have: An Expo project using Expo Router
An Auth0 account with a configured application
Basic understanding of React Native and TypeScript An Expo project using Expo Router An Auth0 account with a configured application Basic understanding of React Native and TypeScript Step 1: Install Required Dependencies First, install the Auth0 React Native SDK: yarn add react-native-auth0 yarn add react-native-auth0 Step 2: Configure Auth0 Create an auth0.config.js file in your project root: auth0.config.js const config = {
  clientId: "YOUR_AUTH0_CLIENT_ID",
  domain: "YOUR_AUTH0_DOMAIN",
}

export default config const config = {
  clientId: "YOUR_AUTH0_CLIENT_ID",
  domain: "YOUR_AUTH0_DOMAIN",
}

export default config Replace the placeholders with your actual Auth0 credentials. Step 3: Create an Authentication Context The authentication context will manage the auth state throughout your app. Create a file called useAuth.tsx in your hooks directory: useAuth.tsx import { createContext, useContext, useEffect, useState } from "react"
import { useAuth0 } from "react-native-auth0"
import { router, useSegments, useRootNavigationState } from "expo-router"

// Define the shape of our auth context
type AuthContextType = {
  signIn: () => Promise<void>
  signOut: () => Promise<void>
  isAuthenticated: boolean
  isLoading: boolean
  user: any
  error: Error | null
}

// Create the context with a default value
const AuthContext = createContext<AuthContextType | null>(null)

// Provider component that wraps the app
export function AuthProvider({ children }: { children: React.ReactNode }) {
  const { authorize, clearSession, user, error, getCredentials, isLoading } =
    useAuth0()
  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false)
  
  const segments = useSegments()
  const navigationState = useRootNavigationState()

  // Check if the user is authenticated and redirect accordingly
  useEffect(() => {
    if (!navigationState?.key) return
    
    const inAuthGroup = segments[0] === "(auth)"
    
    if (isAuthenticated && inAuthGroup) {
      // Redirect authenticated users from auth screens to the main app
      router.replace("/(tabs)")
    } else if (!isAuthenticated && !inAuthGroup) {
      // Redirect unauthenticated users to the login screen
      router.replace("/(auth)/login")
    }
  }, [isAuthenticated, segments, navigationState?.key])

  // Update authentication state when user changes
  useEffect(() => {
    setIsAuthenticated(!!user)
  }, [user])

  // Sign in function
  const signIn = async () => {
    try {
      await authorize()
      const credentials = await getCredentials()
      console.log("Auth credentials:", credentials)
      setIsAuthenticated(true)
    } catch (e) {
      console.error("Login error:", e)
    }
  }

  // Sign out function
  const signOut = async () => {
    try {
      await clearSession()
      setIsAuthenticated(false)
    } catch (e) {
      console.error("Logout error:", e)
    }
  }

  return (
    <AuthContext.Provider
      value={{
        signIn,
        signOut,
        isAuthenticated,
        isLoading,
        user,
        error,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

// Custom hook to use the auth context
export function useAuth() {
  const context = useContext(AuthContext)
  if (!context) {
    throw new Error("useAuth must be used within an AuthProvider")
  }
  return context
} import { createContext, useContext, useEffect, useState } from "react"
import { useAuth0 } from "react-native-auth0"
import { router, useSegments, useRootNavigationState } from "expo-router"

// Define the shape of our auth context
type AuthContextType = {
  signIn: () => Promise<void>
  signOut: () => Promise<void>
  isAuthenticated: boolean
  isLoading: boolean
  user: any
  error: Error | null
}

// Create the context with a default value
const AuthContext = createContext<AuthContextType | null>(null)

// Provider component that wraps the app
export function AuthProvider({ children }: { children: React.ReactNode }) {
  const { authorize, clearSession, user, error, getCredentials, isLoading } =
    useAuth0()
  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false)
  
  const segments = useSegments()
  const navigationState = useRootNavigationState()

  // Check if the user is authenticated and redirect accordingly
  useEffect(() => {
    if (!navigationState?.key) return
    
    const inAuthGroup = segments[0] === "(auth)"
    
    if (isAuthenticated && inAuthGroup) {
      // Redirect authenticated users from auth screens to the main app
      router.replace("/(tabs)")
    } else if (!isAuthenticated && !inAuthGroup) {
      // Redirect unauthenticated users to the login screen
      router.replace("/(auth)/login")
    }
  }, [isAuthenticated, segments, navigationState?.key])

  // Update authentication state when user changes
  useEffect(() => {
    setIsAuthenticated(!!user)
  }, [user])

  // Sign in function
  const signIn = async () => {
    try {
      await authorize()
      const credentials = await getCredentials()
      console.log("Auth credentials:", credentials)
      setIsAuthenticated(true)
    } catch (e) {
      console.error("Login error:", e)
    }
  }

  // Sign out function
  const signOut = async () => {
    try {
      await clearSession()
      setIsAuthenticated(false)
    } catch (e) {
      console.error("Logout error:", e)
    }
  }

  return (
    <AuthContext.Provider
      value={{
        signIn,
        signOut,
        isAuthenticated,
        isLoading,
        user,
        error,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

// Custom hook to use the auth context
export function useAuth() {
  const context = useContext(AuthContext)
  if (!context) {
    throw new Error("useAuth must be used within an AuthProvider")
  }
  return context
} This context provides: Authentication state management
Sign-in and sign-out functions
Automatic redirection based on authentication status
Access to user information and error states Authentication state management Sign-in and sign-out functions Automatic redirection based on authentication status Access to user information and error states Step 4: Set Up the Root Layout Update your app/_layout.tsx file to include the Auth0Provider and AuthProvider: app/_layout.tsx import { Auth0Provider } from "react-native-auth0"
import config from "@/auth0.config"
import { AuthProvider } from "@/hooks/useAuth"
// Other imports...

export default function RootLayout() {
  // Other code...

  return (
    <Auth0Provider domain={config.domain} clientId={config.clientId}>
      <AuthProvider>
        <ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
          <Stack>
            <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
            <Stack.Screen name="(auth)" options={{ headerShown: false }} />
            <Stack.Screen name="+not-found" />
          </Stack>
          <StatusBar style={colorScheme === "dark" ? "light" : "dark"} />
        </ThemeProvider>
      </AuthProvider>
    </Auth0Provider>
  )
} import { Auth0Provider } from "react-native-auth0"
import config from "@/auth0.config"
import { AuthProvider } from "@/hooks/useAuth"
// Other imports...

export default function RootLayout() {
  // Other code...

  return (
    <Auth0Provider domain={config.domain} clientId={config.clientId}>
      <AuthProvider>
        <ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
          <Stack>
            <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
            <Stack.Screen name="(auth)" options={{ headerShown: false }} />
            <Stack.Screen name="+not-found" />
          </Stack>
          <StatusBar style={colorScheme === "dark" ? "light" : "dark"} />
        </ThemeProvider>
      </AuthProvider>
    </Auth0Provider>
  )
} Step 5: Create the Authentication Group Expo Router uses directory-based routing. Create an (auth) directory in your app folder with a layout file: (auth) // app/(auth)/_layout.tsx
import { Stack } from "expo-router"

export default function AuthLayout() {
  return (
    <Stack screenOptions={{ headerShown: false }}>
      <Stack.Screen name="login" />
    </Stack>
  )
} // app/(auth)/_layout.tsx
import { Stack } from "expo-router"

export default function AuthLayout() {
  return (
    <Stack screenOptions={{ headerShown: false }}>
      <Stack.Screen name="login" />
    </Stack>
  )
} Step 6: Create the Login Screen Create a login screen in app/(auth)/login.tsx: app/(auth)/login.tsx import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  ActivityIndicator,
} from "react-native"

export default function LoginScreen() {
  const { signIn, isLoading, error } = useAuth()

  return (
    <View style={styles.container}>
      <View style={styles.content}>
        <ThemedText style={styles.title}>Welcome to Your App</ThemedText>
        <ThemedText style={styles.subtitle}>Sign in to continue</ThemedText>

        <TouchableOpacity
          style={styles.button}
          onPress={signIn}
          disabled={isLoading}
        >
          {isLoading ? (
            <ActivityIndicator color="#fff" />
          ) : (
            <ThemedText style={styles.buttonText}>Sign In</ThemedText>
          )}
        </TouchableOpacity>

        {error && (
          <ThemedText style={styles.errorText}>{error.message}</ThemedText>
        )}
      </View>
    </View>
  )
}

// Styles... import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  ActivityIndicator,
} from "react-native"

export default function LoginScreen() {
  const { signIn, isLoading, error } = useAuth()

  return (
    <View style={styles.container}>
      <View style={styles.content}>
        <ThemedText style={styles.title}>Welcome to Your App</ThemedText>
        <ThemedText style={styles.subtitle}>Sign in to continue</ThemedText>

        <TouchableOpacity
          style={styles.button}
          onPress={signIn}
          disabled={isLoading}
        >
          {isLoading ? (
            <ActivityIndicator color="#fff" />
          ) : (
            <ThemedText style={styles.buttonText}>Sign In</ThemedText>
          )}
        </TouchableOpacity>

        {error && (
          <ThemedText style={styles.errorText}>{error.message}</ThemedText>
        )}
      </View>
    </View>
  )
}

// Styles... Step 7: Create a Profile Screen Add a profile screen to display user information and provide a logout option: // app/(tabs)/profile.tsx
import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  Image,
  ScrollView,
} from "react-native"

export default function ProfileScreen() {
  const { user, signOut, isLoading } = useAuth()

  return (
    <ScrollView style={styles.container}>
      <View style={styles.header}>
        {user?.picture ? (
          <Image source={{ uri: user.picture }} style={styles.avatar} />
        ) : (
          <View style={styles.avatarPlaceholder}>
            <ThemedText style={styles.avatarText}>
              {user?.name?.charAt(0) || user?.email?.charAt(0) || "?"}
            </ThemedText>
          </View>
        )}

        <ThemedText style={styles.name}>{user?.name || "User"}</ThemedText>
        <ThemedText style={styles.email}>{user?.email || ""}</ThemedText>
      </View>

      {/* User information display */}
      
      <View style={styles.actions}>
        <TouchableOpacity
          style={styles.logoutButton}
          onPress={signOut}
          disabled={isLoading}
        >
          <ThemedText style={styles.logoutText}>Sign Out</ThemedText>
        </TouchableOpacity>
      </View>
    </ScrollView>
  )
}

// Styles... // app/(tabs)/profile.tsx
import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  Image,
  ScrollView,
} from "react-native"

export default function ProfileScreen() {
  const { user, signOut, isLoading } = useAuth()

  return (
    <ScrollView style={styles.container}>
      <View style={styles.header}>
        {user?.picture ? (
          <Image source={{ uri: user.picture }} style={styles.avatar} />
        ) : (
          <View style={styles.avatarPlaceholder}>
            <ThemedText style={styles.avatarText}>
              {user?.name?.charAt(0) || user?.email?.charAt(0) || "?"}
            </ThemedText>
          </View>
        )}

        <ThemedText style={styles.name}>{user?.name || "User"}</ThemedText>
        <ThemedText style={styles.email}>{user?.email || ""}</ThemedText>
      </View>

      {/* User information display */}
      
      <View style={styles.actions}>
        <TouchableOpacity
          style={styles.logoutButton}
          onPress={signOut}
          disabled={isLoading}
        >
          <ThemedText style={styles.logoutText}>Sign Out</ThemedText>
        </TouchableOpacity>
      </View>
    </ScrollView>
  )
}

// Styles... Step 8: Update the Tabs Layout Ensure your tabs layout includes the profile tab and checks authentication: // app/(tabs)/_layout.tsx
import { useAuth } from "@/hooks/useAuth"
// Other imports...

export default function TabLayout() {
  const { isAuthenticated } = useAuth()

  // Redirect to login if not authenticated
  React.useEffect(() => {
    if (!isAuthenticated) {
      // The AuthProvider will handle the redirect
    }
  }, [isAuthenticated])

  return (
    <Tabs
      screenOptions={{
        // Tab options...
      }}
    >
      {/* Other tabs */}
      <Tabs.Screen
        name="profile"
        options={{
          title: "Profile",
          tabBarIcon: ({ color }) => (
            <IconSymbol size={28} name="person.fill" color={color} />
          ),
        }}
      />
    </Tabs>
  )
} // app/(tabs)/_layout.tsx
import { useAuth } from "@/hooks/useAuth"
// Other imports...

export default function TabLayout() {
  const { isAuthenticated } = useAuth()

  // Redirect to login if not authenticated
  React.useEffect(() => {
    if (!isAuthenticated) {
      // The AuthProvider will handle the redirect
    }
  }, [isAuthenticated])

  return (
    <Tabs
      screenOptions={{
        // Tab options...
      }}
    >
      {/* Other tabs */}
      <Tabs.Screen
        name="profile"
        options={{
          title: "Profile",
          tabBarIcon: ({ color }) => (
            <IconSymbol size={28} name="person.fill" color={color} />
          ),
        }}
      />
    </Tabs>
  )
} Step 9: Create a Root Redirect Finally, create a root index file to handle initial routing: // app/index.tsx
import { Redirect } from "expo-router"
import { useAuth } from "@/hooks/useAuth"

export default function Index() {
  const { isAuthenticated, isLoading } = useAuth()
  
  // While checking authentication status, don't redirect yet
  if (isLoading) {
    return null
  }
  
  // Redirect based on authentication status
  return isAuthenticated ? (
    <Redirect href="/(tabs)" />
  ) : (
    <Redirect href="/(auth)/login" />
  )
} // app/index.tsx
import { Redirect } from "expo-router"
import { useAuth } from "@/hooks/useAuth"

export default function Index() {
  const { isAuthenticated, isLoading } = useAuth()
  
  // While checking authentication status, don't redirect yet
  if (isLoading) {
    return null
  }
  
  // Redirect based on authentication status
  return isAuthenticated ? (
    <Redirect href="/(tabs)" />
  ) : (
    <Redirect href="/(auth)/login" />
  )
} How It Works Initial Load: When the app starts, it checks the authentication status.
Authentication Flow:

Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality


Protected Routes: The AuthProvider automatically protects routes by redirecting unauthenticated users to the login screen. Initial Load: When the app starts, it checks the authentication status. Initial Load Authentication Flow:

Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality Authentication Flow Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality Unauthenticated users are directed to the login screen After successful login, users are redirected to the main app The profile screen displays user information and provides logout functionality Protected Routes: The AuthProvider automatically protects routes by redirecting unauthenticated users to the login screen. Protected Routes Benefits of This Approach Clean Separation: Authentication logic is isolated in a dedicated context
Route Protection: Automatic redirection based on authentication status
Reusable Authentication: The useAuth hook can be used throughout the app
Seamless UX: Users are directed to the appropriate screens based on their authentication status Clean Separation: Authentication logic is isolated in a dedicated context Clean Separation Route Protection: Automatic redirection based on authentication status Route Protection Reusable Authentication: The useAuth hook can be used throughout the app Reusable Authentication Seamless UX: Users are directed to the appropriate screens based on their authentication status Seamless UX Conclusion Setting up Auth0 with Expo Router provides a robust authentication system for your mobile application. This approach leverages Expo Router's group-based routing to create a clean separation between authenticated and unauthenticated content, while the authentication context manages the state and provides a consistent interface for authentication operations. By following this guide, you've implemented a complete authentication flow that handles login, logout, and protected routes in a maintainable and scalable way.

Setting Up Auth0 Authentication with Expo Router: A Complete Guide

Leveraging the Neo4j Community Graph For Social Discovery Recently the Neo4j Developer Relations team decided to devote a few hours to work together, style, to launch a . One feature we decided was needed for launch was a trending activity feed that showed blog posts and projects that are currently trending in the community. hackathon new Neo4j community forum Fortunately, my colleague has built out the , a series of serverless functions that import data from APIs like , Twitter, Meetup, and Stackoverflow into a Neo4j instance. We use Neo4j Community Graph to keep track of what’s going on in the Neo4j community. In fact if you’ve seen Mark’s newsletter (AKA TWIN4j), a few queries to community graph surfaces each week’s content. Mark Needham Neo4j Community Graph Github This Week In Neo4j In this post I want to explain how we built out the trending activity feed feature on the Neo4j Community Forum using a GraphQL First development approach. Community Graph Data model for the Community Graph. Combining data sets and querying across them is a natural fit for a graph database like Neo4j. One of the benefits of a graph database like Neo4j is the ease with which it allows for combining datasets and querying across them. We’ve been using Neo4j to help keep track of what the Neo4j community has been working on. Neo4j Community Graph is powered by a set of serverless functions that run on AWS Lambda, periodically checking the APIs of GitHub, Twitter, StackOverflow, and Meetup for new Neo4j related updates. Any matches are imported into Neo4j. Mark has even created a so that anyone can spin up a community graph for their community! community graph CLI The Awesome Discourse API The first step was adding content from our new Discourse forum into community graph. Discourse exposes an API to enable developers to build tooling on top of Discourse. In this case Mark registered a webhook on the Discourse API so that events are sent to the serverless community graph ingest Lambda functions. So the new Discourse site becomes a new developer community data set in community graph. This allows us to capture new Discourse users and new posts, including likes and replies. We link Discourse users in the graph with their other accounts (Github, Twitter, Stackoverflow, etc) when a user fills in their Discourse profile with their user names across services. Community Trending Activity Feeds Trending activity feeds provide an overview of what is going on in the community at a glance and quickly show the posts, topics, and projects that are trending. Rather than just showing the most recent posts, we want to rank items to surface content of interest to viewers that show what is currently trending in the community. Exponential Time Decay Functions Discussion forums such as Hacker News and Reddit make use of to rank what posts float to the top and what are banished to the second page and beyond. The basis for these ranking algorithms are a function that calculates a score for each post which consists of a rating divided by the time since the post was created raised to some exponent. The rating can consist of things like upvotes, views, subjective scoring by a reviewer, or as in our case, all three. You can find , but for our purposes we’ll use a much simpler version. exponential time decay functions implementations of the functions used by Hacker News and Reddit A simple exponential time decay function for scoring posts in a discussion forum. Functions like this allow new content to appear high on the leaderboard, but quickly drop off if the community does not find it engaging. Here’s how we can query the community graph using Cypher to find our top community blog posts using an exponential decay function: const cypherQuery = ` (u: )-[: ]->(t: ) t.approved “Exclude” labels(t) *,1.0 * (duration.inSeconds(datetime(), t.createdAt)).seconds/10000 ago u, t, ( (10.0 * t.rating) + t.likeCount + t.replyCount)/(ago^2) score u, (t)[0] AS topic u, topic $first`; MATCH DiscourseUser POSTED_CONTENT DiscourseTopic WHERE AND NOT IN WITH AS WITH AS WITH COLLECT RETURN LIMIT An exponential time decay function with these parameters will surface almost every new post to the top, to give it a chance for the community to vote on it. Posts that the community votes up, or that involve active discussion stay at the top, while posts that are less captivating to the community drop off the list. GraphQL API We expose a GraphQL API on top of the Neo4j community graph instance hosted on that we can query from Discourse to populate the activity feed on the landing page. Neo4j Cloud The GraphQL Schema Defining the GraphQL schema was actually one of the first steps we took. Once we defined the schema we were able to just from the GraphQL API so and could work on the UI. Here’s the GraphQL schema for our top blog post query: return mocked data Jennifer David type {title: Stringurl: Stringauthor: DiscourseUser} CommunityBlog type {name: StringscreenName: Stringavatar: String} DiscourseUser type {topCommunityBlogsAndContent(first: Int = 10): [CommunityBlog]} Query Resolvers In a GraphQL server, resolvers are the functions that contain the logic for fetching data from our data layer. In our case each query entry point to the GraphQL API is a single Cypher query, so we can use the to execute our Cypher query and return the results, ordered by our time decay ranking score. Neo4j JavaScript driver export const resolvers = {Query: { (_, params, context) => { topCommunityBlogsAndContent: let session = context.driver.session();  
  const baseUrl = ‘[https://community.neo4j.com/’](https://community.neo4j.com/%27);

  // cypherQuery is defined above  
  return session.run(cypherQuery, params)  
  .then( result => {  
    const resData = result.records.map(record => {  
      const user = record.get(“u”).properties,  
           topic = record.get(“topic”).properties;

      return {  
        title: topic.title,  
        url: baseUrl + “t/” + topic.slug,  
        author: {  
          name: user.name,  
          screenName: user.screenName,  
          avatar: getAvatarUrl(user.avatarTemplate)  
        }  
      }  
    })  
    return resData;

  })  
  .catch(error => {  
    console.log(error);  
  })  
  .finally( ()=> {  
    session.close();  
  })  
} }}; Apollo Server We use in a Node.js app to allow us to build a GraphQL API from a GraphQL schema (type definitions) and resolvers. We inject a Neo4j driver instance into the context so that it is available in the resolver functions. Apollo Server import { typeDefs, resolvers } from “./graphql-schema”;import { ApolloServer, makeExecutableSchema } from “apollo-server”;import { v1 as neo4j } from “neo4j-driver”;import dotenv from “dotenv”; dotenv.config(); const schema = makeExecutableSchema({ , }); typeDefs resolvers const driver = neo4j.driver(process.env.NEO4J_URI || “bolt://localhost:7687”,neo4j.auth.basic(process.env.NEO4J_USER || “neo4j”,process.env.NEO4J_PASSWORD || “neo4j”)); const server = new ApolloServer({context: { driver },schema: schema}); server.listen(process.env.GRAPHQL_LISTEN_PORT, ‘0.0.0.0’).then(({ url }) => {console.log(`GraphQL API ready at ${url}`);}); One of the benefits of using Apollo Server is that we automatically get GraphQL Playground, a tool for exploring GraphQL APIs. GraphQL Playground allows us to explore the schema, including entry points and types, and to execute GraphQL requests against the API. makes it easy to explore GraphQL APIs. GraphQL Playground Try it here. The Neo4j Community Forum Landing Page The GraphQL first development approach was a fun and productive way for us to quickly build out a feature that allowed us to put it into production after a few hours of collaborative work. When it’s all said and done, here’s how the landing page looks: Not bad for a few hours hacking on a rainy day ☔ Check it out . here I skipped over how we populate the “This Week in Neo4j”, “Popular Community Projects”, and “New Certified Developers” sections, but it all comes from Neo4j Community Graph! You can find the GraphQL API code to see how those bits work. here neo4j-graphql-js and GRANDstack If you’re interested in exposing a GraphQL API on top of a graph database like Neo4j (we think GraphQL and graph databases are an obvious match for each other) be sure to check out the library and for building full stack applications. neo4j-graphql-js GRANDstack Be sure to join the Neo4j community forum on Discourse You can find the code for the GraphQL API . here Further Reading . A GraphQL API for the GraphQL Community Graph on top of Neo4j. GraphQL Community Graph And finally, here are a few more resources about Community Graph: — includes code for spinning up your own community graph Community Graph Github org GraphQL APIs for Developer Communities Five Common GraphQL Problems and How Neo4j-GraphQL Aims to Solve Them — GraphQL, React, Apollo, Neo4j Database full stack development GRANDstack.io

Building Trending Activity Feeds Using GraphQL And Neo4j

On the Economy of Machinery and Manufactures by Charles Babbage is part of the HackerNoon Books Series. You can jump to any chapter in this book . On the Division of Labour here Chapter 20. On the Division of Labour We have already mentioned what may, perhaps, appear paradoxical to some of our readers that the division of labour can be applied with equal success to mental as to mechanical operations, and that it ensures in both the same economy of time. A short account of its practical application, in the most extensive series of calculations ever executed, will offer an interesting illustration of this fact, whilst at the same time it will afford an occasion for shewing that the arrangements which ought to regulate the interior economy of a manufactory, are founded on principles of deeper root than may have been supposed, and are capable of being usefully employed in preparing the road to some of the sublimest investigations of the human mind. In the midst of that excitement which accompanied the Revolution of France and the succeeding wars, the ambition of the nation, unexhausted by its fatal passion for military renown, was at the same time directed to some of the nobler and more permanent triumphs which mark the era of a people's greatness and which receive the applause of posterity long after their conquests have been wrested from them, or even when their existence as a nation may be told only by the page of history. Amongst their enterprises of science, the French Government was desirous of producing a series of mathematical tables, to facilitate the application of the decimal system which they had so recently adopted. They directed, therefore, their mathematicians to construct such tables, on the most extensive scale. Their most distinguished philosophers, responding fully to the call of their country, invented new methods for this laborious task; and a work, completely answering the large demands of the Government, was produced in a remarkably short period of time. M. Prony, to whom the superintendence of this great undertaking was confided, in speaking of its commencement, observes: Je m'y livrai avec toute l'ardeur dont j'etois capable, et je m'occupai d'abord du plan general de l'execution. Toutes les conditions que j'avois a remplir necessitoient l'emploi d'un grand nombre de calculateurs; et il me vint bientot a la pensee d'appliquer a la connection de ces Tables la division du travail, dont les Arts de Commerce tirent un parti si avantageux pour reunir a la pernection de main-d'oeuvre l'economie de la depense et du temps. The circumstance which gave rise to this singular application of the principle of the division on labour is so interesting, that no apology is necessary for introducing it from a small pamphlet printed at Paris a few years since, when a proposition was made by the English to the French Government, that the two countries should print these tables at their joint expense. The origin of the idea is related in the following extract: C'est a un chapitre d'un ouvrage Anglais,(1*) justement celebre, (I.) qu'est probablement due l'existence de l'ouvrage dont le gouvernement Britannique veut faire jouir le monde savant: Voici l'anecdote: M. de Prony s'etait engage. avec les comites de gouvernement. a composer pour la division centesimale du cercle, des tables logarithmiques et trigonometriques, qui, non seulement ne laissassent rien a desirer quant a l'exactitude, mais qui formassent le monument de calcul 1e plus vaste et le plus imposant qui eut jamais ete execute, ou meme concu. Les logarithmes des nombres de 1 a 200.000 formaient a ce travail un supplement necessaire et exige. Il fut aise a M. de Prony de s'assurer que meme en s'associant trois ou quatre habiles co-operateurs. La plus grande duree presumable de sa vie ne lui sufirai pas pour remplir ses engagements. Il etait occupe de cette facheuse pensee lorsque. Se trouvant devant la boutique d'un marchand de livres. Il appercut la belle edition Anglaise de Smith, donnee a Londres en 1776: il ouvrit le livre au hazard. et tomba sur le premier chapitre, qui traite de la division du travail, et ou la fabrication des epingles est citee pour exemple. A peine avait-il parcouru les premieres pages, que, par une espece d'inspiration. il concut l'expedient de mettre ses logarithmes en manufacture comme les epingles. Il faisait en ce moment, a l'ecole polytechnique, des lecons sur une partie d'analyse liee a ce genre de travail, la methode des differences, et ses applications a l'interpolation. Il alla passer quelques jours a la campagne. et revint a Paris avec le plan de fabrication. qui a ete suivi dans l'execution. Il rassembla deux ateliers. qui faisai ent separement les memes calculs, et se servaient de verification reciproque.(2*) The ancient methods of computing tables were altogether inapplicable to such a proceeding. M. Prony, therefore, wishing to avail himself of all the talent of his country in devising new methods, formed the first section of those who were to take part in this enterprise out of five or six of the most eminent mathematicians in France. First section. The duty of this first section was to investigate, amongst the various analytical expressions which could be found for the same function, that which was most readily adapted to simple numerical calculation by many individuals employed at the same time. This section had little or nothing to do with the actual numerical work. When its labours were concluded, the formulae on the use of which it had decided, were delivered to the second section. Second section. This section consisted of seven or eight persons of considerable acquaintance with mathematics: and their duty was to convert into numbers the formulae put into their hands by the first section an operation of great labour; and then to deliver out these formulae to the members of the third section, and receive from them the finished calculations. The members of this second section had certain means of verifying the calculations without the necessity of repeating, or even of examining, the whole of the work done by the third section. Third section. The members of this section, whose number varied from sixty to eighty, received certain numbers from the second section, and, using nothing more than simple addition and subtraction, they returned to that section the tables in a finished state. It is remarkable that nine-tenths of this class had no knowledge of arithmetic beyond the two first rules which they were thus called upon to exercise, and that these persons were usually found more correct in their calculations, than those who possessed a more extensive knowledge of the subject. When it is stated that the tables thus computed occupy seventeen large folio volumes, some idea may perhaps be formed of the labour. From that part executed by the third class, which may almost be termed mechanical, requiring the least knowledge and by far the greatest exertions, the first class were entirely exempt. Such labour can always be purchased at an easy rate. The duties of the second class, although requiring considerable skill in arithmetical operations, were yet in some measure relieved by the higher interest naturally felt in those more difficult operations. The exertions of the first class are not likely to require, upon another occasion, so much skill and labour as they did upon the first attempt to introduce such a method; but when the completion of a calculating engine shall have produced a substitute for the whole of the third section of computers, the attention of analysts will naturally be directed to simplifying its application, by a new discussion of the methods of converting analytical formulae into numbers. The proceeding of M. Prony, in this celebrated system of calculation, much resembles that of a skilful person about to construct a cotton or silk mill, or any similar establishment. Having, by his own genius, or through the aid of his friends, found that some improved machinery may be successfully applied to his pursuit, he makes drawings of his plans of the machinery, and may himself be considered as constituting the first section. He next requires the assistance of operative engineers capable of executing the machinery he has designed, some of whom should understand the nature of the processes to be carried on; and these constitute his second section. When a sufficient number of machines have been made, a multitude of other persons, possessed of a lower degree of skill, must be employed in using them; these form the third section: but their work, and the just performance of the machines, must be still superintended by the second class. As the possibility of performing arithmetical calculations by machinery may appear to non-mathematical readers to be rather too large a postulate, and as it is connected with the subject of the division of labour, I shall here endeavour, in a few lines, to give some slight perception of the manner in which this can be done—and thus to remove a small portion of the veil which covers that apparent mystery. That nearly all tables of numbers which follow any law, however complicated, may be formed, to a greater or less extent, solely by the proper arrangement of the successive addition and subtraction of numbers befitting each table, is a general principle which can be demonstrated to those only who are well acquainted with mathematics; but the mind, even of the reader who is but very slightly acquainted with that science, will readily conceive that it is not impossible, by attending to the following example. The subjoined table is the beginning of one in very extensive use, which has been printed and reprinted very frequently in many countries, and is called a table of square numbers. Terms of Table A Table B first Difference C second Difference 1 1
                            3
    2 4 2
                            5
    3 9 2
                            7
    4 16 2
                            9
    5 25 2
                           11
    6 36 2
                           13
    7 49 Any number in the table, column A, may be obtained, by multiplying the number which expresses the distance of that term from the commencement of the table by itself; thus, 25 is the fifth term from the beginning of the table, and 5 multiplied by itself, or by 5, is equal to 25. Let us now subtract each term of this table from the next succeeding term, and place the results in another column (B), which may be called first difference column. If we again subtract each term of this first difference from the succeeding term, we find the result is always the number 2, (column C); and that the same number will always recur in that column, which may be called the second difference, will appear to any person who takes the trouble to carry on the table a few terms further. Now when once this is admitted, it is quite clear that, provided the first term (1) of the table, the first term (3) of the first differences, and the first term (2) of the second or constant difference, are originally given, we can continue the table of square numbers to any extent, merely by addition: for the series of first differences may be formed by repeatedly adding the constant difference (2) to (3) the first number in column B, and we then have the series of numbers, 3, 5, 6, etc.: and again, by successively adding each of these to the first number (1) of the table, we produce the square numbers. Having thus, I hope, thrown some light upon the theoretical part of the question, I shall endeavour to shew that the mechanical execution of such an engine, as would produce this series of numbers, is not so far removed from that of ordinary machinery as might be conceived.(3*) Let the reader imagine three clocks, placed on a table side by side, each having only one hand, and each having a thousand divisions instead of twelve hours marked on the face; and every time a string is pulled, let them strike on a bell the numbers of the divisions to which their hands point. Let him further suppose that two of the clocks, for the sake of distinction called B and C, have some mechanism by which the clock C advances the hand of the clock B one division, for each stroke it makes upon its own bell: and let the clock B by a similar contrivance advance the hand of the clock A one division, for each stroke it makes on its own bell. With such an arrangement, having set the hand of the clock A to the division I, that of B to III, and that of C to II, let the reader imagine the repeating parts of the clocks to be set in motion continually in the following order: viz.—pull the string of clock A; pull the string of clock B; pull the string of clock C. The table on the following page will then express the series of movements and their results. If now only those divisions struck or pointed at by the clock A be attended to and written down, it will be found that they produce the series of the squares of the natural numbers. Such a series could, of course, be carried by this mechanism only so far as the numbers which can be expressed by three figures; but this may be sufficient to give some idea of the construction—and was, in fact, the point to which the first model of the calculating engine, now in progress, extended. We have seen, then, that the effect of the division of labour, both in mechanical and in mental operations, is, that it enables us to purchase and apply to each process precisely that quantity of skill and knowledge which is required for it: we avoid employing any part of the time of a man who can get eight or ten shillings a day by his skill in tempering needles, in turning a wheel, which can be done for sixpence a day; and we equally avoid the loss arising from the employment of an accomplished mathematician in performing the lowest processes of arithmetic. The division of labour cannot be successfully practised unless there exists a great demand for its produce; and it requires a large capital to be employed in those arts in which it is used. In watchmaking it has been carried, perhaps, to the greatest extent. It was stated in evidence before a committee of the House of Commons, that there are a hundred and two distinct branches of this art, to each of which a boy may be put apprentice: and that he only learns his master's department, and is unable, after his apprenticeship has expired, without subsequent instruction, to work at any other branch. The watch-finisher, whose business is to put together the scattered parts, is the only one, out of the hundred and two persons, who can work in any other department than his own. In one of the most difficult arts, that of mining, great improvements have resulted from the judicious distribution of the duties; and under the arrangments which have gradually been introduced, the whole system of the mine and its government is now placed under the control of the following officers. A manager, who has the general knowledge of all that is to be done, and who may be assisted by one or more skilful persons. Underground captains direct the proper mining operations, and govern the working miners. The purser and book-keeper manage the accounts. The engineer erects the engines, and superintends the men who work them. A chief pitman has charge of the pumps and the apparatus of the shafts. A surface-captain, with assistants, receives the ores raised, and directs the dressing department, the object of which is to render them marketable. The head carpenter superintends many constructions. The foreman of the smiths regulates the ironwork and tools. A materials man selects, purchases, receives and delivers all articles required. The roper has charge of ropes and cordage of all sorts. Notes: An Enquiry into the Nature and Causes of the Wealth of Nations, by Adam Smith. Note sur la publication, proposee par le gouvernement Anglais des grandes tables logarithmiques et trigonometriques de M de Prony De l'imprimerie de F. Didot, December 1, 1829, p. 7 Since the publication of the second edition of this work, one portion of the engine which I have been constructing for some years past has been put together. It calculates, in three columns, a table with its first and second differences. Each column can be expressed as far as five figures, so that these fifteen figures constitute about one ninth part of the larger engine. The ease and precision with which it works leave no room to doubt its success in the more extended form. Besides tables of squares, cubes, and portions of logarithmic tables, it possesses the power of calculating certain series whose differences are not constant; and it has already tabulated parts of series formed from the following equations: The third differential of ux = units figur of delta ux The third differential of ux = nearest whole no. to (1/10,000 delta ux) The subjoined is one amongst the series which it has calculated: 0 3, 486 42,972 0 4,991 50,532 1 6,907 58,812 14 9,295 67,826 70 12,236 77,602 230 15,741 88,202
495 19,861 99,627
916 24,597 111,928
1,504 30,010 125,116
2,340 36,131 139,272 The general term of this is, ux = (x(x-1)(x-2))/(1 X 2 X 3) + the whole number in x/10 + 10 Sigma^3 (units figure of (x(x-1)/2) About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Charles Babbage (2003). On the Economy of Machinery and Manufactures. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/4238/pg4238.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

On the Division of Labour

Google’s MLKit library finds text in images and this works well for simple text but for tabular data such as receipts or tables, it does not. If you’ve ever used an you might have noticed that it works reasonably well when scanning a page with uniform text but when dealing with any kind of tables or text formatting, it just falls flat. OCR app This article discusses an algorithm used in a mobile application I wrote that processes text to keep it in line. We’ll take a common example of a store receipt. In the example below you can see exactly the problem that I’m trying to solve. Lens does not prefer lines for text but will rather put together text that is physically closer together. This works sometimes but definitely does not work for receipts and other tabular data. See specifically how Google Lens put the price as a new line because it was physically far away from the lines on the left. Google 1,49€ is an application developed specifically to scan tabular data and the results of scanning a receipt are in the top right corner.  You can see how it respected the horizontal layout of the receipt and put the price together with the correct article. Line Text Scanner Google OCR library Here is a quick overview of how to use the OCR library: load an image and get text. Recognition of characters happens entirely on Google’s side. InputImage image = InputImage.fromBitmap(mSelectedImage, 0);
        TextRecognizer recognizer = TextRecognition.getClient();
        
        recognizer.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<Text>() {
                            @Override
                            public void onSuccess(Text texts) {
                                processTextRecognitionResult(texts);
                            }
                        })
                .addOnFailureListener(
                       // 
                        }); Full documentation is here and the diagram below is from this link. https://developers.google.com/ml-kit/vision/text-recognition/v2?embedable=true Once we have the Text object we can begin our own logic. We’ll try to process Text to do better than Google Lens. First, we need to look at the Text object. Text is a hierarchical representation of the scanned text as seen in the following diagram from Google’s documentation. The algorithm looks for characters and words in physical space and puts them into a hierarchical structure. As mentioned, this works well for easy text as in the diagram above but for tabular data like a receipt it does not. Below we have the full text of the receipt scanned by Google Lens. ENTRETIEN/BAZAR......
MPX FILM FRAICH30M
EPICERIE/BOISSONS.......
1,49€
265G POIS CHICHES HARICOTS ROUGES TR
0,95€
PECHE FRAICH FRTS
COOKIES SABLES CHO
1,25€
3,69€
2,39€
HYGIENE/BEAUTE.......
2,99€
20 ELAST COURTS WA
2 X BATISTE SHP SEC 6,59€ 13,18€
2è à -60%
-3,95€
MPX FIL DENTAIR 50 SOIN BLANCHEUR GOU
2,09€
7,29€
SURGELES/PRODUITS FRAIS...........
LAITIERE PV VANILL
1,69€
MALO F.FRAIS FRUIT COMTE AOP 6M 450G
2,35€
5,29€
QUICHE LORRAINE ESCAL.PANEES DE BL
2,79€
OEUFS PLEIN AIRX12
2,85€
MORIN MOUSSE CHOCO
3,25€
2,09€
LONGLEY FARM COT.C
1,99€
TOTAL HORS AVANTAGES
57,62€
18
NOMBRE D'ARTICLES I think that you’ll agree that this is not very useful. The algorithm picked the columns first rather than the rows. It made new lines for text that was far away. This is the difference in text processing that this article explores. Processing Text To demonstrate what MLKit does I’ve modified the application to only output the index of Text Elements (those are boxes with dark green border in the diagram from Google). In the screen below we can see text blocks 0 to 31. We can see how the MLKit library prefers physical distance to group words together into phrases. This is not exactly what Google Lens has outputted. We can see that Google Lens made the price of 1,49€ below the first three lines. It treated the text blocks differently but didn’t manage to output clear lines. As seen from this output, the OCR library makes up block 0 as ‘Entrentien/Bazar. MPX FILM FRAICH30M’. The second block is made up of multiple lines of the left column. The library continues to create text blocks from the left column and then moves to the right column to create the text blocks from prices. The image is correctly converted into characters and words. We’ll use these words but do it using a different algorithm to prefer lines to make our sentences. It’s clear that Google Lens also processes these blocks but obviously in yet another way. Breaking boxes Now to our algorithm. The first thing we’ll do is process all the TextBlocks from Text to extract the individual lines. Each line has one or more object and we extract them all and put them into a single  list. Text.Element List<Text.Element> textElements = new ArrayList<>();

        for (int i = 0; i < blocks.size(); i++) {
            Rect rect = blocks.get(i).getBoundingBox();
  
            List<Text.Line> lines = blocks.get(i).getLines();
  
            for (int j = 0; j < lines.size(); j++) {
                List<Text.Element> elements = lines.get(j).getElements();
                for (int k = 0; k < elements.size(); k++) {
                    Text.Element e = elements.get(k);
                    textElements.add(e);
                 }
            } At this point, we have an array of objects which all contain some text. In our example, the four in block 0 are 'ENTRETIEN/BAZAR......’, ‘MPX’, ‘FILM’, and ‘FRAICH30M’. All of the elements are put into a list. Text.Element Text.Elements Sorting boxes So now that we have all these objects in a list, how do we determine what goes after what? As seen from above, the OCR algorithm just recognized blocks of text but it made no effort to make correct sentences. First, we need to realize that object is bound by Rect object which has coordinates and dimensions. We use this fact to sort the . Text.Element Text.Element Text.Elements We take the top and left coordinates of the rectangles and sort them: public int compare(Text.Element t1, Text.Element t2) {
            int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
            int diffOfLefts = t1.getBoundingBox().left - t2.getBoundingBox().left;

            int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) / 2;
            int verticalDiff = (int)(height * 0.35);

            int result = diffOfLefts;
            if (Math.abs(diffOfTops) > verticalDiff) {
                result =  diffOfTops;
            }
            return result;
        } The main decision in this algorithm is to decide whether one rectangle should go after another based on whether it is more to the right of it or more below it. The horizontal difference is easy, if one rectangle has coordinates more to the left of another rectangle then it will come before it. But this will be taken into consideration only if the difference in the tops is more than 35% height of the line. Basically, we allow for some skew in the picture-taking where the text might not align perfectly. But if a rectangle is 35% the height of the current rectangle below the next rectangle then we consider it as another line. Overall, in our algorithm, we prefer horizontal lines along which we can find the objects. Text.Element Making lines In this final processing step, we will make lines by processing the list above. Remember that the list just has rectangles and so we need to add a condition based on coordinates to decide whether to start a new line. To do this, we get the difference between the top of the boxes and take the average of their height. We don’t check the difference in location on the horizontal axis as we already did that when sorting boxes. Here we just have one decision to make: whether or not to make a new line. private boolean isSameLine(Text.Element t1, Text.Element t2) {
        int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
    
        int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) * 0.35;

        if (Math.abs(diffOfTops) > height ) {
            return false;
        }
        return true;
    } This finally gives us the well-formatted tabular text. Here is the full text again. ENTRETIEN/BAZAR.  
MPX FILM FRAICH3OM 1,49€  
EPICERIE/BO1SSONS.  
265G POIS CHICHES 0,95€  
HARICOTS ROUGES TR 1,25e  
PECHE FRAICH FRTS 3,69e  
COOKIES SABLES CHO 2,39e  
HYGIENE/BEAUTE.....  
20 ELAST COURTS WA 2,99€  
2 X BATISTE SHP SEC 6,59€ 13,18€  
2è à -60% -3,95€  
MPX FIL DENTAIR 50 2,09e  
SOIN BLANCHEUR GOU 7,29€  
SURGELES/PRODUITS FRAIS....  
LAITIERE PV VANILL 1,69€  
MALO F.FRAIS FRUIT 2,35€  
COMTE AOP 6M 450G 5,29€  
QUICHE LORRAINE 2,79€  
ESCAL.PANEES DE BL 2,85e 
OEUFS PLEIN AIRX12 3,25€  
MORIN MOUSSE CHOCO 2,09e  
LONGLEY FARM COT.C 1,99e  
TOTAL HORS AVANTAGES 57,62e 
NOMBRE D'ARTICLES 18 Conclusion The solution to process the text in lines in this article is not without faults. The text should be relatively straight and not skewed too much. With some effort, we could calculate the vectors of lines even in the most crumpled receipt but that would be for another article. Here we show how a small tweak in treating the output of a large library can have a big effect for a very specific purpose. If you think that this is useful to you, the app is available in the . Google Play Store

Using Google MLKit Text Recognition to Scan Tabular Data

As 2022 wrapped up, people felt the coldest wave of “crypto winter,” sending chills down their spine. With what James Bromley, an attorney involved in the FTX bankruptcy proceedings, described as ,” the once crypto giant succumbed under a series of its own financial misdeeds. “the most abrupt and difficult collapses of Corporate America Sam Bankman Fried’s cryptocurrency empire, FTX, collapsed in a lightning-fast series of events. Followed by of Alameda’s balance sheet and the company’s desperate and unsuccessful attempts to secure emergency funding covering the shortcomings of around $8bn dollars, the now infamous SBF on Nov 11. He was arrested on Nov 22 for the charges of wire fraud, securities fraud, and money laundering. Coindesk’s analysis report filed for bankruptcy Though the collapse has brought up so many questions, the developments in the case leave two major ones looming: How far will the damage spread? And Is there a way to save cryptocurrency? “The recent collapse of FTX is a loud warning bell that cryptocurrencies can fail, and just like we saw with over-the-counter derivatives that led to a financial crisis, these failures can have a ripple effect on consumers and other parts of our financial system. The cryptocurrency market’s continued turmoil is why we must think carefully about how to regulate cryptocurrencies and their role in our economy,” (D-Ohio), the Chair of the Senate Banking, Housing, and Urban Affairs Committee. said Sen. Sherrod Brown Assessing the Damage The immediate aftermath of the crash saw the value of many cryptocurrencies drops sharply. Bitcoin, the world’s largest cryptocurrency by market capitalization, saw its value in the days following the incident. Other major cryptocurrencies, such as Ethereum and Litecoin, also experienced significant declines. fall over by 10% The collapse also caused a domino effect, with many investors liquidating their assets and several crypto exchanges filing for bankruptcy. The companies, due to “significant exposure” to FTX, took a page from their “biggest creditor’s” handbook and filed for Chapter 11. The latest one to the list is after BlockFi, Celsius Network, and Voyager Digital. join Genesis In addition to the direct financial losses suffered by the investors, the fall led to a negative impact on the overall perception of cryptocurrency. The traditional financial institutions and mainstream investors saw the collapse as a failure of security and stability in holding digital assets. In a on the crypto-asset risks, Federal Reserve System and Federal Deposit Insurance Corporation said, “It is important that risks related to the crypto-asset sector that cannot be mitigated or controlled do not migrate to the banking system. The agencies are supervising banking organizations that may be exposed to risks stemming from the crypto-asset sector and carefully reviewing any proposals from banking organizations to engage in activities that involve crypto-assets.” joint statement The skepticism is not baseless; this cryptic world operates in a peer-to-peer network of blockchain, where the transactions are just a click away. Many mainstream economists like Christine Lagarde, Paul Krugman, Nouriel Roubini, and Kenneth Rogoff have come out in the past. against crypto European Central Bank President Christine Lagarde said she is concerned about people “who have no understanding of the risks, who will lose it all and who will be terribly disappointed, which is why I believe that that should be regulated.” A conducted back in 2021 showed that 1 in 3 people investing in cryptocurrency knows little to nothing about it. Data collected from about 750 investors showed that only 16.9% of them understood where their money was going. survey With the traditional finance system, even if the people do not fully understand the system, stringent laws and regulations back it up, protecting customers’ interests. In the case of DeFi, the regulations are there, but the exercising authority and the political lines blur around the edges. In a back in Aug 2021, the SEC chair Gary Gensler said, “There are some gaps in this(crypto) space, though: We need additional Congressional authorities to prevent transactions, products, and platforms from falling between regulatory cracks. We also need more resources to protect investors in this growing and volatile sector.” speech More than 13 years since the release of Bitcoin and more than a year since this speech, there are still no centralized regulations backing the space up. The crypto industry has been in a cold war with regulators for quite some years now. The drill doesn’t amount to anything but reviewing potential bills to pass aimed at revolutionizing this uncertain digital market. “ If you wanted to build a new system for trading crypto, you could kind of just code it up and see what happened. Then you could go to the regulators and say, “Here’s how the rules for crypto should work,” and they might listen to you. (Or they might not. They might argue, as many regulators did, that crypto is largely covered by existing rules and that you were breaking them. But you might go ahead anyway or move to a different country with friendlier regulators.).” Matt Levine wrote in an article titled “ .” How to not play the game End number of new digital currencies and companies have been launched, and the policing authorities have struggled to keep up. There are with cryptocurrencies to trade, according to CoinMarketCap. 240+ crypto exchanges 8870 In the months following the crash, a majority of these exchanges have been to reinstate the faith of investors and protect themselves from the same fate as FTX, including exercising regulations and providing publicly accessible reserve proofs. actively taking steps Regulation and Decentralization’s Impact on the Future of Cryptocurrency “2023 for us could be a real inflection point in policy, and a regulatory framework could be one of those things that help to accelerate the accelerator side of the crypto downturn,” , VP of international policy at Coinbase. said Tom Duff Gordon The FTX breach had a detrimental effect, yet despite this, the cryptocurrency industry has proven to be quite resilient. have recovered, and trading volume has reached pre-contagion levels. The episode, however, serves as a warning of the dangers involved with investing in digital assets and the demand for more security and transparency in the sector. Prices “It’s frustrating to see what a lot of people in crypto see as a built-in bias against the industry, which many of us understand because this space does have a side to it that deserves and requires scrutiny,” says the chief marketing officer for crypto investor Haun Ventures. Rachael Horwitz, Cryptocurrency exchanges are constantly evolving, and a lack of regulations in this volatile space makes it easier for these institutions to engage in fraudulent and illegal activities. The lawmakers now have an impetus to get the proposed legislative laws finalized and set up a widespread regulatory framework. The demise of this crypto giant did not help those who were building their trust in cryptocurrencies. However, they are missing the argument that FTX was not “Crypto” itself; it was a centralized medium that let you borrow, buy, and sell crypto.  The convolutional framework of “real” cryptocurrencies is based upon a decentralized financial system(DeFi). “The major benefits (of DeFi) are we're looking at transparency. We're looking at the automation of risk management. We're looking at trustless reporting. You don't need to trust a third party, person, auditor, SBF, or anybody to understand the NAV and the valuation of a certain protocol. You can use things like subgraph technology. You can use things like Chainlink Oracle, and you don't have to trust a human being. You have to trust decentralized code, which is much easier to buy into.”  Mona El Isa, the CEO and founder of Avantgarde Finance and founder of Enzyme, said while talking about how DeFi can save cryptocurrency. in an interview In their , the members of the Monetary and Economic Department of the Bank for International Settlements: Igor Makarov and Antoinette Schoar, explained how decentralized exchanges (DEXs) have gained a lot of attention and are now the DeFi industry segment with the quickest rate of growth. Users' ownership over their private keys is one of the fundamental benefits of decentralized exchanges versus centralized exchanges. Market participants cede ownership of their crypto tokens to the exchange when they deposit them with a centralized exchange. This exposes them to exchange risk; investors may suffer large losses if the platform is compromised and their funds are misused. BIS working papers However, they also pointed out how we still have a long way to go since “the new financial architecture proposed by cryptocurrencies and decentralized finance presents formidable challenges for regulators.” The biggest challenge in regulating the crypto architecture comes from the jurisdiction-free nature of the currency originating from the use of permissionless blockchain protocols and smart contracts. A common framework of regulations is needed to protect the interests of global investors and to ensure that exchanges do not exercise free will when it comes to operating across different countries. “There also really needs to be coordination on enforcement to ensure that countries are not a safe haven and that there’s that level of global cooperation,” , a longtime advocate of stronger oversight. said Wharton’s Kevin Werbach

FTX’s Collapse and How It Will Impact the Regulatory Landscape and Future of the Crypto Industry

El colapso de FTX y cómo afectará el panorama regulatorio y el futuro de la criptoindustria

L'effondrement de FTX et son impact sur le paysage réglementaire et l'avenir de l'industrie de la cryptographie

FTX का पतन और यह कैसे क्रिप्टो उद्योग के नियामक परिदृश्य और भविष्य को प्रभावित करेगा

FTXの崩壊とそれが規制環境と暗号産業の将来にどのように影響するか

O colapso da FTX e como isso afetará o cenário regulatório e o futuro da indústria cripto

Sự sụp đổ của FTX và nó sẽ tác động như thế nào đến bối cảnh pháp lý và tương lai của ngành công nghiệp tiền điện tử

FTX 的崩溃及其将如何影响加密货币行业的监管格局和未来

I'm a big fan of tRPC. The idea of exporting types from the server and importing them in the client to have a type-safe contract between both, even without a compile-time step, is simply brilliant. To all the people who are involved in tRPC, you're doing amazing work. That said, when I'm looking at comparisons between tRPC and GraphQL, it seems like we're comparing apples and oranges. This becomes especially apparent when you look at the public discourse around GraphQL and tRPC. Look at this diagram by for example: theo explained this diagram in depth and at first glance, it makes a lot of sense. tRPC doesn't require a compile-time step, the developer experience is incredible, and it's a lot simpler than GraphQL. Theo But is that really the full picture, or is this simplicity achieved at the cost of something else? Let's find out by building a simple app with both tRPC and GraphQL. Let's build a Facebook clone with tRPC Let's imagine a file tree with a page for the news feed, a component for the feed list and a component for the feed item. src/pages/news-feed
├── NewsFeed.tsx
├── NewsFeedList.tsx
└── NewsFeedItem.tsx At the very top of the feed page, we need some information about the user, notifications, unread messages, etc. When rendering the feed list, we need to know the number of feed items, if there's another page, and how to fetch it. For the feed item, we need to know the author, the content, the number of likes, and if the user has liked it. If we were to use tRPC, we would create a "procedure" to load all this data in one go. We'd call this procedure at the top of the page and then propagate the data down to the components. Our feed component would look something like this: import { trpc } from '../utils/trpc'

export function NewsFeed() {
  const feed = trpc.newsFeed.useQuery()
  return (
    <div>
      <Avatar>{feed.user}</Avatar>
      <UnreadMessages> {feed.unreadMessages} unread messages </UnreadMessages>
      <Notifications> {feed.notifications} notifications </Notifications>
      <NewsFeedList feed={feed} />
    </div>
  )
} Next, let's look at the feed list component: export function NewsFeedList({ feed }) {
  return (
    <div>
      <h1>News Feed</h1>
      <p>There are {feed.items.length} items</p>
      {feed.items.map((item) => (
        <NewsFeedItem item={item} />
      ))}
      {feed.hasNextPage && (
        <button onClick={feed.fetchNextPage}>Load more</button>
      )}
    </div>
  )
} And finally, the feed item component: export function NewsFeedItem({ item }) {
  return (
    <div>
      <h2>{item.author.name}</h2>
      <p>{item.content}</p>
      <button onClick={item.like}>Like</button>
    </div>
  )
} Keep in mind, we're still a single team, it's all TypeScript, one single codebase, and we're still using tRPC. Let's figure out what data we actually need to render the page. We need the user, the unread messages, the notifications, the feed items, the number of feed items, the next page, the author, the content, the number of likes, and if the user has liked it. Where can we find detailed information about all of this? To understand the data requirements for the avatar, we need to look at the component. There are components for unread messages and notifications, so we need to look at those as well. The feed list component needs the number of items, the next page, and the feed items. The feed item component contains the requirements for each list item. Avatar In total, if we want to understand the data requirements for this page, we need to look at 6 different components. At the same time, we don't really know what data is actually needed for each component. There's no way for each component to declare what data it needs as tRPC has no such concept. Keep in mind that this is just one single page. What happens if we add similar but slightly different pages? Let's say we're building a variant of the news feed, but instead of showing the latest posts, we're showing the most popular posts. We could more or less use the same components, with just a few changes. Let's say that popular posts have special badges which require extra data. Should we create a new procedure for this? Or maybe we could just add a few more fields to the existing procedure? Does this approach scale well if we're adding more and more pages? Does this not sound like the problem we've had with REST APIs? We've even got famous names for these problems, like Overfetching and Underfetching, and we haven't even gotten to the point where we're talking about the N+1 problem. At some point we might decide to split the procedure into one root procedure and multiple sub-procedures. What if we're fetching an array at the root level, and then for each item in the array, we have to call another procedure to fetch more data? Another open could be to introduce arguments to the initial version of our procedure, e.g. . trpc.newsFeed.useQuery({withPopularBadges: true}) This would work, but it feels like we're starting to re-invent the features of GraphQL. Let's build a Facebook clone with GraphQL Now, let's contrast this with GraphQL. GraphQL has the concept of Fragments, which allows us to declare the data requirements for each component. Clients like Relay allow you to declare a single GraphQL query at the top of the page, and include fragments from the child components into the query. This way, we're still making a single fetch at the top of the page, but the framework actually supports us in declaring and gathering the data requirements for each component. Let's look at the same example using GraphQL, Fragments, and Relay. For laziness reasons, the code is not 100% correct because I'm using Copilot to write it, but it should be very close to what it would look like in a real app. import { graphql } from 'react-relay'

export function NewsFeed() {
  const feed = useQuery(graphql`
    query NewsFeedQuery {
      user {
        ...Avatar_user
      }
      unreadMessages {
        ...UnreadMessages_unreadMessages
      }
      notifications {
        ...Notifications_notifications
      }
      ...NewsFeedList_feed
    }
  `)
  return (
    <div>
      <Avatar user={feed.user} />
      <UnreadMessages unreadMessages={feed.unreadMessages} />
      <Notifications notifications={feed.notifications} />
      <NewsFeedList feed={feed} />
    </div>
  )
} Next, let's look at the feed list component. The feed list component declares a fragment for itself, and includes the fragment for the feed item component. import { graphql } from 'react-relay'

export function NewsFeedList({ feed }) {
  const list = useFragment(
    graphql`
      fragment NewsFeedList_feed on NewsFeed {
        items {
          ...NewsFeedItem_item
        }
        hasNextPage
      }
    `,
    feed
  )
  return (
    <div>
      <h1>News Feed</h1>
      <p>There are {feed.items.length} items</p>
      {feed.items.map((item) => (
        <NewsFeedItem item={item} />
      ))}
      {feed.hasNextPage && (
        <button onClick={feed.fetchNextPage}>Load more</button>
      )}
    </div>
  )
} And finally, the feed item component: import { graphql } from 'react-relay'

export function NewsFeedItem({ item }) {
  const item = useFragment(
    graphql`
      fragment NewsFeedItem_item on NewsFeedItem {
        author {
          name
        }
        content
        likes
        hasLiked
      }
    `,
    item
  )
  return (
    <div>
      <h2>{item.author.name}</h2>
      <p>{item.content}</p>
      <button onClick={item.like}>Like</button>
    </div>
  )
} Next, let's create a variation of the news feed with popular badges on feed items. We can reuse the same components, as we're able to use the directive to conditionally include the popular badge fragment. @include import { graphql } from 'react-relay'

export function PopularNewsFeed() {
  const feed = useQuery(graphql`
    query PopularNewsFeedQuery($withPopularBadges: Boolean!) {
      user {
        ...Avatar_user
      }
      unreadMessages {
        ...UnreadMessages_unreadMessages
      }
      notifications {
        ...Notifications_notifications
      }
      ...NewsFeedList_feed
    }
  `)
  return (
    <div>
      <Avatar user={feed.user} />
      <UnreadMessages unreadMessages={feed.unreadMessages} />
      <Notifications notifications={feed.notifications} />
      <NewsFeedList feed={feed} />
    </div>
  )
} Next, let's look at how the updated feed list item could look like: import { graphql } from 'react-relay'

export function NewsFeedItem({ item }) {
  const item = useFragment(
    graphql`
      fragment NewsFeedItem_item on NewsFeedItem {
        author {
          name
        }
        content
        likes
        hasLiked
        ...PopularBadge_item @include(if: $withPopularBadges)
      }
    `,
    item
  )
  return (
    <div>
      <h2>{item.author.name}</h2>
      <p>{item.content}</p>
      <button onClick={item.like}>Like</button>
      {item.popularBadge && <PopularBadge badge={item.popularBadge} />}
    </div>
  )
} As you can see, GraphQL is quite flexible and allows us to build complex web applications, including variations of the same page, without having to duplicate too much code. GraphQL Fragments allow us to declare data requirements at the component level Moreover, GraphQL Fragments allow us to explicitly declare the data requirements for each component, which get then hoisted up to the top of the page, and then fetched in a single request. GraphQL separates API implementation from data fetching The great developer experience of tRPC is achieved by merging two very different concerns into one concept, API implementation and data consumption. It's important to understand that this is a trade-off. There's no free lunch. The simplicity of tRPC comes at the cost of flexibility. With GraphQL, you have to invest a lot more into schema design, but this investment pays off the moment you have to scale your application to many but related pages. By separating API implementation from data fetching it becomes much easier to re-use the same API implementation for different use cases. The purpose of APIs is to separate the internal implementation from the external interface There's another important aspect to consider when building APIs. You might be starting with an internal API that's exclusively used by your own frontend, and tRPC might be a great fit for this use case. But what about the future of your endeavor? What's the likelihood that you'll be growing your team? Is it possible that other teams, or even 3rd parties will want to consume your APIs? Both REST and GraphQL are built with collaboration in mind. Not all teams will be using TypeScript, and if you're crossing company boundaries, you'll want to expose APIs in a way that's easy to understand and consume. There's a lot of tooling to expose and document REST and GraphQL APIs, while tRPC is clearly not designed for this use case. So, while it's great to start with tRPC, you're very likely to outgrow it at some point, which I think theo also mentioned in one of his videos. It's certainly possible to generate an OpenAPI specification from a tRPC API, the tooling exists, but if you're building a business that will eventually rely on exposing APIs to 3rd parties, your RPCs will not be able to compete against well-designed REST and GraphQL APIs. Conclusion As stated in the beginning, I'm a big fan of the ideas behind tRPC. It's a great step into the right direction, making data fetching simpler and more developer friendly. GraphQL, Fragments, and Relay on the other hand are powerful tools that help you build complex web applications. At the same time, the setup is quite complex and there are many concepts to learn until you're getting the hang of it. While tRPC gets you started quickly, it's very likely that you'll outgrow its architecture at some point.If you're making a decision today to bet on either GraphQL or tRPC, you should take into account where you see your project going in the future. How complex will the data fetching requirements be? Will there be multiple teams consuming your APIs? Will you be exposing your APIs to 3rd parties? Outlook With all that said, what if we could combine the best of both worlds? How would an API client look like that combines the simplicity of tRPC with the power of GraphQL? Could we build a pure TypeScript API client that gives us the power of Fragments and Relay, combined with the simplicity of tRPC? Imagine we take the ideas of tRPC and combine them with what we've learned from GraphQL and Relay. Here's a little preview: // src/pages/index.tsx
import { useQuery } from '../../.wundergraph/generated/client'
import { Avatar_user } from '../components/Avatar'
import { UnreadMessages_unreadMessages } from '../components/UnreadMessages'
import { Notifications_notifications } from '../components/Notifications'
import { NewsFeedList_feed } from '../components/NewsFeedList'
export function NewsFeed() {
  const feed = useQuery({
    operationName: 'NewsFeed',
    query: (q) => ({
      user: q.user({
        ...Avatar_user.fragment,
      }),
      unreadMessages: q.unreadMessages({
        ...UnreadMessages_unreadMessages.fragment,
      }),
      notifications: q.notifications({
        ...Notifications_notifications.fragment,
      }),
      ...NewsFeedList_feed.fragment,
    }),
  })
  return (
    <div>
      <Avatar />
      <UnreadMessages />
      <Notifications />
      <NewsFeedList />
    </div>
  )
}

// src/components/Avatar.tsx
import { useFragment, Fragment } from '../../.wundergraph/generated/client'
export const Avatar_user = Fragment({
  on: 'User',
  fragment: ({ name, avatar }) => ({
    name,
    avatar,
  }),
})
export function Avatar() {
  const data = useFragment(Avatar_user)
  return (
    <div>
      <h1>{data.name}</h1>
      <img src={data.avatar} />
    </div>
  )
}

// src/components/NewsFeedList.tsx
import { useFragment, Fragment } from '../../.wundergraph/generated/client'
import { NewsFeedItem_item } from './NewsFeedItem'
export const NewsFeedList_feed = Fragment({
  on: 'NewsFeed',
  fragment: ({ items }) => ({
    items: items({
      ...NewsFeedItem_item.fragment,
    }),
  }),
})
export function NewsFeedList() {
  const data = useFragment(NewsFeedList_feed)
  return (
    <div>
      {data.items.map((item) => (
        <NewsFeedItem item={item} />
      ))}
    </div>
  )
}

// src/components/NewsFeedItem.tsx
import { useFragment, Fragment } from '../../.wundergraph/generated/client'
export const NewsFeedItem_item = Fragment({
  on: 'NewsFeedItem',
  fragment: ({ id, author, content }) => ({
    id,
    author,
    content,
  }),
})
export function NewsFeedItem() {
  const data = useFragment(NewsFeedItem_item)
  return (
    <div>
      <h1>{data.title}</h1>
      <p>{data.content}</p>
    </div>
  )
} What do you think? Would you use something like this? Do you see the value in defining data dependencies at the component level, or do you prefer to stick with defining remote procedures at the page level? I'd love to hear your thoughts... We're currently in the design phase to build the best data fetching experience for React, NextJS and all other frameworks. If you're interested in this topic, follow me on to stay up to date. Twitter If you'd like to join the discussion and discuss RFCs with us, feel free to join our server. Discord Next

The Simplicity of tRPC with the Power of GraphQL 

La simplicidad de tRPC con el poder de GraphQL

La simplicité de tRPC avec la puissance de GraphQL

ग्राफक्यूएल की शक्ति के साथ टीआरपीसी की सरलता

GraphQL の力による tRPC のシンプルさ

A simplicidade do tRPC com o poder do GraphQL

Tính đơn giản của tRPC với sức mạnh của GraphQL

tRPC 的简单性和 GraphQL 的强大功能

Ruby on Rails has an awesome gem to upload, store and display images: . It's very easy to use and it comes with a local disk-based service, that should be enough to store everything you need if you just want to practice using Rails. Active Storage However, when you start building more elaborated websites and deploy them to production, you'll start noticing the limitations of Active Storage's local disk. In Heroku, for example, although you are able to upload images using disk storage and everything will look fine, these files will disappear after the application is automatically restarted (which happens once every 24 hours on the free plan). Of course, this all makes sense. The purpose of the local disk is for development and testing. For production, Active Storage facilitates uploading files to cloud storage services, such as Amazon S3, Google Cloud Storage, an Microsoft Azure Storage, which are suggested by . Rails Guides Or, if you are a developer student like me and want to save any possible dollar, you can use . Cloudinary Why choose Cloudinary? The first reason that made me choose Cloudinary was the price. It's free! At least for my needs and, I think, for most of yours as well. The Free Classic Plan gives you 10GB of storage, and it's not just for one year, it's forever. The second reason was the possibility to use it on my existing Rails application. Cloudinary provides a that simplifies the integration with Ruby on Rails applications, which, according to the documentation, presents the following features: Ruby Gem Methods to build URLs for image and video manipulations; Rails view helper tags for embedding and transforming images; API wrappers for file upload, administration, sprite generation and more; Server-side file upload plus direct unsigned file upload from the browser using the jQuery plugin; Migration tool; Active Record integration; CarrierWave plugin; Static image syncing for CDN delivery; General Ruby integration for non-Rails frameworks such as Sinatra. Not enough, Cloudinary also allows you to manipulate uploaded images simply by passing a set of transformation parameters on the dynamic URL in your views. For example, you can resize and crop the images, change its format and quality, rotate, and apply a large variety of special effects and filters. All manipulations are performed automatically in the cloud. The free plan offers 20,000 monthly transformations. Setting up Cloudinary on your Rails application The first step, of course, it's to sign up for a Cloudinary free account. Then, to install the Cloudinary Ruby gem on your project, add the following line to the Gemfile: gem 'cloudinary' And run bundle install. To use the library, you need to configure your project to provide Cloudinary's cloud_name, api_key, and api_secret. These credentials can be found on the Dashboard page of your account. Setting the configuration parameters can be done globally by creating a file under the directory of your Rails project. The contents of this file should look like this: cloudinary.yml config production: cloud_name: "sample" api_key: "874837483274837" api_secret: "a676b67565c6767a6767d6767f676fe1" secure: true cdn_subdomain: true You can your customized configuration file through Cloudinary's Management Console, and just place it under the directory. You might also define several optional if relevant for your project. download cloudinary.yml config configuration parameters So, now that everything is configured for using the gem, you will need to create the functionality for uploading and displaying the images on your website. Cloudinary offers many uploading options, such as an upload widget, server-side upload, and direct uploading from the browser. Moreover, it also supports integration with other libraries, like CarrierWage, Attachinary, and Active Storage, which can be useful for integrating image uploads with your models. In my case, my application was almost ready when I realized I needed an alternative to store the images. Until there, I was using Active Storage's local disk, and since I didn't want to change so much of my code, my decision was pretty clear. Integrating Cloudinary with Active Storage The Cloudinary gem allows you to use all its great features, while still using Active Storage to easily upload images from HTML forms to your model. Assuming you have already configured your application to use Active Storage (if not, I recommend reading ), the following steps are pretty straightforward. this article 1. Declare the Cloudinary service in the file by adding a new entry with a custom name (e.g., cloudinary) and the service configuration: config/storage.yml Cloudinary cloudinary: service: 2. In each environment you want to use Cloudinary, you have to tell Active Storage to use this service by updating . For example, if you want to use it on the production environment, you need to have the following line on the : config.active_storage.service config/environments/production.rb config.active_storage.service = # Store uploaded files on the local file system (see config/storage.yml for options). :cloudinary 3.  After setting up Cloudinary as the service, you will use direct uploading, which is already supported by Active Storage. To do that, include in your application's JavaScript bundle: activestorage.js //= require activestorage 4. On the form, include the direct upload URL on the input field: <%= %> <%= %> <%= %> <% %> form_for @post do |f| f.file_field , :picture : ' - ', : class form control direct_upload true f.submit , 'Create' : ' - - - - -100 -3' class btn sign up button btn outline secondary w mt end 5. Now you just need to display the image in the browser. Use the helper method to generate a permanent URL link, that upon access, redirects to a Cloudinary endpoint. url_for <%= %> url_for(@post.picture) One problem and how I solve it: Although with these configurations uploading and storage work fine, in the browser vertical images were being displayed in the wrong orientation. Turns out this happens because pictures captured on cameras, including from mobile devices, are stored with a series of metadata. One of them is called EXIF (exchangeable image file format), which informs the image's orientation. It seems that not all browsers have the support to get this information and apply the rotation automatically. Searching about this problem, I found out that if the image is transformed, Cloudinary will automatically orientate the image based on its EXIF information, and the image will be delivered with the correct orientation. Easy enough, no? As I said before, it's very easy to manipulate uploaded images on Cloudinary, simply by passing a set of transformation parameters on the dynamic URL in your views. Well, not so much. Even though the documentation states that the helper method was enhanced to accept any Cloudinary image transformation as a parameter, when I tried to do that, it results in an error saying this method only accepts 0..1 argument. url_for I couldn't find any answers to this problem yet, but searching through Cloudinary's settings, I found out that is possible to set up default transformations without changing my code. In your account settings, under the tab, you will find a section for . Upload upload presets Click on , and in the tab, you will find When you click on you will see all the available transformation options, including automatic rotation and use EXIF data. add presets Upload Manipulations Incoming Transformations. edit, In my case, I select the following transformations: use EXIF data, a default width, and quality automatic - good. And ta-dah!! Everything looks perfect now and my website it's fully functional, no more vanishing images (and for free!). Update (april 8th 2020) I contacted Cloudinary's support team about this error I was getting,  and it turns out it was a mistake in the documentation. So, instead of using the helper method, you need to use one of these: url_for <%= cl_image_tag(@user.avatar.key, , ) %> OR

<%= cloudinary_url(@user.avatar.key, options = {}) %> width: 200 crop: :scale //

Image Storage in Rails Apps Using  Cloudinary and Active Storage

A story of Galapagos birds and silicon chips Physics has changed human life a million times over. It regularly produces breakthroughs that seem science fiction: , , and . It’s amazing how scientists can unravel the mysteries of the universe. controlled star explosions putting a lab on a comet gravitational waves things too complicated to understand One would expect the human body and mind, which we all are familiar with, would pose little challenge. Yet psychology is going through a : less than 40% of tested research findings prove true. Then in medicine there is a marked lack of progress: despite incredibly large investments, . If you look at nutrition, it just a , with leading . replication crisis the war on cancer is being lost medical error might be third leading cause of death mess scientific research contradicting the official paradigm But why? We intuitively understand more about our minds and bodies than about quarks and bosons. Why can’t we develop this into a reliable science? And what does it have to do with Galapagos? There are 5 unavoidable causes for our incompetence is understanding ourselves: Galileo studied gravitational acceleration by dropping stones from the Tower of Pisa. In the 1940s the U.S. studied syphilis by infecting prisoners and individuals with mental illnesses with syphilis. Both are experiments, one in physics, the other in medicine. The gold standard of science is the experiment: a procedure undertaken to validate or refute a hypothesis. What Galileo did is admirable, while what the U.S. did is despicable. The inherent limitation of medicine and psychology: experiments can harm human beings. Because of this it is too costly to run most experiments for medicine and psychology. No potential finding is valuable enough to cost human lives. So medicine and psychology turned to observational studies. Scientists look at groups of people considered to differ in one specific variable (the independent variable). Then they measure various outcomes for these groups. The differences in outcomes between groups are attributed to the independent variable. Observational studies produce . They constitute the reason for much of the uncertainty in human understanding. uncertain findings But there are more basic limitations than the research design. They have a lot to do with the Galapagos and Darwin’s insights there. “All our knowledge begins with the senses” Immanuel Kant, Critique of Pure Reason Despite the complex and abstract nature of modern physics, it is rooted in sensory perceptions. Our sensory organs evolved to be great at perceiving the outside world. It was a basic requirement for survival. Physics is creating a model of the world out of what our senses tell us. When we turn our senses inward, the results are murky. You don’t know how fast your heart is beating. You cannot feel the health of your organs. You cannot even sense if you have foreign bodies inside (like parasites). Likewise we don’t perceive the processes in our minds, we can’t look at synapses or smell which areas of our brain are active. We can only feel the effects of our internal processes. Why are we in the dark about our own inside? Nothing about us is random. Ever forget to do anything? Maybe an email, or a chore? What if you forgot to breathe? Or did not send the right antibodies to fight an infection? We think of our conscious mind as our ultimate tool. But it cannot be trusted with the critical workings of our body. So they are automated. They are handled by an unconscious nervous system that does everything without our input. If we don’t consciously control these inner workings, then we do not need to know what is going on. Our senses do not tell us much about our own body. Except for low-res signals to prompt us to take specific actions (e.g. pain to not walk into walls or touch barbed wire). Without sensory input, we have to rely on indirect evidence of our own body’s processes. The first physics discovery might have been the intuitive understanding of gravity: objects fall. This is a repeatable, generalizable fact, e.g. all things fall, all the time, in any place on Earth. The first psychological discovery might have been that people get scared if you shout at them. But some people get more scared, some less, and others attack you. And all of them behave differently at different times. This does not fulfill any of the requirements for scientific fact. Plus, even without the sensory handicap, the human body is harder to study because of: “The first thing one learns about complex systems is that they are not a sum of body parts: a system is a collection of interactions, not an addition of individual responses.” Nassim Taleb In the physical world, if a stone falls besides you, you are mostly unaffected. As is most of the rest of the Earth. All events are correlated, but often the interaction effects are small. Scientist can study specific effects in isolation to the rest of the universe. In the human body, things are different. If you eat a bad egg, everything in your body is affected. Even your mood and thinking. The interaction effects are large and widespread. And it’s not just temporary events: , and your mind . This means it’s impossible to study any one event or one variable in complete isolation. Anything and everything interacts and affects the whole system. bacteria in your gut influence your emotions and behaviour health correlates with happiness can cause illness We don’t have the sensory organs to see these interaction effects. So we try to use math to model them. But our mathematical methods are quite . bad at understanding interaction effects in general In physics scientists use math to describe the world. Math is precise, clear, objective. It’s really hard to misunderstand math without showing you are an idiot. But because math is hard, and math for interconnected systems is especially hard, psychologists and physicians use words instead. Words are much less useful than math. It’s really, really easy to misunderstand words. Often it even makes you look smart. So: Physics = testable — easily observable — math (clear) Human body= not testable — hard to observe — words (unclear) Already looks hard. But it gets worse, the unclear words compound our: “Yet weren’t all human beings simply human beings no matter what name you applied to them[?]” Mind-reading robot Giskard, Robots and Empire, Isaac Asimov When the rock falls, I see it fall. And you see it fall. We agree that the rock fell. Even when we use imprecise words. When I eat a watermelon, I feel things (feelings, sensations, thoughts). When you eat the same watermelon, you feel different things. We also feel different things when someone shouts at us. Each of us has a big complex baggage of experiences that shapes our perceptions, emotions and thoughts. When studying the human body and mind, we bring all this baggage with us. When I research depression, I cannot help but think of my own experiences of being depressed. These biases cloud our judgements. I use poorly designed words to express my biased judgement. Your own biases then make you decode those words into something different than what I intended to express. Yet we might throw words at each other that make us believe we are in agreement. Maybe we need to design an A.I. that is free of all these biases so it can understand us for us. Did you see the connection with silicon chips yet? Hint: do our brains resemble computers? An A.I. would also benefit from not going through our biggest obstacle: evolution “Man is descended from a hairy, tailed quadruped, probably arboreal in its habits.” Charles Darwin Evolution is the root cause. We did not evolve to develop perfect medicine to live forever. We did not evolve to make ourselves happy and fulfilled. We evolved to survive and pass our DNA to offspring. That is it. We did not need an understanding of ourselves for this purpose. It might actually be detrimental. It’s hard to deal with the fact that there is no meaning to life beyond living. But it’s even more insidious. We tend to think of ourselves as brilliant minds trapped in flawed bodies. A popular metaphor is to think of the brain (and body) as hardware, and the mind as software running on top of this hardware. This is a bad metaphor. It confuses and obfuscates. A better metaphor is to think of the brain+mind as our Operating System and accompanying hardware. The brain and mind are interconnected. They have a continuous two-way relationship. They have evolved along a very long period of time to fulfill the survival function. On top of this O.S., we have the applications and files. The software. These are all the ideas, thoughts, models, emotions, concepts that we acquire and integrate in our own lifetime. They make up our individuality, our growth and our self. Files and applications can be added or erased. But we cannot change the O.S. (we don’t have admin). We cannot see the code behind it or go beyond it, to the BIOS. We have to work with what we have. Trying to create complex abstract theories without taking into account the specifics of the O.S. is akin to playing the latest videogame at high-res on Windows 3.1. It will crash and freeze. What I’m saying with my metaphor poorly constructed out of imprecise words is that the only clear fact about the human body and mind is it evolved for survival. If we can build a new model of ourselves, starting from that, then we might learn to improve our lives. We cannot have the science of physics, but we can have clarity. Help me help others Avantgarde Savage is creating a Radical Model for Better Life | Patreon I am creating Avantgarde Savage: a radical new model to create a Better Life for everyone. We live in a world where , in meaningless jobs, lost, complacently unhealthy, lonely and alone. All because we do not understand ourselves. most of us are unhappy is born from a multitude of sciences about human mind and brain and body. Based on how Homo Sapiens evolved in nature, we uncover how we can Avantgarde Savage make our lives in the modern world better. Discover Avantgarde Savage : did you find the link with Galapagos islands and silicon chips? Addendum we accept the theory of evolution inspired by Darwin voyage to the Galapagos island, yet we see ourselves as designed and abstract as silicon chips in computers we build. If not:

Why Humans Rock at Physics but Suck at Psychology and Medicine

New graduate? Jump on board one of these high flying companies Graduating students hungry to dive into the (aka ) often struggle to select the right, specific opportunity to start their career. startup community StartUpLand Each spring, I provide a comprehensive list of exciting, growing, hiring startups–both private or recently public–that are worthy of consideration as places to start or continue a career in StartupLand. The criteria for being on the list is subjective but is a mix of fundraising (typically > $10m in the most recent round), scale (typically > 50 employees), momentum (typically growing revenue or users > 50%) and hiring (typically > 10 open reqs, including a number of entry level positions that would be a fit for recent college or business school graduates). Before we get into the companies themselves, I suggest checking out my posts and , where I give some more detailed advice on how to select the right company for you and position yourself to secure a job. Getting Your First Startup Job Are You Suited For A StartUp? Once you have reviewed this framework for deciding what you’re looking for, this post will give you to research and approach. a list of over 500 companies As usual, the list is compiled and organized based on location since I believe in selecting a geography to plug in to (and contribute to) a community and ecosystem. I received fantastic input from angels, entrepreneurs, lawyers and VCs across the world, helping me pressure test and compile this list (note: Flybridge portfolio companies are in blue). I recognize that the list contains no companies from India or China. I hope to cover those geographies in the future but just didn’t feel I had good enough intelligence at this time. I’d also point folks to Stanford’s Andy Rachleff’s , which he publishes each fall with a similar theme (albeit more Silicon Valley focused). terrific list I’m sure I made many mistakes and omissions, which are all my own. Feedback welcome! East Coast West Coast International Other Startup Hubs Bitpay, Ionic Security, Kabbage, MailChimp ATL: AvantCredit, , BucketFeet, Civis Analytics, Dough, Fooda, Groupon, Iris Mobile, Kapow, Narrative Sciences, , Raise.com, ShopRunner, Shiftgig, SpotHero, SproutSocial, Tastyworks, Uptake CHI: bloXroute Precognitive FullContact, Ibotta, LogRhythm, Rally, SendGrid, Sympoz, TeamSnap, VictorOps, Webroot, CO: Welltok 2U, Cvent, Optoro, Sonatype, Vox Media, WeddingWire DC: Apptio, Avalara, Avvo, ExtraHop, Julep, Juno, Koru, OfferUp, Outreach, Peach, Porch, Pro, Redfin, Rover.com SEA: Bamboo HR, Canopy Tax, Domo, Health Catalyst, HireVue, InsideSales, Instructure, Lucid Software, Observe Point, Pluralsight, Qualtrics, Solution Reach, Workfront UT: That’s it! Special thanks to all those who provided me with anonymous input as well as my colleague, , who did most of the heavy lifting to help me in compiling this list. Caroline Constable

The Rocket Ship Startup List: 2018

As someone who has spent months documenting, reporting, and repeatedly reaching out to VRChat's moderation team, I can say with full certainty: VRChat is failing its community. Worse, it's failing the thousands of underage users on its platform by allowing sexually explicit avatars to remain accessible in public worlds. These avatars are not subtle. They're not merely "suggestive." They're explicit, with full nudity toggles, simulated sexual parts (DPS/SPS), and hyper-sexualized models that can be used—and are being used—in public worlds accessed by children. And VRChat knows it. I've reported over 120 public avatars, each of which violated VRChat's own Terms of Service and Community Guidelines. Each avatar included blatant sexual content, from strip toggles to simulated genitalia. And while some of these avatars were later switched to "private"— which proves the reports were acknowledged — this lazy moderation tactic does nothing. Any user can reupload the same avatar. They can flip the switch and make it public again. And no action is ever taken against the accounts that originally uploaded them. That means the same user who put a hyper-nude avatar in a public world where minors play can go back and do it again without a single consequence. Let That Sink In: No Consequences. No Accountability. VRChat is a platform that boasts over 100,000 active users daily, and it has a rapidly growing Quest user base—which includes children as young as 13. Yes, the platform allows minors. And yes, those minors can—and do—equip fully nude avatars because they are public and often marked as Quest-compatible. This isn’t hypothetical. It’s happening now. This isn’t just poor moderation. It’s corporate negligence. When I reached out through the official moderation ticketing system, I was met with silence. Weeks passed. Tickets were ignored. In rare cases where action was taken, it was insufficient, temporary, and left the underlying problem untouched. Out of frustration and with deep concern for platform safety, I reached out to multiple senior staff at VRChat Inc., including: Casey (VP of Product & Production)
Graham Gaylor (Co-Founder & CEO)
Sam Luangkhot (Senior Community Manager)
Travis Morrison (Chief of Staff)
Thomas Hyde (VP of People) Not a single response. The VRC+ Illusion I’ve been a paying member. I’ve supported the platform. But VRC+ membership doesn’t come with any enhanced support, moderation tools, or even a voice in community health. You’re just another number feeding revenue to a company that reduced its workforce by 30% while its platform grew in daily users and risk. Meanwhile, the few remaining staff are too overwhelmed—or disinterested—to address one of the platform’s biggest threats: unchecked exposure to sexual content. Why It Matters Because this isn’t about prudishness. This is about basic digital safety and platform ethics. When minors are allowed to equip and explore NSFW avatars that simulate sexual acts, it’s no longer just a community problem. It becomes a legal and reputational liability. And it's something the entire VR industry should be watching closely. It's astonishing that in 2025, a leading VR social platform can look the other way while its underage users are exposed to—and actively using—avatars that could easily fall under definitions of sexually explicit material. I’m Done Waiting I've sent emails. I've submitted tickets. I've done the job of a community moderator for free, painstakingly documenting and flagging harmful content. And in return, I've been ignored. No one should have to fight this hard just to get a basic safety violation acknowledged. So now, I’m bringing this to the public. If VRChat won’t listen to those of us within the community trying to uphold its own policies, then maybe it’s time the wider tech world takes notice. A Call to Action If you’re a developer, creator, or someone who cares about the future of digital platforms: speak out. If you're a parent, take a hard look at what your kids are accessing. And if you’re part of the VRChat team reading this: do your damn job. You don’t get to hide behind automation and ticket systems anymore. Your users—especially your youngest ones—deserve a safe environment. And those of us who care about this community aren’t going anywhere. Harry Varden As someone who has spent months documenting, reporting, and repeatedly reaching out to VRChat's moderation team, I can say with full certainty: VRChat is failing its community. Worse, it's failing the thousands of underage users on its platform by allowing sexually explicit avatars to remain accessible in public worlds. These avatars are not subtle. They're not merely "suggestive." They're explicit, with full nudity toggles, simulated sexual parts (DPS/SPS), and hyper-sexualized models that can be used—and are being used—in public worlds accessed by children. And VRChat knows it. I've reported over 120 public avatars , each of which violated VRChat's own Terms of Service and Community Guidelines. Each avatar included blatant sexual content, from strip toggles to simulated genitalia. And while some of these avatars were later switched to "private"— which proves the reports were acknowledged — this lazy moderation tactic does nothing. over 120 public avatars Any user can reupload the same avatar. They can flip the switch and make it public again. And no action is ever taken against the accounts that originally uploaded them. That means the same user who put a hyper-nude avatar in a public world where minors play can go back and do it again without a single consequence. Let That Sink In: No Consequences. No Accountability. VRChat is a platform that boasts over 100,000 active users daily , and it has a rapidly growing Quest user base—which includes children as young as 13. Yes, the platform allows minors. And yes, those minors can—and do—equip fully nude avatars because they are public and often marked as Quest-compatible. This isn’t hypothetical. It’s happening now. over 100,000 active users daily public This isn’t just poor moderation. It’s corporate negligence. When I reached out through the official moderation ticketing system, I was met with silence. Weeks passed. Tickets were ignored. In rare cases where action was taken, it was insufficient, temporary, and left the underlying problem untouched. Out of frustration and with deep concern for platform safety, I reached out to multiple senior staff at VRChat Inc., including: Casey (VP of Product & Production) Graham Gaylor (Co-Founder & CEO) Sam Luangkhot (Senior Community Manager) Travis Morrison (Chief of Staff) Thomas Hyde (VP of People) Casey (VP of Product & Production) Graham Gaylor (Co-Founder & CEO) Sam Luangkhot (Senior Community Manager) Travis Morrison (Chief of Staff) Thomas Hyde (VP of People) Not a single response. The VRC+ Illusion I’ve been a paying member. I’ve supported the platform. But VRC+ membership doesn’t come with any enhanced support, moderation tools, or even a voice in community health. You’re just another number feeding revenue to a company that reduced its workforce by 30% while its platform grew in daily users and risk. Meanwhile, the few remaining staff are too overwhelmed—or disinterested—to address one of the platform’s biggest threats: unchecked exposure to sexual content. Why It Matters Because this isn’t about prudishness. This is about basic digital safety and platform ethics . When minors are allowed to equip and explore NSFW avatars that simulate sexual acts, it’s no longer just a community problem. It becomes a legal and reputational liability. And it's something the entire VR industry should be watching closely. basic digital safety platform ethics legal reputational It's astonishing that in 2025, a leading VR social platform can look the other way while its underage users are exposed to—and actively using—avatars that could easily fall under definitions of sexually explicit material. I’m Done Waiting I've sent emails. I've submitted tickets. I've done the job of a community moderator for free, painstakingly documenting and flagging harmful content. And in return, I've been ignored. No one should have to fight this hard just to get a basic safety violation acknowledged. So now, I’m bringing this to the public. If VRChat won’t listen to those of us within the community trying to uphold its own policies, then maybe it’s time the wider tech world takes notice. A Call to Action If you’re a developer, creator, or someone who cares about the future of digital platforms: speak out . If you're a parent, take a hard look at what your kids are accessing. And if you’re part of the VRChat team reading this: do your damn job . speak out do your damn job You don’t get to hide behind automation and ticket systems anymore. Your users—especially your youngest ones—deserve a safe environment. And those of us who care about this community aren’t going anywhere. Harry Varden

VRChat's Dangerous Oversight: A Breeding Ground for Public NSFW Avatars

VRChat's Dangerous Oversight: A Breeding Ground для публічных аватараў NSFW

La supervisió perillosa de VRChat: un terreny de cria per als avatars públics de NSFW

La supervisión peligrosa de VRChat: un terreno de cría para avatares públicos de NSFW

הפיקוח המסוכן של VRChat: קרקע לגידול אווטרים ציבוריים של NSFW

VRChatov opasni nadzor: uzgojno tlo za javne NSFW avatare

VRChatの危険な監視:公共のNSFWアバターの繁殖地

Ny Fanaraha-maso mampidi-doza amin'ny VRChat: Tontolo ho an'ny avatar NSFW ho an'ny vahoaka

यो बर्ष महानगरको अभियान — सम्पदा संरक्षण तथा सम्बर्धन, पर्यटन प्रवर्धनका लागि पूर्वाधार Next Post

Het gevaarlijke toezicht van VRChat: een kweekterrein voor publieke NSFW-avatars

Supervisão perigosa do VRChat: um terreno de reprodução para avatares públicos do NSFW

Небезпечний нагляд VRChat: Рослинний грунт для публічних аватарів NSFW

VRChat's Dangerous Oversight: A Breeding Ground for Public NSFW Avatars (Nhận xét nguy hiểm của VRChat: Một nền tảng sinh sản cho các avatar NSFW công cộng)

Stories, News & Mentions about AVANTARTE

Categories

Trending Topics

Stories, News & Mentions about AVANTARTE

Avantarte’s Stories on HackerNoon

Categories

Trending Topics