When async helps and when it does not in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

When does async improve Django view performance?

Which scenario below best explains when using async views in Django will improve performance?

A When the view waits for slow external APIs or database queries and can release the thread during waiting.

B When the view performs long CPU-heavy calculations without waiting for external resources.

C When the view only renders a simple template with no external calls.

D When the view uses synchronous ORM queries exclusively.

💡 Hint

Think about when releasing the thread during waiting helps.

Async views help when the code waits on external I/O like APIs or databases, allowing other requests to run meanwhile. CPU-heavy or purely synchronous code won't benefit.

❓ component_behavior

intermediate

Output of async Django view with blocking code

What will be the behavior of this async Django view when called multiple times concurrently? ```python from django.http import JsonResponse import time async def my_view(request): time.sleep(2) # blocking call return JsonResponse({'status': 'done'}) ```

Django

from django.http import JsonResponse
import time

async def my_view(request):
    time.sleep(2)  # blocking call
    return JsonResponse({'status': 'done'})

A All requests will be handled concurrently without delay.

B The view will return immediately without waiting.

C The server will raise a SyntaxError due to async with time.sleep.

D Each request will block the server thread for 2 seconds, causing sequential delays.

💡 Hint

Consider what happens when blocking code runs inside async functions.

Using blocking calls like time.sleep inside async views blocks the event loop, causing requests to be handled one after another, not concurrently.

📝 Syntax

advanced

Identify the syntax error in async Django ORM usage

Which option contains the correct syntax for using Django's async ORM method inside an async view? ```python async def get_user(request): user = await User.objects.get(id=1) return JsonResponse({'username': user.username}) ```

Django

async def get_user(request):
    user = await User.objects.get(id=1)
    return JsonResponse({'username': user.username})

A Cannot use await with ORM; must call get() without await in async views.

B Correct as is, Django ORM supports await on get() in async views.

C Must use sync_to_async wrapper around User.objects.get() to await it.

D Must define get_user as a synchronous function to use ORM.

💡 Hint

Check if Django ORM methods are natively async or require wrappers.

Django ORM methods like get() are synchronous and must be wrapped with sync_to_async to be awaited in async views.

❓ state_output

advanced

Effect of async on Django middleware execution order

Given this middleware setup, what is the order of print statements when a request is processed? ```python class SyncMiddleware: def __init__(self, get_response): self.get_response = get_response print('SyncMiddleware init') def __call__(self, request): print('SyncMiddleware before') response = self.get_response(request) print('SyncMiddleware after') return response class AsyncMiddleware: def __init__(self, get_response): self.get_response = get_response print('AsyncMiddleware init') async def __call__(self, request): print('AsyncMiddleware before') response = await self.get_response(request) print('AsyncMiddleware after') return response ``` Middleware order in settings: [SyncMiddleware, AsyncMiddleware]

Django

class SyncMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('SyncMiddleware init')

    def __call__(self, request):
        print('SyncMiddleware before')
        response = self.get_response(request)
        print('SyncMiddleware after')
        return response

class AsyncMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('AsyncMiddleware init')

    async def __call__(self, request):
        print('AsyncMiddleware before')
        response = await self.get_response(request)
        print('AsyncMiddleware after')
        return response

A AsyncMiddleware init, SyncMiddleware init, AsyncMiddleware before, SyncMiddleware before, SyncMiddleware after, AsyncMiddleware after

B SyncMiddleware init, AsyncMiddleware init, SyncMiddleware before, AsyncMiddleware before, AsyncMiddleware after, SyncMiddleware after

C SyncMiddleware init, AsyncMiddleware init, AsyncMiddleware before, SyncMiddleware before, SyncMiddleware after, AsyncMiddleware after

D AsyncMiddleware init, SyncMiddleware init, SyncMiddleware before, AsyncMiddleware before, AsyncMiddleware after, SyncMiddleware after

💡 Hint

Remember middleware __init__ runs on startup, __call__ runs per request in order.

Middleware __init__ runs in order on startup. On request, SyncMiddleware __call__ runs first, then calls AsyncMiddleware __call__, which awaits the next layer. The prints show nested calls accordingly.

🔧 Debug

expert

Debugging async Django view causing server hang

You wrote this async Django view but the server hangs and never responds: ```python from django.http import JsonResponse import asyncio async def slow_view(request): asyncio.sleep(3) return JsonResponse({'status': 'done'}) ``` What is the cause of the hang?

Django

from django.http import JsonResponse
import asyncio

async def slow_view(request):
    asyncio.sleep(3)
    return JsonResponse({'status': 'done'})

A asyncio.sleep is a coroutine and must be awaited; missing await causes the hang.

B asyncio.sleep is blocking and freezes the event loop.

