Return to Answer

I agree with you and I have the very same feeling of rejection when it comes to calling external processes. However, how @Telastyn answered, some times is necessary. So worth doing a bit of research to know the tools and the alternatives at hand.

@Telastyn has mentioned caches. In line with this argument, I would suggest meeting your tools in deep first, because some of the libraries, drivers and protocols implement cache out of the box. It's the case of some DB drivers, WWW architecture, etc.

For example, if ...

given the fact that they could be used multiple times

You have to research if your DB or your driver is already caching statements. If they do, probably many of the validation queries you execute are going to be cached. For a while. The same applies to HTTP requests (if you set the proper headers).

Regarding performance, often we put the focus on it too early. It's preferable implementing the easiest and obvious solution first, perform load tests, monitoring the system and get metrics. Then you are in a better position to make good decisions because these will be ground upon objective inputs.

To finish, when it comes to communication failures, worth knowing patterns and strategies such as Circuit Breaker, Retry or Fail Fast. They won't save you from the Fallacies of the Distributed Computing, but they can keep the solution simple and reliable.

Summarising. If you can avoid it, then dot it. If you can't, start implementing the easiest solution and test it. Then look for enhancements or alternatives if need it. The key is having resources, a toolbox to work on this sort of situations with some degree of confidence.

Most of the time the best solution is not the one that most likes us. It's the one that works, the simplest and reliable. Performance is not a problem most of the times. Connection errors should be expected (always, anytime), the solution then is an adequate error handling strategy.

I agreed. I have the same feeling of rejection when it comes to calling external services. How @Telastyn say, some times is necessary so worth doing a bit of research to meet in deep the tools and the alternatives at hand.

@Telastyn also mentioned caches. In line with his argument, I suggest meeting your tools first because some of them implement cache out of the box. It's the case of DB drivers, WWW architecture, ERM, frameworks, etc.

For example

given the fact that they could be used multiple times

Research whether your DB, driver, ERM or framework is already caching statements. If they do, many of the validation queries will be cached eventually. For a while. The same applies to HTTP requests (if you set the proper headers).

However, working with caches can be painful, overall if we don't understand how, when and what is invalidated.

Regarding performance, often we put the focus on it too soon. Start implementing first the easiest solution, perform load tests and get real metrics. Then you will be in a better position to make decisions because these will be ground and backed by data.

To finish, when it comes to communication failures, worth knowing patterns and strategies. For example Circuit Breaker, Retry or Fail Fast. These won't save you from the Fallacies of the Distributed Computing, but they can keep the actual solution simple and reliable.

Summarising, if you can avoid it, then do it. If you can't, start with meeting your resources at hand, implement something simple and test it. Then look for enhancements or alternatives if need it.

I agree with you and I have the very same feeling of rejection when it comes to calling external processes. However, how @Telastyn answered, some times is necessary. So worth doing a bit of research to know the tools and the alternatives at hand.

@Telastyn has mentioned caches. In line with this argument, I would suggest meeting your tools in deep first, because some of the libraries, drivers and protocols implement cache out of the box. It's the case of some DB drivers, WWW architecture, etc.

For example, if ...

given the fact that they could be used multiple times

You have to research if your DB or your driver is already caching statements. If they do, probably many of the validation queries you execute are going to be cached. For a while. The same applies to HTTP requests (if you set the proper headers).

Regarding performance, we often put the focus on it too early. It's preferable implementing the easiest and obvious solution first, perform some load tests, track and see how it behaves.

To finish, regarding communication failures, worth knowing patterns and strategies such as Circuit Breaker, Retry or Fail Fast. They won't save you from the Fallacies of the Distributed Computing, but they can contribute to keeping the solution simple and reliable.

Summarising. If you can avoid it then dot it. If you can't, don't worry too soon. Implement the easiest solution and test it. Then look for enhancements or alternatives if need it. The key is on having a toolbox to treat with this sort of situations with some degree of confidence. Most of the time the best solution is not the one that most likes us. It's the one that works, is simple and reliable. Performance is not a problem most of the times. Connection errors should be expected (always, anytime), the solution then is a good error handling strategy.

