Halakhah Yomit · Techie Talmid · On-Ramp

Shulchan Arukh, Orach Chayim 108:11-109:1

On-RampTechie TalmidNovember 23, 2025

Problem Statement – The "Bug Report" in the Sugya

Alright, fellow code-slingers of Torah! We've stumbled upon a fascinating bug in the spiritual operating system, specifically around handling missed prayer computations. The Shulchan Arukh, in Orach Chayim 108:11-109:1, presents a complex set of conditional logic for what happens when you miss a prayer (an Amidah instance). The core issue is how to implement a "make-up" or "catch-up" prayer (תפילת תשלומין) when a scheduled prayer (תפילת חובה) is missed.

Here's the bug report:

Bug ID: OrahChayim_108_109_MissedPrayerException

Severity: Critical – Affects core user functionality (daily prayer observance).

Description: Users (davening individuals) may encounter scenarios where they miss the designated prayer window for an Amidah. The system's expected behavior is to allow for a make-up prayer. However, the current implementation logic is complex and prone to misinterpretation, leading to potential errors in fulfilling mitzvot. Specifically, the rules for when a make-up is permissible, how many times it should be prayed, and what constitutes a valid make-up are intricate and depend on various contextual factors like the specific prayer missed, the time of the subsequent prayer, and whether the missed prayer was intentional or due to extenuating circumstances.

Observed Behavior: Users might pray a make-up prayer and not fulfill the obligation, or incorrectly believe they have fulfilled it. The system may also fail to correctly handle sequential missed prayers or missed prayers on special occasions (Shabbat, Rosh Chodesh, Yom Tov).

Expected Behavior: A clear, deterministic process for handling missed Amidah instances, ensuring the user can correctly perform a make-up prayer if eligible, and understanding when a make-up is not possible or required. This involves correctly identifying the "next adjoining prayer" as the designated make-up slot and managing specific conditions for holidays and intentional omissions.

Example Scenario: User misses Shacharit (morning prayer). The system should allow them to pray it during Mincha (afternoon prayer) as a make-up. But what if they also miss Mincha? The rules for handling multiple missed prayers become a performance bottleneck.

Our goal is to deconstruct this complex logic into a more manageable system, analyze different implementation strategies (Rishonim vs. Acharonim), and identify potential edge cases that could cause a system crash.

Full Experience in the App

Listen. Chat. Go deeper.

Audio playback, interactive chevruta, Hebrew tools, and every daily learning track — only in Derekh Learning.

Text Snapshot

Here are the key lines from the Shulchan Arukh that form the core logic we'll be analyzing:

108:11: "If one erred or was forced [by circumstance] and did not pray the morning prayer, one should pray the afternoon prayer twice: the first is the afternoon prayer, and the second as a make-up."
108:11: "If one inverted [the order], one has not fulfilled one obligation in prayer for the prayer which is a make-up, and one needs to go back and pray it [again]."
108:12: "If one erred and did not pray the afternoon prayer, one should pray the evening prayer twice: the first is for the evening prayer, and the second is for the make-up."
108:13: "[This statement] that one can complete [i.e. make-up] the [Amidah] prayer that one missed applies specifically during the time of [the next Amidah] prayer, but when it is not the time of [that next Amidah] prayer, one may not."
108:14: "There are no make-up prayers other than for the prayer immediately adjoining [i.e. preceding] prayer alone; so that if one erred and did not pray the morning prayer and [also] the afternoon prayer, one [only] prays the evening prayer twice [with] the latter prayer as a make-up for the afternoon prayer, but for the morning prayer there is no make-up;"
108:16: "If one erred and did not pray the afternoon prayer on the eve of Shabbat, one should pray the evening prayer [i.e. Shabbat Amidah] twice: the first is for the evening prayer and the second is the make-up [for the afternoon prayer]."
108:17: "If one erred and did not pray the afternoon prayer on Shabbat, one should pray it upon the [immediately after the end of] Shabbat (two weekday prayers); one separates [Shabbat from weekday i.e. the insertion of "ata chonantanu" into the 4th blessing of the Amidah] in the first, but one does not separate in the second."
108:18: "[If] it was on purpose and one did not pray [an Amidah], there is no make-up for it. Even at the prayer that is immediately adjoining it."
108:19: "One who did not pray [the Amidah] while there was still enough time to pray because one supposed that time would still remain for one after one finished whatever thing one was involved in, and between one thing and another, the time passed; and similarly, one who was troubled with monetary needs... All of these are considered people with extenuating circumstances and they [do] have a [opportunity for] a make-up."