C The view must be synchronous to use sleep.

D JsonResponse cannot be returned from async views.

💡 Hint

Check how to properly use async sleep functions.

asyncio.sleep is a coroutine that must be awaited. Without await, the coroutine is created but not run, causing the view to hang waiting indefinitely.

Practice

1. Which scenario best shows when Django's async features help improve performance?

easy

A. Handling many simultaneous network requests without blocking

B. Performing heavy calculations on the CPU

C. Rendering a simple HTML template synchronously

D. Writing data to a local file synchronously

Solution

1. Step 1: Understand async strengths

   Async in Django helps when tasks involve waiting, like network calls, allowing other tasks to run meanwhile.

2. Step 2: Match scenario to async use

   Handling many network requests fits async well because it avoids waiting and blocking the server.

3. Final Answer:

   Handling many simultaneous network requests without blocking -> Option A

4. Quick Check:

   Async helps with waiting tasks = A [OK]

Hint: Async helps when waiting, not heavy CPU work [OK]

Common Mistakes:

• Thinking async speeds up CPU-heavy tasks
• Assuming async helps synchronous file writes
• Confusing async with faster template rendering

2. Which of the following is the correct way to declare an async view in Django?

easy

A. def my_view(request):

B. async def my_view(request):

C. def async my_view(request):

D. async my_view(request):

Solution

1. Step 1: Recall async function syntax in Python

   Async functions start with the keyword 'async' before 'def'.

2. Step 2: Apply to Django view declaration

   The correct syntax is 'async def my_view(request):' to define an async view.

3. Final Answer:

   async def my_view(request): -> Option B

4. Quick Check:

   Async function syntax = D [OK]

Hint: Async functions start with 'async def' in Python [OK]

Common Mistakes:

• Omitting 'def' after 'async'
• Placing 'async' after 'def'
• Using 'async' without 'def'

3. Consider this Django async view snippet:

async def fetch_data(request):
    data = await some_network_call()
    return JsonResponse({'result': data})

What happens if some_network_call() is a slow network request?

medium

A. The server crashes due to await usage

B. The server blocks and waits until the call finishes

C. The view returns immediately with empty data

D. The server can handle other requests while waiting

Solution

1. Step 1: Understand 'await' in async views

   The 'await' keyword pauses this view but lets the server handle other tasks meanwhile.

2. Step 2: Effect on server behavior

   Because of 'await', the server does not block and can serve other requests during the slow network call.

3. Final Answer:

   The server can handle other requests while waiting -> Option D

4. Quick Check:

   Await allows concurrency = A [OK]

Hint: Await pauses task but frees server for others [OK]

Common Mistakes:

• Thinking await blocks the whole server
• Assuming immediate return without data
• Believing await causes server crash

4. You wrote this async Django view:

async def cpu_task(request):
    result = heavy_calculation()
    return JsonResponse({'value': result})

Why might this cause performance issues?

medium

A. Because heavy_calculation() is synchronous and blocks the event loop

B. Because async views cannot return JsonResponse

C. Because async views must not have return statements

D. Because heavy_calculation() is awaited incorrectly

Solution

1. Step 1: Identify sync call inside async view

   The function heavy_calculation() is synchronous and CPU-heavy, called without await.

2. Step 2: Understand impact on async event loop

   This blocks the async event loop, preventing other tasks from running concurrently, hurting performance.

3. Final Answer:

   Because heavy_calculation() is synchronous and blocks the event loop -> Option A

4. Quick Check:

   Sync CPU work blocks async loop = B [OK]

Hint: Sync CPU tasks block async event loop, causing lag [OK]

Common Mistakes:

• Thinking async views can't return JsonResponse
• Believing return statements are forbidden in async views
• Assuming heavy_calculation() is awaited automatically

5. You want to optimize a Django app that reads many files and processes data. Which approach best uses async to improve performance?

hard

A. Keep everything synchronous to avoid complexity

B. Make all processing CPU-heavy tasks async without changing file reading

C. Make file reading async and process data in small CPU chunks synchronously

D. Use async only for database queries, not file reading or processing

Solution

1. Step 1: Identify async benefits for I/O tasks

   Async helps with waiting tasks like file reading, allowing other tasks to run meanwhile.

2. Step 2: Combine async I/O with sync CPU processing

   Processing CPU-heavy data synchronously in small chunks avoids blocking the event loop too long.

3. Final Answer:

   Make file reading async and process data in small CPU chunks synchronously -> Option C

4. Quick Check:

   Async for I/O, sync for CPU work = C [OK]

Hint: Use async for waiting tasks, sync for CPU work [OK]

Common Mistakes:

• Making CPU-heavy tasks async without benefit
• Ignoring async for file reading
• Avoiding async due to complexity fears