Lisp as an analogy for effective prayer

It may seem a bit odd to draw parallels between the programming language Lisp and effective prayer, but this was a revelation that struck me recently. No prior knowledge of Lisp, or of prayer, is necessary to understand this post.

A brief look at Lisp - specification and implementation

First let's take a very quick look at Lisp. Lisp is a programming language that has a specification, meaning that each command (or function, to use Lisp terminology) is defined to produce a certain result. As a concrete example, the + function must take in as many numbers as desired and must provide the result of adding those numbers. For example (+ 4 5 10) should result in 19.  Exactly HOW the nuts and bolts work for producing the result (i.e. the steps of adding up all the numbers in the + function) is up to the implementation of Lisp.  

The programmer doesn't need to know or care how the implementation works, the programmer just needs to know that if they call the + function, they will get a result with their numbers added together.

Anyone may create a Lisp implementation, although that's a massive task so most programmers simply use an existing implementation. The point is, there are already several different implementations of Lisp out there which are available for any programmer to use. Each implementation might have differences in the steps of its internal computations - but the same function should give the same result no matter what implementation you use.

It's really important for this blog post that you understand the difference between the specification and implementation.

To sum up this bit:

the specification is a set of requirements (or definitions) of what the results should be. For example, the multiplication function, indicated by the star symbol * is a function that multiplies as many numbers together as desired and gives the final result of that multiplication as a number. For example (* 2 10 5) will give a result of 100.

the implementation is the steps that go on behind the scenes to produce the final result. The programmer doesn't need to know about the implementation to program in Lisp. You don't need to know how the steps of multiplication work when you call the * function, you just need to know that it will yield the result of those numbers multiplied together, no matter which implementation of Lisp you use.

How does this analogize to prayer?

You may be wondering what this has to do with prayer. Through reading the Bible, God has often provided creative solutions to prayers - in other words, prayers were answered, but not necessarily in the way that you might first expect. 

When praying, these readings made me realize we don't want to tell God HOW to answer the prayer.  We just want to pray, and trust Him to come up with His way of how to answer the prayer. This may not necessarily be the way you had thought was best!

So to use the Lisp analogy, we want to pray the specification, not the implementation. As a concrete example, I would want to pray "Lord, let my child form positive harmonious friendships with others", NOT "Lord, please let this specific child be available to play with my child later this week".

When you pray, make sure you are praying the specification, not the implementation. If you find yourself praying the implementation, change your prayer to the specification

We need to trust the Lord to work out the details of the implementation, not us. So long as we are praying in His will i.e. a prayer that He wants for us anyway, He will answer it - but He will do it in His way. This may be somewhat different to the way we had envisaged. Remember, His way is in the long term the better way, even if at the time we had hoped for our way or our implementation. 

If you found this post interesting, you may also like these related posts:


Comments

Popular posts from this blog

Why Do Atheists Shout So Loudly When They Believe the Stakes are Lower?

Organized religion and why it is important

Do You Expect God to Match Up With YOUR Specifications?