Flow Model – The Decision Tree of Divine Service

Let's visualize the core logic of make-up prayers as a decision tree. This is like mapping out the execution path of our makeUpPrayer function.

START
- INPUT: missedPrayer, currentTime, prayerStatus (e.g., erred, forced, intentional)
- IS_PRAYER_MISSED?
  - YES:
    - IS_PRAYER_INTENTIONAL?
      - YES:
        
        OUTPUT: No Make-up Available. (See 108:18)
      - NO: (Erred or Forced)
        
        GET_NEXT_ADJOINING_PRAYER(missedPrayer): This function identifies the next scheduled prayer in the sequence (e.g., if missedPrayer is Shacharit, nextAdjoining is Mincha).
        
        IS_NEXT_ADJOINING_PRAYER_TIME_VALID? (i.e., has the time for nextAdjoining prayer arrived, but not yet passed its own window?)
        
        YES:
        
        HAS_MULTIPLE_MISSED? (Are there more than one consecutive missed prayers before nextAdjoining?)
        
        YES: (e.g., Missed Shacharit AND Mincha)
        
        OUTPUT: Pray nextAdjoining prayer twice. First is nextAdjoining חובה (obligatory). Second is make-up for the immediately preceding missed prayer. Earlier missed prayers are unrecoverable. (See 108:14)
        
        NO: (Only one missed prayer, e.g., Shacharit missed)
        
        HANDLE_HOLIDAY_CONDITIONS(missedPrayer, nextAdjoiningPrayer): (Special logic for Shabbat, Rosh Chodesh, Yom Tov – see 108:16-17, 108:20)
        
        If Shabbat/Yom Tov Eve: Pray nextAdjoining twice. First for חובה, second as make-up. (See 108:16)
        
        If Shabbat: Pray nextAdjoining (post-Shabbat) twice. First with Shabbat modifications, second without. (See 108:17)
        
        If Rosh Chodesh: Similar logic to Shabbat eve. (See 108:20, commentary)
        
        Default (Weekday): Pray nextAdjoining twice. First for חובה, second as make-up. (See 108:11, 108:12)
        
        OUTPUT: Pray nextAdjoining prayer twice, with appropriate Holiday/Weekday configurations.
        
        NO: (nextAdjoiningPrayer time has passed)
        
        OUTPUT: No Make-up Available. (See 108:13)
  - NO:
    - OUTPUT: Prayer already fulfilled.

Key State Variables:

missedPrayer: Enum (Shacharit, Mincha, Maariv)
currentTime: Timestamp
prayerStatus: Enum (OK, Erred, Forced, Intentional)
consecutiveMissedCount: Integer
isHoliday: Boolean (Shabbat, RoshChodesh, YomTov)

Two Implementations – Algorithm A vs. Algorithm B

The Rishonim (early commentators) and Acharonim (later commentators) offer slightly different algorithmic approaches to implementing these rules. Let's model them.

Algorithm A: The Rishonim's "Strict Adherence" Model (Implicitly, as reflected in the Shulchan Arukh's initial rulings)

This algorithm focuses on the direct interpretation of the core rules, particularly the concept of the "immediately adjoining prayer." It's like a straightforward imperative programming approach.

Core Logic:

Input: missedPrayer (e.g., Shacharit), currentTime.
Check prayerStatus:
- If Intentional, return NoMakeUp.
- If Erred or Forced:
  - Determine nextAdjoiningPrayer: (Shacharit -> Mincha, Mincha -> Maariv, Maariv -> Shacharit)
  - Check isNextAdjoiningTimeValid(nextAdjoiningPrayer):
    - If FALSE, return NoMakeUp.
    - If TRUE:
      - Check consecutiveMissedCount:
        
        If > 1 (e.g., missed Shacharit and Mincha):
        
        Pray nextAdjoiningPrayer (e.g., Maariv) once for its חובה.
        
        Pray nextAdjoiningPrayer a second time as make-up only for the immediately preceding missed prayer (e.g., if Shacharit and Mincha were missed, the second Maariv is a make-up for Mincha). The earlier missed prayer (Shacharit) has no make-up.
        
        Return PrayTwice(nextAdjoiningPrayer, makeUpFor: previousMissed).
        
        If == 1 (e.g., missed Shacharit):
        
        Handle Holiday Modifiers:
        
        If isShabbatOrYomTovEve(nextAdjoiningPrayer): Pray nextAdjoiningPrayer twice. First for חובה, second as make-up.
        
        If isShabbat(nextAdjoiningPrayer): Pray nextAdjoiningPrayer twice. First with Shabbat modifications (Ata Chonantanu), second without.
        
        If isRoshChodesh(nextAdjoiningPrayer): Similar to Shabbat Eve.
        
        Else (Weekday): Pray nextAdjoiningPrayer twice. First for חובה, second as make-up.
        
        Return PrayTwice(nextAdjoiningPrayer, makeUpFor: missedPrayer).

