Plus one sheep minus one sheep
Pyth, 33 bytes

M?+&amp;&lt;HGgtGH&amp;+-499GHgGtHH1g749 250


Try it online: Pyth Compiler/Executor. Takes about 3 seconds on my laptop. The online compiler is a bit slower, but also computes the answer in about 15 seconds. 

The answer is: 

160547283350099323317963999889002394629262478407796913030854915361460989263675794524349914992326520887556329626280682363011590724268659750627030457440692447081328860242720905181098211539560301455338502543318855115593179999323115473879753632000


Explanation:

First some pseudo-code of the recursive function. This is quite easy to write. 

function g(p, n):
   if (p &gt; 0 and n &gt; 0):
      count = 0
      if (occupied_places_in_barn &lt; 499):
         count += g(p-1, n)
      if (occupied_places_in_barn &gt; 0):
         count += g(p, n-1)
      return count
   else:
      return 1 # only one way possible


And the Pyth translation:

M                                  def g(G,H): return _
    &lt;HG                               H &lt; G
   &amp;   gtGH                                 and g(G-1,H)
            +-499GH                   499-G+H
           &amp;       gGtH                       and g(G,H-1)
  +                                   return sum of these two numbers
 ?                     H1             if H else 1
                         g749 250  call g(749,250) and print


Why is this recursive code so fast? Doesn't the function g iterate over all 1.6*10^199 possibilities?

No it doesn't. The key here is dynamic programming. We store known results in a cache and lookup the results, when we call the function with the same parameters again. One really cool feature of Python is the @lru_cache decorator, which does all the work for you. No need to manually generate such a cache and handle stuff like lookup, storing results, ... And in Pyth it's even simpler, since each function automatically uses such a cache. So in total the function g gets executed only 125499 times. Way less than 1.6*10^199 times.