<html><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space; "><div>I don't know that hanging your hat on the deterministic coat hook is the right thing to do.</div><div><br></div><div>The way that I've always looked at this is more probabilistic - you want the result to arrive within a certain time frame for a certain operation with a high probability. &nbsp;There is always the probability that the h/w will fail anyway - you could even reason that the software taking too long is just &nbsp;a transient fault that clears - random (non-correlated - preferably a bernoulli choice) failures are OK, non-deterministic ones aren't.</div><div><br></div><div>This probabilistic, low probability of being at the tail of timing, approach would give a lot more flexibility in any form of (say incremental) GC - you may not be able to bound the incremental steps absolutely but a strong probabilistic bound might well be more achievable.</div><div><br></div><div>Neil</div><div><br></div><div><br></div><div><div>On 1 Mar 2010, at 21:06, Job Vranish wrote:</div><br class="Apple-interchange-newline"><blockquote type="cite"><br><br><div class="gmail_quote">On Mon, Mar 1, 2010 at 2:37 PM, Thomas Schilling <span dir="ltr">&lt;<a href="mailto:nominolo@googlemail.com">nominolo@googlemail.com</a>&gt;</span> wrote:<br><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"> <div class="im">On 1 March 2010 16:27, Job Vranish &lt;<a href="mailto:job.vranish@gmail.com">job.vranish@gmail.com</a>&gt; wrote:<br> &gt; My current area of work is on realtime embedded software programming for<br> &gt; avionics systems. We do most of our coding in Ada but I've been dreaming of<br> &gt; using haskell instaed.<br></div> <br> A possible workaround would be to sprinkle lots of 'rnf's around your<br> code to make sure you don't build up a thunk or two that will delay<br> you later. &nbsp;And if you do this, aren't you essentially programming in<br> a strict functional language (like SML or O'Caml)? &nbsp;By careful<br> profiling you and auditing you can probably rule out most of the<br> potential bad cases, so it can be acceptable for a soft real-time<br> system (Galois did something like this, I believe). &nbsp;But for avionics<br> systems you probably want to more assurances than that, don't you?<font color="#888888"><br></font></blockquote></div><br>Yes and no.<br>It's true that lazy evaluation makes reasoning about timings a bit more difficult (and might not be usable in very time critical scenarios) but it is still has well defined deterministic behavior.<br> <br>It's the referential transparency that saves us here. If you run a lazy function with the same objects (in the same evaluation state) it should _theoretically_ take the same amount of time to run. All of our toplevel inputs will be strict, and if we keep our frame-to-frame state strick, our variances in runtimes, given the same inputs, should be quite low modulo the GC. <br> <br>Even our current code can take significantly different amounts of time to compute things depending on what you're doing. Some waypoints take longer to lookup from the database than others. Predicting the time to arrival can take significantly longer/shorter depending on seemingly trivial parameters, etc...<br> <br>It matters less that code always takes the same amount of time to run (though it needs to always be less than the frame time)&nbsp; and more so that it always takes the same amount of time to run given the same initial conditions.<br> <br>- Job<br> _______________________________________________<br>Haskell-Cafe mailing list<br><a href="mailto:Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>http://www.haskell.org/mailman/listinfo/haskell-cafe<br></blockquote></div><br></body></html>