YAGNI (You Aren't Gonna Need It) in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to apply the YAGNI principle by avoiding unnecessary features.

LLD

if user_needs_feature:
    implement_feature()
else:
    [1]

Drag options to blanks, or click blank then click option'

Awrite_complex_logic()

Bdo_nothing()

Cadd_extra_code()

Doptimize_prematurely()

Attempts:

3 left

💡 Hint

Common Mistakes

Adding code for features not currently needed.

YAGNI means you should do nothing if the feature is not needed yet.

2fill in blank

medium

Complete the code to follow YAGNI by not adding unused parameters.

LLD

def process_data(data[1]):
    # process data
    pass

Drag options to blanks, or click blank then click option'

A, config

B, required_param

C, data_format

D, unused_param

Attempts:

3 left

💡 Hint

Common Mistakes

Adding parameters that are never used in the function.

Only include required_param which is necessary; avoid unused parameters.

3fill in blank

hard

Fix the error in the design by removing the unnecessary caching layer as per YAGNI.

LLD

class DataFetcher:
    def fetch(self):
        [1]
        # unnecessary cache layer removed

Drag options to blanks, or click blank then click option'

Areturn self.database.query()

Breturn self.cache.get_data()

Creturn self.cache.refresh()

Dreturn self.cache.clear()

Attempts:

3 left

💡 Hint

Common Mistakes

Using cache methods when cache is not required.

YAGNI suggests removing unused cache; fetch directly from database.

4fill in blank

hard

Fill both blanks to implement a simple feature without extra complexity, following YAGNI.

LLD

def calculate_total(items):
    total = 0
    for item in items:
        total [1] item.price
    return total [2] discount

Drag options to blanks, or click blank then click option'

A+=

B-=

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication or subtraction unnecessarily.

Use += to add prices and + to add discount simply, avoiding unnecessary complexity.

5fill in blank

hard

Fill all three blanks to create a minimal class design that avoids unnecessary features, following YAGNI.

LLD

class User:
    def __init__(self, [1], [2]):
        self.name = [3]
        self.email = [4]

Drag options to blanks, or click blank then click option'

Aname

Bemail

Cpassword

Daddress

Attempts:

3 left

💡 Hint

Common Mistakes

Adding unnecessary attributes in the constructor.

Only include name and email in constructor to keep design simple and avoid unused features.

Practice

1. What does the YAGNI principle primarily encourage in system design?

easy

A. Build only features you currently need

B. Plan and build all possible future features

C. Add complex layers for scalability upfront

D. Write extra code for potential edge cases

Solution

1. Step 1: Understand YAGNI meaning

   YAGNI stands for "You Aren't Gonna Need It" and advises to avoid building features before they are necessary.

2. Step 2: Match principle to options

   Build only features you currently need matches the idea of building only what is needed now, while others suggest building for future or complexity.

3. Final Answer:

   Build only features you currently need -> Option A

4. Quick Check:

   YAGNI = Build only what you need now [OK]

Hint: YAGNI means avoid future guesswork, build now only [OK]

Common Mistakes:

• Thinking YAGNI means planning for all future needs
• Confusing YAGNI with over-engineering
• Assuming YAGNI discourages any planning

2. Which of the following is the correct way to apply YAGNI when designing a new feature in a system?

easy

A. Add detailed logging for every possible error before deployment

B. Design the database schema to handle all future data types

C. Write unit tests for features you plan to add later

D. Implement only the core functionality needed for the feature now

Solution

1. Step 1: Identify core YAGNI practice

   YAGNI advises to implement only what is necessary now, avoiding premature additions.

2. Step 2: Evaluate options for current need focus

   Implement only the core functionality needed for the feature now focuses on core functionality now, while others add future or unnecessary work.

3. Final Answer:

   Implement only the core functionality needed for the feature now -> Option D

4. Quick Check:

   YAGNI = Build core now, skip extras [OK]

Hint: Focus on core feature first, skip extras [OK]

Common Mistakes:

• Adding features or tests for future needs
• Over-engineering database for unknown data
• Writing unnecessary logs before real errors occur

3. Consider this scenario: A team adds a caching layer anticipating high traffic, but the system never reaches that load. What does this violate in terms of YAGNI?

medium

A. They avoided unnecessary complexity

B. They followed YAGNI by preparing for future needs

C. They built a feature they didn't need yet

D. They simplified the system by adding cache

Solution

1. Step 1: Analyze the caching layer addition

   The team added caching before it was needed, anticipating future load.

2. Step 2: Relate to YAGNI principle

   YAGNI discourages building features before they are actually needed, so this is a violation.

3. Final Answer:

   They built a feature they didn't need yet -> Option C

4. Quick Check:

   YAGNI violation = building unneeded features [OK]

Hint: Building features before need breaks YAGNI [OK]

Common Mistakes:

• Thinking preparing for future is YAGNI
• Confusing simplification with premature optimization
• Assuming caching always simplifies system

4. A developer added a complex permission system anticipating many user roles, but the product currently has only one role. What is the main issue here related to YAGNI?

medium

A. The developer ignored YAGNI by adding unnecessary complexity

B. The permission system is too simple for current needs

C. The system is scalable and follows YAGNI

D. The product requires multiple roles immediately

Solution

1. Step 1: Identify the developer's action

   The developer added a complex system for roles not currently needed.

2. Step 2: Connect to YAGNI principle

   YAGNI advises against adding complexity before it's necessary, so this is a violation.

3. Final Answer:

   The developer ignored YAGNI by adding unnecessary complexity -> Option A

4. Quick Check:

   Unneeded complexity violates YAGNI [OK]

Hint: Avoid complexity until it's truly needed [OK]

Common Mistakes:

• Assuming scalability means following YAGNI
• Believing all future roles must be planned now
• Confusing simple with insufficient

5. You are designing a messaging system. You consider adding encryption support now, but the current users do not require it. According to YAGNI, what should you do?

hard

A. Implement encryption now to avoid future rework

B. Skip encryption for now and add it when users need it

C. Design the system assuming all messages are encrypted

D. Build a complex key management system upfront

Solution

1. Step 1: Understand current user needs

   Users do not require encryption now, so it is not immediately necessary.

2. Step 2: Apply YAGNI principle to design decision

   YAGNI advises to avoid building features before they are needed, so skip encryption now.

3. Final Answer:

   Skip encryption for now and add it when users need it -> Option B

4. Quick Check:

   YAGNI = build features only when needed [OK]

Hint: Add features only when users actually need them [OK]

Common Mistakes:

• Building features just to avoid future work
• Assuming all users need encryption immediately
• Over-engineering system upfront