Example Execution (Algorithm A):

Missed Shacharit.
nextAdjoiningPrayer is Mincha.
isNextAdjoiningTimeValid(Mincha) is true.
consecutiveMissedCount is 1.
It's a weekday.
Output: Pray Mincha twice. The first is the obligatory Mincha. The second is the make-up for Shacharit.

Analysis (Algorithm A):

Pros: Simple, directly maps to the textual rules. Efficient for single missed prayers.
Cons: Can be brittle when dealing with multiple consecutive misses or complex holiday interactions. The rule about "no make-up for the earlier prayer" feels like a hardcoded constraint rather than a derived principle.

Algorithm B: The Acharonim's "Conditional Refinement" Model (incorporating later glosses and explanations)

This algorithm incorporates the nuances and clarifications provided by later commentators like the Magen Avraham and Mishnah Berurah. It's more like an object-oriented approach with refined methods and exception handling. The key refinement is often the concept of praying the make-up prayer "as a voluntary prayer" (בתורת נדבה) when there's a doubt or when the strict חובה prayer doesn't fully resolve the missed obligation.

Core Logic:

Input: missedPrayer, currentTime.
Check prayerStatus:
- If Intentional, return NoMakeUp.
- If Erred or Forced:
  - Determine nextAdjoiningPrayer:
  - Check isNextAdjoiningTimeValid(nextAdjoiningPrayer):
    - If FALSE, return NoMakeUp.
    - If TRUE:
      - Check consecutiveMissedCount:
        
        If > 1:
        
        Pray nextAdjoiningPrayer once for its חובה.
        
        Crucial Acharonim Point: For the second prayer, it's often prayed as a voluntary prayer (בתורת נדבה). This is because the strict חובה might not perfectly "count" as a make-up for an earlier missed prayer, especially if the later prayer itself has specific holiday requirements that were also missed. (See Turei Zahav, Ba'er Hetev on 108:16, Mishnah Berurah on 108:32).
        
        Return PrayTwice(nextAdjoiningPrayer, makeUpType: voluntary, makeUpFor: previousMissed).
        
        If == 1:
        
        Handle Holiday Modifiers:
        
        If isShabbatOrYomTovEve(nextAdjoiningPrayer): Pray nextAdjoiningPrayer twice. First for חובה, second as make-up.
        
        If isShabbat(nextAdjoiningPrayer): Pray nextAdjoiningPrayer twice. First with Shabbat modifications, second without. (See 108:17)
        
        If isRoshChodesh(nextAdjoiningPrayer): Similar to Shabbat Eve.
        
        Else (Weekday):
        
        Acharonim Nuance: If there's doubt about whether the first prayer fully counts, or if the missed חובה prayer was on a special day (like Rosh Chodesh and Ya'aleh V'yavo was missed), the second prayer might be prayed בתורת נדבה. (See Magen Avraham on 108:16, Ba'er Hetev on 108:16).
        
        Return PrayTwice(nextAdjoiningPrayer, makeUpType: defaultOrVoluntary, makeUpFor: missedPrayer).

Example Execution (Algorithm B):

Missed Shacharit and Mincha.
nextAdjoiningPrayer is Maariv.
isNextAdjoiningTimeValid(Maariv) is true.
consecutiveMissedCount is 2.
It's a weekday.
Output: Pray Maariv once for the obligatory Maariv. Pray Maariv a second time as a voluntary prayer (בתורת נדבה) to cover the missed Mincha. The missed Shacharit remains unrecoverable.

Analysis (Algorithm B):

