Question: If I have a bottom tab navigator and I the screens within that navigator to navigate to a modal which will be truly full-screen (covering `SafeAreaView`), how do i I do that? From what i understand, `AppContainer` has to be rendered within `SafeAreaView`, if I'm using `SafeAreaView`. So that makes it tricky to use a modal outside of `SafeAreaView`. 

```
const Tabs = createBottomTabNavigator(
  {
    Home,
    ScreenA,
    ScreenB,
    ScreenC,
  },
  {
    tabBarOptions: {
      safeAreaInset: { bottom: 'never' },
    },
  }
);

const TabsAndModal = createStackNavigator(
  {
    Tabs,
    Modal,
  },
  {
    mode: 'modal',
    headerMode: 'none',
    initialRouteName: 'Tabs',
  },
);

const AppContainer = createAppContainer(TabsAndModal);

const App = () => {
  return (
    <SafeAreaView style={{ flex: 1, backgroundColor: 'blue' }}>
      <AppContainer />
    </SafeAreaView>
  );
};

```

This causes the modal to slide up from the bottom, but it starts at the `SafeAreaView` on an iphone X, so the blue background is visible just below. What is the right way to do this, so that the modal slides up from the very bottom of an an iphone x and the tabs are still rendered within `SafeAreaView`?

Answer: 
Good question , lets discuss one by one 

**Synchronous behavior:**

* Client send HTTP or any request and waits for the response HTTP.

**Asynchronous behavior:**

Client sends the request, There's another thread that is waiting on the socket for the response. Once response arrives, the original sender is notified (usually, using a callback like structure).

**Now we can talk about blocking vs nonblocking call**

When you are using spring rest then each call will initiate new thread and waiting for response and block your network , while nonblocking call all call going via single thread and pushback will return response without blocking network.

Now come to your question 

> 
> Using rabbitmq improve the performance of microservices due to
>  asynchronous nature of rabbitmq.
> 
> 
> 

**No** , performance is depends on your TPS hit and rabbitmq not going to improve performance .

Messaging give you two different type of messaging model

* Synchronous messaging
* Asynchronous messaging

Using Messaging you will get loose coupling and fault tolerance .

* If your application need blocking call like response is needed else cannot move use Rest
* If you can work without getting response go ahaead with non blocking
* If you want to design your app loose couple go with messaging.

In short above all are architecture style how you want to architect your application , performance depends on scalability .

You can combine your app with rest and messaging and non-blocking with messaging.

In your scenario microservice 1 could be rest blocking call give call other api using rest template or web client and or messaging queue and once get response will return rest json call to your web app.
You could also use events and make the whole flow async. In this scenario microservice1 creates an event representing the user request and then return a requested created response immediately to the user. You can then notify the user later when the request is finished processing.

I recommend the book *Designing Event-Driven Systems* written by Ben Stopford.