Pyramid of doom (programming)

<h2 id="examples">Examples</h2>

Most modern <a href="/facts/Object-oriented_programming_language/TxNMEcao">object-oriented programming languages</a> use a coding style known as dot notation that allows multiple method calls to be written in a single line of code, each call separated by a period. For instance:

theWidth = windows("Main").views(5).size().width();

This code contains four different instructions; it first looks in the collection of windows for a window with the name "Main", then looks in that window's views collection for the 5th subview within it, then calls the size method to return a structure with the view's dimensions, and finally calls the width method on that structure to produce a result that is assigned to a variable name theWidth.
The problem with this approach is that the code assumes that all of these values exist. While it is reasonable to expect that a window will have a size and that size will have a width, it is not at all reasonable to assume that a window named "Main" will exist, nor that it has five subviews. If either of those assumptions is wrong, the corresponding call will result in a null pointer error.
To avoid this error, the programmer has to check every method call to ensure it returns a value. A safer version of the same code would be:

if windows.contains("Main") {
 if windows("Main").views.contains(5) {
 theWidth = windows("Main").views(5).size().width();
 //more code that works with theWidth
 }
}

If the programmer wishes to use that value based on whether or not it exists and is valid, the functional code inside the if statements is all pushed to the right, making it difficult to read longer lines. This often leads to attempts to "flatten" the code:

if windows.contains("Main") { theWindow = windows("Main") }
if theWindow != null && theWindow.views.contains(5) { theView = theWindow.views(5) }
if theView != null {
 theWidth = theView.size().width();
 //additional code
}

Or alternatively:

if !windows.contains("Main") {
 // handle error
} else if !windows("Main").views.contains(5) {
 // handle error
} else {
 theWidth = windows("Main").views(5).size().width();
 //more code that works with theWidth
}

This sort of programming construct is very common and a number of programming languages have added some sort of <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a> to address this. For instance, Apple's <a href="/facts/Swift_(programming_language)/A7qHQC32">Swift</a> added the concept of <a href="/facts/Safe_navigation_operator/L7GdyDVo">optional chaining</a> in if statements<a class="footnote-ref" id="fnref:5" href="#fn:5">5</a> while Microsoft's <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> 6.0 and <a href="/facts/Visual_Basic_.NET/09mPEo4q">Visual Basic</a> 14 added the <a href="/facts/Safe_navigation_operator/L7GdyDVo">null-conditional</a> operators ?. and ?[ for member access and indexing, respectively.<a class="footnote-ref" id="fnref:6" href="#fn:6">6</a><a class="footnote-ref" id="fnref:7" href="#fn:7">7</a><a class="footnote-ref" id="fnref:8" href="#fn:8">8</a> <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a> added support for the optional chaining operator in 2020.<a class="footnote-ref" id="fnref:9" href="#fn:9">9</a> The basic idea is to allow a string of method calls to immediately return null if any of its members is null, so for instance:

theWidth = windows("Main")?.views(5)?.size.width;

would assign null to theWidth if either "Main" or the fifth subview is missing, or complete the statement and return the width if they are both valid. There are many times where the programmer wants to take different actions in these two cases, so Swift adds another form of syntactic sugar for this role, the if let statement, also known as "optional binding":

if let theView = windows("Main")?.views(5) {
 //do things knowing the view exists...
 theWidth = theView.size.width
}

<h2 id="resolution">Resolution</h2>

Pyramid of Doom can usually be resolved in any language by simply breaking up the code into multiple nested functions (or other groupings). For instance, instead of:

main() {
	aaaaa() {
		bbbbb() {
			ccccc() {
				ddddd() {
					// do something now
				}
			}
		}
	}
}

You can break up the functionality like this:

doSomething() {
	// do something now
}

CC() {
	ccccc() {
		ddddd() {
			doSomething()
		}
	}
}

main() {
	aaaaa() {
		bbbbb() {
			CC()
		}
	}
}

Similarly, data structures can be broken up by levels, when similar pyramids occur.
Not only is the Pyramid of Doom solved, but it's better practice to not have large, complicated functions; 
smaller ones are easier for a programmer to write without erring, easier to read, and easier to verify.
Choosing function names for each of these levels will also help the author clarify to readers what is done where.
Typically, each level doesn't need many connections to levels that are far away, so separating them out is easy.
If there are such connections, the author can re-think their design to something more reliable, because this is a fertile source of bugs.

<h2 id="see-also">See also</h2>

Look up pyramid of doom in Wiktionary, the free dictionary.

<ul><li><a href="/facts/Futures_and_promises/5Mpgxv4m">Promises</a>, a technique for avoiding the pyramid of doom, e.g. used in JavaScript<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a></li>
<li><a href="/facts/Law_of_Demeter/bYgvB4Te">Law of Demeter</a></li>
<li><a href="/facts/Safe_navigation_operator/L7GdyDVo">Safe navigation operator</a>, a programming language operator that lets one avoid the pyramid of doom</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">Dave Herman (14 December 2011). "Why coroutines won't work on the web". The Little Calculist. Archived from the original on 2016-03-06. <a href="http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-web/" target="_blank">http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-web/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">"The Pyramid of Doom: A javaScript Style Trap". 27 November 2012. Archived from the original on 2015-12-09. <a href="https://web.archive.org/web/20151209151711/http://tritarget.org/blog/2012/11/28/the-pyramid-of-doom-a-javascript-style-trap" target="_blank">https://web.archive.org/web/20151209151711/http://tritarget.org/blog/2012/11/28/the-pyramid-of-doom-a-javascript-style-trap</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">Eberhardt, Colin (8 December 2014). "Tearing Down Swift's Optional Pyramid Of Doom". Archived from the original on 2016-07-31. <a href="http://blog.scottlogic.com/2014/12/08/swift-optional-pyramids-of-doom.html" target="_blank">http://blog.scottlogic.com/2014/12/08/swift-optional-pyramids-of-doom.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">"New Language Features in Visual Basic 14". 9 December 2014. Archived from the original on 2014-12-25. <a href="http://blogs.msdn.com/b/vbteam/archive/2014/12/09/new-language-features-in-visual-basic-14.aspx" target="_blank">http://blogs.msdn.com/b/vbteam/archive/2014/12/09/new-language-features-in-visual-basic-14.aspx</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">"Optional Chaining". Apple. <a href="https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html" target="_blank">https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">"Null-conditional Operators (C# and Visual Basic)". Microsoft. 7 March 2024. <a href="https://msdn.microsoft.com/en-us/library/Dn986595.aspx" target="_blank">https://msdn.microsoft.com/en-us/library/Dn986595.aspx</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">"What's New for Visual C#". Microsoft. 21 May 2024. <a href="https://msdn.microsoft.com/en-us/library/hh156499.aspx" target="_blank">https://msdn.microsoft.com/en-us/library/hh156499.aspx</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">"What's New for Visual Basic". Microsoft. 21 February 2023. <a href="https://msdn.microsoft.com/en-us/library/we86c8x2.aspx" target="_blank">https://msdn.microsoft.com/en-us/library/we86c8x2.aspx</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">"Optional chaining in JavaScript". 28 October 2024. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining" target="_blank">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">Joe Zimmerman (March 28, 2013). "What's The Point Of Promises?". telerik.com. <a href="http://www.telerik.com/blogs/what-is-the-point-of-promises" target="_blank">http://www.telerik.com/blogs/what-is-the-point-of-promises</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
</ol>

Pyramid of doom (programming) open-in-new

Pyramid of doom (programming)