Pros: More robust to edge cases and doubts. The בתורת נדבה (voluntary prayer) mechanism acts as a flexible fallback, ensuring fulfillment in uncertain situations, which is a common characteristic of later halakhic reasoning. It better captures the spirit of "when in doubt, add a layer of caution."
Cons: Slightly more complex to implement due to the makeUpType parameter and the conditions under which it's applied.

Comparative Table: Algorithm A vs. Algorithm B

Feature	Algorithm A (Rishonim-centric)	Algorithm B (Acharonim-integrated)
Core Strategy	Direct mapping of rules to `חובה` make-up.	`חובה` make-up, with `נדבה` as a fallback for ambiguity/doubt.
Multiple Misses	Second prayer is `חובה` make-up for immediately preceding missed.	Second prayer often `נדבה` make-up for immediately preceding missed.
Holiday Nuances	Primarily dictates how to pray the two prayers.	Dictates how and sometimes whether the second prayer is `נדבה`.
Flexibility	Lower. Rules are more rigid.	Higher. `נדבה` provides a buffer for uncertainty.
Complexity	Lower.	Higher.
Example Textual Basis	108:11, 108:12, 108:14	108:11, 108:12, 108:14, 108:16, 108:17, 108:18, Commentary on 108:16.

Edge Cases – Inputs That Break Naïve Logic

Let's test our system with some tricky inputs. These are like malformed API requests that could cause a crash or unexpected output.

Edge Case 1: The "Double Holiday Overlap" Scenario