I agree with you and I have the very same feeling of rejection when it comes to calling external processes. However, how @Telastyn answered, some times is necessary. So worth doing a bit of research to know the tools and the alternatives at hand.

@Telastyn has mentioned caches. In line with this argument, I would suggest meeting your tools in deep first, because some of the libraries, drivers and protocols implement cache out of the box. It's the case of some DB drivers, WWW architecture, etc.

For example, if ...

given the fact that they could be used multiple times

You have to research if your DB or your driver is already caching statements. If they do, probably many of the validation queries you execute are going to be cached. For a while. The same applies to HTTP requests (if you set the proper headers).

Regarding performance, often we put the focus on it too early. It's preferable implementing the easiest and obvious solution first, perform load tests, monitoring the system and get metrics. Then you are in a better position to make good decisions because these will be ground upon objective inputs.

To finish, when it comes to communication failures, worth knowing patterns and strategies such as Circuit Breaker, Retry or Fail Fast. They won't save you from the Fallacies of the Distributed Computing, but they can keep the solution simple and reliable.

Summarising. If you can avoid it, then dot it. If you can't, start implementing the easiest solution and test it. Then look for enhancements or alternatives if need it. The key is having resources, a toolbox to work on this sort of situations with some degree of confidence. 

Most of the time the best solution is not the one that most likes us. It's the one that works, the simplest and reliable. Performance is not a problem most of the times. Connection errors should be expected (always, anytime), the solution then is an adequate error handling strategy.

I agree with you and I have the very same feeling of rejection when it comes to calling external processes. However, how @Telastyn answered, some times is necessary. So worth doing a bit of research to know the tools and the alternatives at hand.

@Telastyn has mentioned caches. In line with this argument, I would suggest meeting your tools in deep first, because some of the libraries, drivers and protocols implement cache out of the box. It's the case of some DB drivers, WWW architecture, etc.

For example, if ...

given the fact that they could be used multiple times

You have to research if your DB or your driver is already caching statements. If they do, probably many of the validation queries you execute are going to be cached. For a while. The same applies to HTTP requests (if you set the proper headers).

Regarding performance, we often put the focus on it too early. It's preferable implementing the easiest and obvious solution first, perform some load tests, track and see how it behaves.

To finish, regarding communication failures, worth knowing patterns such as Circuit Breaker, Retry or Fail Fast. They won't save you from the Fallacies of the Distributed Computing, but they can contribute to keeping the solution simple and reliable.

Summarising. If you can avoid it then dot it. If you can't, don't worry too soon. Implement the easiest solution and test it. Then look for enhancements or alternatives if need it. The key is on having a toolbox to deal with this sort of situations with some degree of confidence. Most of the time the best solution is not the one that most likes us. It's the one that works, is simple and reliable. Many times performance is not a problem and connection errors are expected, the solution then is a good error handling strategy.

I agree with you and I have the very same feeling of rejection when it comes to calling external processes. However, how @Telastyn answered, some times is necessary. So worth doing a bit of research to know the tools and the alternatives at hand.

@Telastyn has mentioned caches. In line with this argument, I would suggest meeting your tools in deep first, because some of the libraries, drivers and protocols implement cache out of the box. It's the case of some DB drivers, WWW architecture, etc.

For example, if ...

given the fact that they could be used multiple times

You have to research if your DB or your driver is already caching statements. If they do, probably many of the validation queries you execute are going to be cached. For a while. The same applies to HTTP requests (if you set the proper headers).

Regarding performance, we often put the focus on it too early. It's preferable implementing the easiest and obvious solution first, perform some load tests, track and see how it behaves.

To finish, regarding communication failures, worth knowing patterns and strategies such as Circuit Breaker, Retry or Fail Fast. They won't save you from the Fallacies of the Distributed Computing, but they can contribute to keeping the solution simple and reliable.

Summarising. If you can avoid it then dot it. If you can't, don't worry too soon. Implement the easiest solution and test it. Then look for enhancements or alternatives if need it. The key is on having a toolbox to treat with this sort of situations with some degree of confidence. Most of the time the best solution is not the one that most likes us. It's the one that works, is simple and reliable. Performance is not a problem most of the times. Connection errors should be expected (always, anytime), the solution then is a good error handling strategy.