Meetup in 8th: Complete Solution & Deep Dive Guide

---

Mastering Date Logic in 8th: The Complete Guide to Solving the Meetup Problem

Calculating specific dates, like the "third Tuesday of the month," is a common programming challenge that tests your understanding of date manipulation and logical branching. In 8th, this problem is solved elegantly using its stack-based nature and powerful date utilities, allowing you to build a robust scheduler logic from scratch.

---

Ever found yourself staring at a calendar, trying to manually figure out a recurring event? "We need to meet on the fourth Thursday of every month," your colleague says. Your mind starts racing: you find the first of the month, figure out what day of the week it is, and then start counting forward. It's a surprisingly complex mental exercise, prone to error, especially when dealing with tricky cases like the "last Sunday" or the mysterious "teenth Wednesday."

This exact challenge is a cornerstone of many real-world applications, from event schedulers and booking systems to financial software that calculates deadlines on specific weekdays. If you've ever felt the friction of implementing this logic, you're in the right place. This guide will walk you through the entire process of solving this "Meetup" problem, transforming a confusing task into a clear, logical algorithm. We will dissect an expert solution from the exclusive kodikra.com learning path, providing a deep, line-by-line analysis in the 8th programming language.

What Exactly Is the Meetup Date Calculation Problem?

At its core, the Meetup problem is a specification for a function or program that finds the exact calendar date for a recurring event based on a set of descriptive rules. It's a classic algorithm challenge that moves beyond simple date arithmetic and into the realm of contextual date logic.

The function must accept the following inputs:

• Year: An integer representing the year (e.g., 2023).
• Month: An integer representing the month (e.g., 1 for January, 12 for December).
• Day of the Week: A string representing the target day (e.g., "Monday", "Tuesday").
• Week Specifier: A string that describes which occurrence of the weekday to find.

The week specifier is the most interesting part of the problem, with six distinct possibilities:

• 'first': The first occurrence of the weekday in the month.
• 'second': The second occurrence of the weekday in the month.
• 'third': The third occurrence of the weekday in the month.
• 'fourth': The fourth occurrence of the weekday in the month.
• 'last': The final occurrence of the weekday in the month.
• 'teenth': The one occurrence of the weekday that falls on a day number ending in "-teen" (i.e., the 13th, 14th, 15th, 16th, 17th, 18th, or 19th).

The program's output must be a precise date object or structure representing the calculated day. For instance, given (2023, 5, "Wednesday", "teenth"), the correct output would be the date for May 17th, 2023.

---

Why This Challenge Is a Crucial Skill for Developers

You might wonder why a seemingly simple calendar problem is so important. The logic required to solve the Meetup challenge is foundational to a vast array of software applications. Mastering it demonstrates a robust understanding of algorithms, date/time libraries, and edge-case handling.

This logic appears everywhere in the real world:

• Event & Meeting Schedulers: Think Google Calendar or Outlook. "Monthly team sync on the second Tuesday" is a direct implementation of this problem.
• E-commerce & Subscription Services: "Your subscription renews on the first Monday of each month."
• Financial Systems: Calculating payroll dates (e.g., "payday is the last Friday of the month") or options expiration dates in trading ("options expire on the third Friday").
• Automation & Cron Jobs: Scheduling automated tasks or reports to run on specific, recurring days.
• Content Management Systems: Planning content publication schedules like "publish a new blog post on the first and third Wednesday of the month."

For developers using 8th, a stack-based language, this problem is an excellent exercise. It forces you to think about data flow, breaking down a complex problem into smaller, reusable functions (or "words" in 8th terminology) that manipulate data on the stack. It's a perfect showcase of 8th's concise and powerful nature for logical operations. For a deeper dive into the language itself, explore our complete guide to 8th programming.

---

How to Approach the Problem: The Core Logic

Before diving into the 8th code, let's establish a universal, language-agnostic algorithm. No matter the language, the core steps remain the same. We need to find a starting point and then calculate an offset.

Step 1: Find the First Day of the Month

Everything starts here. Given a year and a month, our first task is to determine what day of the week the 1st falls on. For example, May 1st, 2023, was a Monday.