Input: User misses Mincha prayer on Shabbat afternoon. Shabbat ends, and it's immediately Rosh Chodesh (the new month begins).
Naïve Logic (Algorithm A, without full holiday integration): User should pray the evening prayer twice. The first is for Maariv (obligatory Maariv), the second as a make-up. The first prayer would likely be a weekday Maariv.
Problem: This doesn't account for the fact that the "evening prayer" is Rosh Chodesh Maariv. Also, the missed prayer was Mincha on Shabbat. How do we reconcile this?
Expected Output (Algorithm B's sophistication):
1. First Prayer: Rosh Chodesh Maariv (חובה). This prayer must include the Ya'aleh V'yavo insertion for Rosh Chodesh.
2. Second Prayer: This is the make-up for the missed Shabbat Mincha. According to 108:17, when making up a Shabbat prayer after Shabbat, you separate (Ata Chonantanu) in the first prayer but not the second. However, here the first prayer is already Rosh Chodesh Maariv. The commentary on 108:16 (Magen Avraham, Ba'er Hetev, Mishnah Berurah) discusses this. If one missed Rosh Chodesh Mincha and is praying Rosh Chodesh Maariv twice, the second is a make-up. If Ya'aleh V'yavo was missed in the first, but said in the second, it's fine. If missed in both, or said in first not second, you don't go back. Crucially, the Ba'er Hetev (on 108:16) and Mishnah Berurah (on 108:34) suggest that if it's Rosh Chodesh evening, one will say Ya'aleh V'yavo in the first prayer, thus "profiting" from it. The second prayer, as a make-up for Shabbat Mincha, would be a weekday Maariv, but without the Ata Chonantanu modification (as per 108:17, which implies the first prayer gets the holiday modification when making up a Shabbat prayer). This is a complex interaction. The most robust approach would be:
  - First Prayer: Rosh Chodesh Maariv (חובה + Ya'aleh V'yavo).
  - Second Prayer: Weekday Maariv as a make-up for Shabbat Mincha. Since the first prayer is already a Rosh Chodesh prayer, the second prayer as a make-up for the Shabbat prayer would not include Ata Chonantanu. The commentary on 108:17 states that if Ata Chonantanu is not separated in the first, but separated in the second, the second counts. Here, the first prayer is a different holiday. The prevailing opinion is that the second prayer is a standard weekday make-up. (See Magen Avraham on 108:16).
  - Refined Expected Output: Pray Rosh Chodesh Maariv (with Ya'aleh V'yavo), then pray a second Weekday Maariv as a make-up for the missed Shabbat Mincha.

Edge Case 2: The "Sequential Interruption" Scenario

Input: User intended to pray Shacharit, but got delayed. They then intended to pray Mincha, but also got delayed. They finally get to pray Maariv, but realize they missed both Shacharit and Mincha.
Naïve Logic (Algorithm A): The system would look at nextAdjoiningPrayer for the last missed prayer (Mincha), which is Maariv. It would then pray Maariv twice. The first is the obligatory Maariv, and the second is the make-up for Mincha. It would incorrectly assume the Shacharit make-up is lost.
Problem: The rule in 108:14 is explicit: "There are no make-up prayers other than for the prayer immediately adjoining [i.e. preceding] prayer alone." This implies a cascading failure.
Expected Output (Algorithm A and B agree here):
1. First Prayer: Maariv (חובה).
2. Second Prayer: Maariv as a make-up for the immediately preceding missed prayer, which is Mincha.
3. Result: The missed Shacharit prayer has no make-up. The system correctly discards the earlier missed prayer's make-up opportunity because it was not the "immediately adjoining" missed prayer to the current prayer slot. This is a core constraint in the system design.

Refactor – One Minimal Change to Clarify the Rule

Let's refactor one of the core rules to make it more like a clear, well-documented API. The most complex part is the handling of multiple consecutive missed prayers.

Original Rule (Simplified): If one missed prayer A and then prayer B, and prays prayer C (the next in sequence), C serves as the obligatory prayer, and a second prayer C serves as a make-up for B, but not for A.

Refactored Rule using Pseudocode/Systematic Notation:

FUNCTION MakeUpPrayer(missedPrayer, currentTime):
  IF NOT IsTimeForPrayer(missedPrayer, currentTime):
    RETURN NO_MAKE_UP_AVAILABLE

  IF IsIntentional(missedPrayer):
    RETURN NO_MAKE_UP_AVAILABLE

  // Determine the target prayer slot for the make-up
  targetPrayerSlot = GetNextAdjoiningPrayerSlot(missedPrayer)
  IF NOT IsTimeForPrayer(targetPrayerSlot, currentTime):
    RETURN NO_MAKE_UP_AVAILABLE

  // Identify all prayers missed immediately preceding targetPrayerSlot
  consecutiveMissedPrayers = GetConsecutiveMissedPrayers(missedPrayer, targetPrayerSlot)

  // Special holiday logic applies here... (simplified for this refactor)

  IF Count(consecutiveMissedPrayers) == 1:
    // Single missed prayer
    Pray(targetPrayerSlot, Obligatory)
    Pray(targetPrayerSlot, MakeUpFor = missedPrayer)
  ELSE IF Count(consecutiveMissedPrayers) > 1:
    // Multiple consecutive missed prayers
    // The first prayer in targetPrayerSlot is Obligatory for targetPrayerSlot itself.
    Pray(targetPrayerSlot, Obligatory)

    // The second prayer is a make-up ONLY for the IMMEDIATELY PRECEDING missed prayer.
    // All earlier missed prayers in the sequence have no make-up.
    immediatelyPrecedingMissed = LastElement(consecutiveMissedPrayers)
    Pray(targetPrayerSlot, MakeUpFor = immediatelyPrecedingMissed, MakeUpType = Voluntary) // Often voluntary due to complexity
  
  RETURN SUCCESS

The Minimal Change: Explicitly defining consecutiveMissedPrayers and stating that the make-up is only for the LastElement(consecutiveMissedPrayers) clarifies the cascading failure and the scope of the make-up. The addition of MakeUpType = Voluntary for multiple misses captures the nuance of Algorithm B.

Takeaway

The Shulchan Arukh's laws of make-up prayers are a beautiful example of a complex, yet elegant, system. They're not just a set of rules, but an algorithm designed to maximize the user's ability to connect with the Divine, even after a system interruption.

By framing these sugyot through a systems thinking lens, we can see:

State Management: Tracking missedPrayer, currentTime, and prayerStatus is crucial.
Conditional Logic: The IF-THEN-ELSE structures, especially with nested holiday conditions, are the core of the execution flow.
Error Handling: Intentional omissions and expired prayer windows are treated as unrecoverable errors, while Erred or Forced situations trigger make-up routines.
Algorithm Evolution: The shift from Rishonim to Acharonim shows how a system can be refined. Algorithm B, with its בתורת נדבה mechanism, is a more robust, fault-tolerant version that handles ambiguity better.

Understanding these sugyot as a system helps us appreciate the depth of Halakha and its intricate, yet divinely-inspired, design. Keep debugging, keep praying, and may our spiritual code always compile!

Back to lesson library

derekhlearning.com