Under the single-responsibility principle, should caching data be a separate function from returning the data?

Question

Suppose I have a program that returns data from an API. If its cache of the data is too old, the program downloads more data from the API, caches it, and outputs the new data. Else, the program outputs the cached data.

Should the function that downloads the data be separate from the function that caches the data? Should the function that caches the data be separate from the function that returns the data?

Answer 1

The SRP is first and foremost a principle for classes and/or modules, not for functions. Hence it is debatable if your case really applies to the SRP. My recommendation here is: do yourself a favor and stop thinking in terms like "how do I follow this principle" - better think in terms like "what makes most sense for my case".

In this case, in can perfectly make sense to have

• one function that downloads data
• a second function which caches the downloaded data
• a third function which tests if the cache data is "too old"
• and a fourth function which just calls the other three, coordinates them and returns either the cached or the downloaded data (this might also be the public entry point, whilst the other functions stay private)

But for deciding if that's a useful structure, I personally would prefer to look at the real code, not make some hypothetical discussion.

Answer 2

So, StackExchange's own single-responsibility tag helped clarify the single-responsibility principle: Wherever I can logically decouple the tasks to be performed, those tasks should be their own functions.

In this example, caching the data and retrieving the cached data are separate, relatively independent, tasks and should probably be separate functions.