Step 2: Calculate the Date of the First Target Weekday

Once we know the day of the week for the 1st, we can find the date of the first occurrence of our target weekday. If the 1st is a Monday and we're looking for the first Wednesday, we simply add 2 days. If the 1st is a Friday and we're looking for the first Tuesday, we need to calculate the days remaining until the next Tuesday.

Step 3: Apply the Week Specifier

This is where the different rules come into play. Let's say we found the first Thursday of the month is the 4th.

• For 'first', our answer is the 4th.
• For 'second', we add 7 days: 4 + 7 = 11th.
• For 'third', we add 14 days: 4 + 14 = 18th.
• For 'fourth', we add 21 days: 4 + 21 = 25th.

The 'last' and 'teenth' cases are special and require their own logic, which we'll explore in detail.

This general process can be visualized with a simple flow diagram.

    ● Start (Year, Month, Weekday, Nth)
    │
    ▼
  ┌──────────────────────────┐
  │ Get Date of 1st of Month │
  └────────────┬─────────────┘
               │
               ▼
  ┌──────────────────────────┐
  │ Find Day-of-Week for 1st │
  └────────────┬─────────────┘
               │
               ▼
  ┌──────────────────────────┐
  │ Calculate Offset to find │
  │ the 1st Target Weekday   │
  └────────────┬─────────────┘
               │
               ▼
  ┌──────────────────────────┐
  │ Date = (1st Target Date) │
  │      + (N-1) * 7 days    │
  └────────────┬─────────────┘
               │
               ▼
    ● End (Resulting Date)

---

The 8th Solution: A Detailed Code Walkthrough

Now, let's analyze the elegant solution provided in the kodikra.com 8th module. This code leverages the date/utils library and defines a series of helper words to solve the problem in a clean, functional style. We will break it down piece by piece.

The Complete Code

Here is the full solution code we will be dissecting.

needs date/utils \ This is a workaround for a known issue

: first-dow \ d dow -- d
  d-dow swap d:/ 2 1 a:! d:join -1 d:+ swap d:next-dow ;

: >dow \ s -- n
  { "Monday": ' d:Mon, "Tuesday": ' d:Tue, "Wednesday": ' d:Wed, 
    "Thursday": ' d:Thu, "Friday": ' d:Fri, "Saturday": ' d:Sat, 
    "Sunday": ' d:Sun } swap caseof ;

: >day \ d -- n
  d:/ 2 a:_@ ;

: first-day-of-month \ n n -- d
  1 a:! d:new ;

: last-day-of-month \ n n -- d
  d:days-in-month a:! d:new ;

: teenth \ d -- d
  begin dup >day 13 < while 7 d:+ repeat
  dup >day 19 > if 7 d:- then ;

: meetup \ n n s s -- d
  >dow                     \ convert weekday string to a number
  swap >r                  \ store it on the return stack
  first-day-of-month r>     \ get 1st day of month, retrieve weekday num
  first-dow                \ find the date of the first target weekday
  
  { "first":  ' nip,
    "second": ' 7 d:+,
    "third":  ' 14 d:+,
    "fourth": ' 21 d:+,
    "last":   ' begin dup 7 d:+ swap last-day-of-month d:> if drop exit then swap repeat,
    "teenth": ' teenth
  } swap caseof ;

Part 1: Helper Words & Setup

Good 8th code is built on small, reusable words. This solution is no exception.

needs date/utils

This line is crucial. It imports the necessary library for all date and time operations. The comment notes a workaround for a specific issue, which is good practice for maintainability.

: >dow \ s -- n

This word converts a weekday string (like "Monday") into its corresponding numeric representation from the date library (d:Mon, etc.).

• \ s -- n is a stack effect comment: it takes a string (s) and leaves a number (n).
• { ... } defines a hashmap or dictionary.
• swap caseof takes the input string, swaps it with the map, and performs a lookup, executing the code associated with the key. In this case, it just pushes the constant like d:Mon onto the stack.

: >day \ d -- n

This is a simple utility to extract the day number (1-31) from a full date object.

• d:/ explodes a date object into its components (year, month, day, etc.) on the stack.
• 2 a:_@ accesses the element at index 2 of the resulting array, which is the day.

: first-day-of-month \ n n -- d and : last-day-of-month \ n n -- d

These two words create a date object for the first or last day of a given month and year.

• first-day-of-month takes a year and month, pushes 1 onto the stack, and uses d:new to create the date for the 1st.
• last-day-of-month is cleverer. It uses d:days-in-month to determine the number of days in that specific month (handling leap years automatically!) and then creates a date for that day.

Part 2: The Core Logic Words

: first-dow \ d dow -- d

This is one of the most important helpers. Given a starting date (d) and a target day-of-the-week number (dow), it finds the date of the *next* occurrence of that weekday, including the starting date itself.

• d-dow gets the day-of-week number for the input date.
• swap d:/ 2 1 a:! d:join is a complex but efficient way to create a date object for the 1st of the month from the input date.
• -1 d:+ goes back one day to the end of the previous month. This is a trick to ensure the subsequent search starts correctly.
• swap d:next-dow is the key function. It takes a date and a day-of-week number and finds the very next date that matches that day of the week.

: teenth \ d -- d

This word implements the special logic for the "teenth" case. It takes a date (which should be the first occurrence of the target weekday) and finds the one that falls between the 13th and 19th.

• begin ... while ... repeat is a loop. It keeps adding 7 days (7 d:+) as long as the day number (dup >day) is less than 13 (13 <).
• This loop effectively fast-forwards the date until it's on or after the 13th.
• The final check, dup >day 19 > if 7 d:- then, is a correction. If the loop overshot and went past the 19th, it subtracts 7 days to get back into the "teenth" range. This handles cases where the first occurrence is late in the month.

The logic for the "teenth" case deserves its own visualization.

    ● Start (Date of 1st Target Weekday)
    │
    ▼
  ┌──────────────────────────┐
  │ Get Day Number (e.g., 4) │
  └────────────┬─────────────┘
               │
               ▼
  ◆ Is Day Number < 13?
 ╱                           ╲
Yes                         No
 │                           │
 ▼                           ▼
┌──────────────────┐     (Proceed to next check)
│ Add 7 days to Date │
└─────────┬────────┘
          │
          └─────────── Loop back to check ◀───
                               │
                               ▼
                   ◆ Is Day Number > 19?
                  ╱                       ╲
                 Yes                     No
                  │                       │
                  ▼                       ▼
           ┌──────────────────┐    (Date is correct)
           │ Subtract 7 days  │         │
           └─────────┬────────┘         │
                     │                  │
                     └────────┬─────────┘
                              │
                              ▼
                       ● End (Teenth Date)

Part 3: The Main Word - meetup

: meetup \ n n s s -- d

This is the main entry point that ties everything together. The stack comment shows it takes year, month, weekday string, and week specifier string.

1. >dow: Converts the weekday string (e.g., "Tuesday") to its number.
2. swap >r: Swaps the weekday number with the week specifier string ("third") and temporarily stores the weekday number on the return stack using >r. This is a common 8th idiom to keep the main stack clean.
3. first-day-of-month r>: Creates the date for the 1st of the month, then retrieves the weekday number from the return stack with r>. The stack now has: ( date_of_1st, weekday_num ).
4. first-dow: Calls our helper to find the date of the very first occurrence of our target weekday in the month. The stack now holds this single date object.
5. { ... } swap caseof: This is the final dispatch. It uses the week specifier string (which is now on top of the stack) to look up the correct action in the hashmap.

Let's look at the actions in the map:

• "first": ' nip,: Does nothing. nip drops the second item on the stack (the string "first"), leaving our calculated date.
• "second": ' 7 d:+,: Adds 7 days to the first occurrence.
• "third": ' 14 d:+,: Adds 14 days.
• "fourth": ' 21 d:+,: Adds 21 days.
• "teenth": ' teenth,: Calls our special teenth word to perform the teenth logic.
• "last": ' begin ... repeat,: This is a clever loop to find the last occurrence. It starts with the first occurrence, keeps adding 7 days, and checks if the new date is past the end of the month (last-day-of-month d:>). It continues until it goes too far, then uses drop and exit to leave the previous, valid date on the stack.

---

Analysis of the Solution: Pros & Cons

Every implementation has trade-offs. This particular solution from the kodikra.com curriculum is highly idiomatic for 8th, but it's useful to analyze its strengths and potential drawbacks.

Pros

Cons

Highly Reusable: The code is broken into small, single-purpose words (>dow, first-dow) that can be used in other date-related programs. Efficient: It avoids brute-force iteration through every day of the month. It calculates the first occurrence and then jumps forward by weeks. Idiomatic 8th: The use of the stack, return stack (>r/r>), and caseof for dispatch is excellent, idiomatic 8th programming. Readable (for 8th devs): Once you are familiar with stack-based thinking, the data flow is very clear and linear.

High Learning Curve: For developers new to stack-based languages, the code can be dense and difficult to trace without understanding stack effects. Library Dependency: The solution is entirely dependent on the date/utils library. Any changes or bugs in that library will directly affect this code. Implicit State: The state is managed entirely on the stack. A small mistake (like forgetting a swap or drop) can lead to hard-to-debug errors.

---

Frequently Asked Questions (FAQ)

1. What exactly does "teenth" mean in this context?

"Teenth" refers to the single occurrence of a specific weekday within a month that falls on a day numbered from 13 to 19, inclusive. For example, the "teenth Thursday" is the Thursday that lands on the 13th, 14th, 15th, 16th, 17th, 18th, or 19th of the month. There will always be exactly one of each weekday in this seven-day range.

2. How does this 8th code handle leap years?

The code handles leap years automatically and correctly because it relies on the date/utils library. The word d:days-in-month, used in the last-day-of-month helper, is aware of the rules for leap years. When asked for the number of days in February of a leap year, it will correctly return 29.

3. Why is 8th a stack-based language and how does that impact the code?

8th is a concatenative, stack-based language inspired by Forth. Instead of using named variables and passing them as arguments to functions, operations work directly on a data stack. Words (functions) pop values off the stack, compute, and push results back on. This leads to very concise, point-free code but requires the programmer to mentally track the state of the stack at all times. The meetup word is a prime example, where data is passed implicitly from one word to the next on the stack.

4. Could this logic be adapted to find something like the "second-to-last" Friday?

Yes, absolutely. You would first find the date of the "last" Friday using the existing logic. Once you have that date object, you would simply use the date library's subtraction function (like 7 d:-) to subtract 7 days from it. This would give you the date of the second-to-last Friday.

5. What is the purpose of the `swap >r` and `r>` pattern in the `meetup` word?

This is a common and powerful idiom in stack-based languages for temporarily storing a value. The main data stack is used for active computation. By moving a value to the return stack (>r), it gets it out of the way while other operations happen. Then, when it's needed again, r> retrieves it. In meetup, it's used to hold the target weekday number while the code calculates the first day of the month.

6. Are there alternatives to the `caseof` structure for handling the different week specifiers?

While caseof is very clean for this kind of dispatch, you could also use a series of if/then statements. However, that would be much more verbose and less efficient. The caseof structure is specifically designed for this pattern and is considered the best practice in 8th for mapping keys to actions.

---

Conclusion and Future-Proofing

We have journeyed from the conceptual definition of the Meetup problem to a deep, line-by-line analysis of a professional-grade solution in the 8th programming language. You've learned how to break down the problem into logical steps, leverage a date library, and structure the solution using small, reusable words—the hallmark of a skilled 8th developer.

The core takeaway is that complex date logic can be tamed by establishing a reliable starting point (the first of the month) and then applying calculated, predictable offsets. The special cases, like 'last' and 'teenth', simply require their own tailored algorithms. As you continue your programming journey, remember that the principles of date and time manipulation—handling time zones, durations, and periods—are critical, and this kodikra module provides an excellent foundation.

This problem is a fantastic stepping stone. To continue building your expertise, we encourage you to explore the rest of the 8th learning roadmap, where you'll tackle even more interesting and practical challenges.

Disclaimer: All code and examples are based on the 8th language environment and its `date/utils` library as of the current stable version. Future language updates may introduce changes to function names or behavior.

---

Published by Kodikra — Your trusted 8th learning resource.