Go Gin HTML Template chevron_right Advanced Template Features and Functions

Advanced Template Features and Functions

calendar_today schedule 14 min read

Learning Objectives: By the end of this lesson, you will be able to:

  • Utilize built-in template functions effectively
  • Create custom template functions for specific needs
  • Implement template caching and performance optimization
  • Handle complex data structures and nested templates

1. Welcome and Introduction (5 minutes)

Icebreaker Activity

Have you ever used Excel and wondered how functions like SUM(), IF(), and VLOOKUP() make complex calculations so easy? Template functions work similarly - they’re pre-built tools that transform and manipulate data directly within your templates, making complex operations simple and readable.

Advanced template features unlock the full potential of Go’s template system, allowing you to build sophisticated web applications with clean, maintainable code. Today we’ll explore the powerful function system, custom extensions, and performance optimization techniques that professional developers use in production applications.

Lesson Overview

  • Duration: 3-4 hours
  • Prerequisites: Lessons 1-3 completed (Gin basics, template syntax, layouts)
  • Materials Needed: Go development environment, previous lesson code, profiling tools

2. Learning Objectives and Session Outline (5 minutes)

What We’ll Cover Today:

  1. Built-in Function Mastery - Comprehensive guide to Go’s template functions
  2. Custom Function Development - Creating specialized functions for your needs
  3. Performance Optimization - Template caching and compilation strategies
  4. Security Best Practices - XSS prevention and safe data handling
  5. Advanced Patterns - Complex data manipulation and template composition

Success Criteria:

By the end of this session, you should be able to create sophisticated templates with custom functionality, optimize template performance for production use, and implement secure template practices that protect against common vulnerabilities.

3. Foundation Knowledge (15-20 minutes)

Core Concepts

Template Function Architecture

Template functions in Go are methods that can be called from within templates to transform, format, or manipulate data. Go provides extensive built-in functions, and you can create custom functions to extend template capabilities for your specific needs.

Real-World Analogy: Template functions are like tools in a craftsman’s workshop. Just as a carpenter has specialized tools for cutting, shaping, and joining wood, template functions provide specialized capabilities for formatting dates, manipulating strings, performing calculations, and transforming data.

Why This Matters: Functions keep templates clean and focused on presentation while providing powerful data manipulation capabilities. They enable complex logic without cluttering template code and promote reusability across multiple templates.

Template Performance and Caching

Template performance becomes critical in high-traffic applications. Understanding compilation, caching, and optimization strategies ensures your templates can handle thousands of requests per second efficiently.

Real-World Analogy: Template caching is like a restaurant’s mise en place - preparing and organizing everything in advance so that during busy service, chefs can quickly assemble dishes without starting from scratch each time.

Why This Matters: Proper template optimization can improve application response times by 10x or more, reduce server resource usage, and provide better user experience even under heavy load.

Security in Template Systems

Template security involves preventing XSS attacks, handling user input safely, and ensuring that dynamic content doesn’t compromise application security. Go’s html/template package provides automatic escaping, but understanding when and how to use it properly is crucial.

Key Terminology

  • Built-in Functions: Pre-provided functions like len, index, range, printf
  • Custom Functions: User-defined functions registered with the template engine
  • Function Map: A registry of functions available to templates
  • Pipeline: Chaining functions together using the | operator
  • Template Compilation: Converting template text into executable bytecode
  • Context Function: Functions that receive the template’s data context
  • HTML Escaping: Automatically converting dangerous characters to safe HTML entities

4. Detailed Explanation and Examples (25-30 minutes)

Built-in Template Functions Deep Dive

Go’s template system includes powerful built-in functions organized into several categories:

String Manipulation Functions

  • printf: C-style string formatting with type-safe operations
  • print and println: Basic output functions with automatic spacing
  • String comparison: Built-in comparison operators for conditional logic

Mathematical and Logical Functions

  • Arithmetic: add, sub, mul, div for mathematical operations
  • Comparison: eq, ne, lt, le, gt, ge for conditional logic
  • Logical: and, or, not for boolean operations

Data Structure Functions

  • len: Get length of slices, maps, strings, and arrays
  • index: Access elements by index in slices and arrays
  • slice: Extract sub-slices from larger slices
  • range: Iterate over collections with key-value pairs

Control Flow Functions

  • if: Conditional rendering with complex boolean expressions
  • with: Change template context for cleaner nested access
  • range: Iteration with support for keys, values, and indexes

Custom Function Development Patterns

Creating custom functions follows established patterns that ensure compatibility with Go’s template system:

Simple Value Functions

Functions that take input parameters and return formatted output:

func formatCurrency(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

Context-Aware Functions

Functions that access the current template context for complex operations:

func isCurrentUser(userID int, context interface{}) bool {
    if data, ok := context.(map[string]interface{}); ok {
        if currentUser, exists := data["currentUser"]; exists {
            // Implementation details...
        }
    }
    return false
}

Data Transformation Functions

Functions that manipulate data structures for template consumption:

func groupByCategory(items []Product) map[string][]Product {
    groups := make(map[string][]Product)
    for _, item := range items {
        groups[item.Category] = append(groups[item.Category], item)
    }
    return groups
}

Template Performance Optimization Strategies

Precompilation and Caching

Template precompilation involves parsing and compiling templates at application startup rather than on each request. This eliminates parsing overhead and enables better error detection.

Memory Management

Efficient memory usage in templates involves:

  • Reusing template instances across requests
  • Minimizing temporary object creation
  • Using streaming output for large responses
  • Implementing proper garbage collection patterns

Concurrency Considerations

Template engines must handle concurrent access safely while maintaining performance. This involves understanding template instance sharing, data race prevention, and thread-safe function implementation.

5. Live Coding Demonstration (20-25 minutes)

Example 1: Comprehensive Built-in Function Usage

package main

import (
    "fmt"
    "html/template"
    "net/http"
    "sort"
    "strings"
    "time"
    
    "github.com/gin-gonic/gin"
)

// Product represents an e-commerce product
type Product struct {
    ID          int       `json:"id"`
    Name        string    `json:"name"`
    Price       float64   `json:"price"`
    Category    string    `json:"category"`
    Description string    `json:"description"`
    InStock     bool      `json:"in_stock"`
    Rating      float64   `json:"rating"`
    Reviews     int       `json:"reviews"`
    CreatedAt   time.Time `json:"created_at"`
    Tags        []string  `json:"tags"`
}

// User represents application user
type User struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email"`
    Role     string `json:"role"`
    Premium  bool   `json:"premium"`
}

func main() {
    r := gin.Default()
    
    // Register custom template functions
    r.SetFuncMap(template.FuncMap{
        "formatCurrency": formatCurrency,
        "formatDate":     formatDate,
        "truncate":       truncate,
        "calculateDiscount": calculateDiscount,
        "isAdmin":        isAdmin,
        "contains":       strings.Contains,
        "title":          strings.Title,
        "upper":          strings.ToUpper,
        "lower":          strings.ToLower,
        "join":           strings.Join,
        "split":          strings.Split,
        "multiply":       multiply,
        "percentage":     percentage,
        "dict":           dict,
    })
    
    r.LoadHTMLGlob("templates/*")
    
    r.GET("/products", productsHandler)
    r.GET("/dashboard", dashboardHandler)
    
    r.Run(":8080")
}

// Custom template functions
func formatCurrency(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

func formatDate(date time.Time, format string) string {
    switch format {
    case "short":
        return date.Format("Jan 2, 2006")
    case "long":
        return date.Format("January 2, 2006 at 3:04 PM")
    case "relative":
        now := time.Now()
        diff := now.Sub(date)
        if diff < time.Hour {
            return fmt.Sprintf("%d minutes ago", int(diff.Minutes()))
        } else if diff < 24*time.Hour {
            return fmt.Sprintf("%d hours ago", int(diff.Hours()))
        } else {
            return fmt.Sprintf("%d days ago", int(diff.Hours()/24))
        }
    default:
        return date.Format("2006-01-02")
    }
}

func truncate(text string, length int) string {
    if len(text) <= length {
        return text
    }
    return text[:length] + "..."
}

func calculateDiscount(price, discountPercent float64) float64 {
    return price * (1 - discountPercent/100)
}

func isAdmin(user User) bool {
    return user.Role == "admin"
}

func multiply(a, b float64) float64 {
    return a * b
}

func percentage(part, whole float64) float64 {
    if whole == 0 {
        return 0
    }
    return (part / whole) * 100
}

// Do not register a general string -> template.HTML helper: it bypasses
// html/template's contextual escaping for any untrusted input.

func dict(values ...interface{}) map[string]interface{} {
    dict := make(map[string]interface{})
    for i := 0; i < len(values); i += 2 {
        if i+1 < len(values) {
            dict[values[i].(string)] = values[i+1]
        }
    }
    return dict
}

func productsHandler(c *gin.Context) {
    products := []Product{
        {
            ID: 1, Name: "Premium Laptop", Price: 1299.99, Category: "Electronics",
            Description: "High-performance laptop with advanced features", InStock: true,
            Rating: 4.8, Reviews: 156, CreatedAt: time.Now().AddDate(0, -2, -15),
            Tags: []string{"laptop", "premium", "performance"},
        },
        {
            ID: 2, Name: "Wireless Headphones", Price: 199.99, Category: "Electronics",
            Description: "Noise-canceling wireless headphones", InStock: false,
            Rating: 4.5, Reviews: 89, CreatedAt: time.Now().AddDate(0, -1, -8),
            Tags: []string{"audio", "wireless", "noise-canceling"},
        },
        {
            ID: 3, Name: "Coffee Maker", Price: 79.99, Category: "Home",
            Description: "Programmable drip coffee maker", InStock: true,
            Rating: 4.2, Reviews: 234, CreatedAt: time.Now().AddDate(0, 0, -5),
            Tags: []string{"coffee", "kitchen", "programmable"},
        },
    }
    
    currentUser := User{
        ID: 1, Name: "John Doe", Email: "john@example.com",
        Role: "customer", Premium: true,
    }
    
    c.HTML(http.StatusOK, "products.html", gin.H{
        "title":       "Product Catalog",
        "products":    products,
        "currentUser": currentUser,
        "categories":  []string{"Electronics", "Home", "Sports", "Books"},
        "totalProducts": len(products),
        "discountPercent": 15.0,
    })
}

func dashboardHandler(c *gin.Context) {
    stats := map[string]interface{}{
        "totalSales":    125430.50,
        "totalOrders":   1567,
        "activeUsers":   892,
        "conversionRate": 3.4,
        "avgOrderValue": 79.99,
    }
    
    recentOrders := []map[string]interface{}{
        {"id": 1001, "customer": "Alice Smith", "amount": 159.99, "status": "shipped"},
        {"id": 1002, "customer": "Bob Johnson", "amount": 89.50, "status": "processing"},
        {"id": 1003, "customer": "Carol Williams", "amount": 234.75, "status": "delivered"},
    }
    
    currentUser := User{
        ID: 1, Name: "Admin User", Email: "admin@example.com",
        Role: "admin", Premium: true,
    }
    
    c.HTML(http.StatusOK, "dashboard.html", gin.H{
        "title":        "Admin Dashboard",
        "stats":        stats,
        "recentOrders": recentOrders,
        "currentUser":  currentUser,
    })
}

Example 2: Advanced Template with Custom Functions

Create templates/products.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.title}}</title>
    <style>
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
        .container { max-width: 1200px; margin: 0 auto; }
        .header { background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        .products-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }
        .product-card { background: white; border-radius: 8px; padding: 20px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); transition: transform 0.2s; }
        .product-card:hover { transform: translateY(-2px); }
        .product-name { font-size: 1.2rem; font-weight: bold; margin-bottom: 10px; color: #333; }
        .product-price { font-size: 1.5rem; font-weight: bold; color: #e74c3c; margin: 10px 0; }
        .product-rating { color: #f39c12; margin: 5px 0; }
        .product-description { color: #666; margin: 10px 0; }
        .product-tags { margin: 10px 0; }
        .tag { background: #3498db; color: white; padding: 3px 8px; border-radius: 12px; font-size: 0.8rem; margin-right: 5px; }
        .out-of-stock { opacity: 0.6; }
        .discount-badge { background: #e74c3c; color: white; padding: 5px 10px; border-radius: 4px; font-size: 0.9rem; }
        .category-filter { margin: 20px 0; }
        .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 20px; }
        .stat-card { background: #3498db; color: white; padding: 15px; border-radius: 8px; text-align: center; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>{{.title}}</h1>
            
            {{/* User greeting with conditional logic */}}
            {{if .currentUser}}
                <p>Welcome back, {{.currentUser.Name | title}}! 
                {{if .currentUser.Premium}}
                    <span style="background: gold; color: black; padding: 2px 6px; border-radius: 3px;">PREMIUM</span>
                {{end}}
                </p>
            {{end}}
            
            {{/* Statistics using custom functions */}}
            <div class="stats">
                <div class="stat-card">
                    <h3>Total Products</h3>
                    <p>{{.totalProducts}}</p>
                </div>
                <div class="stat-card">
                    <h3>Categories</h3>
                    <p>{{len .categories}}</p>
                </div>
                {{if .discountPercent}}
                <div class="stat-card">
                    <h3>Current Discount</h3>
                    <p>{{.discountPercent}}% OFF</p>
                </div>
                {{end}}
            </div>
        </div>
        
        {{/* Product filtering */}}
        <div class="category-filter">
            <strong>Categories:</strong>
            {{range $index, $category := .categories}}
                {{if $index}}, {{end}}
                <a href="/products?category={{$category | lower}}">{{$category}}</a>
            {{end}}
        </div>
        
        <div class="products-grid">
            {{range .products}}
                <div class="product-card {{if not .InStock}}out-of-stock{{end}}">
                    <div class="product-name">{{.Name}}</div>
                    
                    {{/* Price with discount calculation */}}
                    <div class="product-price">
                        {{if $.discountPercent}}
                            <span style="text-decoration: line-through; color: #999; font-size: 0.9rem;">
                                {{formatCurrency .Price}}
                            </span><br>
                            <span class="discount-badge">
                                {{formatCurrency (calculateDiscount .Price $.discountPercent)}}
                            </span>
                        {{else}}
                            {{formatCurrency .Price}}
                        {{end}}
                    </div>
                    
                    {{/* Rating display with stars */}}
                    <div class="product-rating">
                        {{/* Generate star rating */}}
                        {{$fullStars := printf "%.0f" .Rating}}
                        {{range $i := seq (atoi $fullStars)}}★{{end}}
                        {{if lt .Rating 5}}
                            {{range $i := seq (sub 5 (atoi $fullStars))}}☆{{end}}
                        {{end}}
                        ({{.Rating}}/5 - {{.Reviews}} reviews)
                    </div>
                    
                    {{/* Description with truncation */}}
                    <div class="product-description">
                        {{truncate .Description 100}}
                    </div>
                    
                    {{/* Tags display */}}
                    {{if .Tags}}
                        <div class="product-tags">
                            {{range .Tags}}
                                <span class="tag">{{. | title}}</span>
                            {{end}}
                        </div>
                    {{end}}
                    
                    {{/* Stock status and age */}}
                    <div style="margin-top: 15px; font-size: 0.9rem; color: #666;">
                        {{if .InStock}}
                            ✅ In Stock
                        {{else}}
                            ❌ Out of Stock
                        {{end}}
                        • Added {{formatDate .CreatedAt "relative"}}
                    </div>
                    
                    {{/* Category badge */}}
                    <div style="margin-top: 10px;">
                        <span style="background: #95a5a6; color: white; padding: 3px 8px; border-radius: 12px; font-size: 0.8rem;">
                            {{.Category}}
                        </span>
                    </div>
                </div>
            {{end}}
        </div>
        
        {{/* Summary calculations */}}
        <div style="background: white; padding: 20px; border-radius: 8px; margin-top: 20px;">
            <h3>Catalog Summary</h3>
            {{$totalValue := 0.0}}
            {{$inStockCount := 0}}
            {{range .products}}
                {{$totalValue = add $totalValue .Price}}
                {{if .InStock}}
                    {{$inStockCount = add $inStockCount 1}}
                {{end}}
            {{end}}
            
            <p><strong>Total Catalog Value:</strong> {{formatCurrency $totalValue}}</p>
            <p><strong>In Stock:</strong> {{$inStockCount}} of {{len .products}} products ({{percentage (float64 $inStockCount) (float64 (len .products)) | printf "%.1f"}}%)</p>
            
            {{if $.discountPercent}}
                <p><strong>Potential Savings:</strong> {{formatCurrency (multiply $totalValue (div $.discountPercent 100))}}</p>
            {{end}}
        </div>
    </div>
</body>
</html>

Example 3: Performance-Optimized Template System

// Template caching and optimization
package main

import (
    "html/template"
    "sync"
    "time"
    
    "github.com/gin-gonic/gin"
)

// TemplateCache provides thread-safe template caching
type TemplateCache struct {
    templates map[string]*template.Template
    mutex     sync.RWMutex
    funcMap   template.FuncMap
}

// NewTemplateCache creates a new template cache
func NewTemplateCache() *TemplateCache {
    return &TemplateCache{
        templates: make(map[string]*template.Template),
        funcMap:   make(template.FuncMap),
    }
}

// RegisterFunction adds a custom function to the function map
func (tc *TemplateCache) RegisterFunction(name string, fn interface{}) {
    tc.mutex.Lock()
    defer tc.mutex.Unlock()
    tc.funcMap[name] = fn
}

// LoadTemplate loads and caches a template
func (tc *TemplateCache) LoadTemplate(name, pattern string) error {
    tc.mutex.Lock()
    defer tc.mutex.Unlock()
    
    tmpl, err := template.New(name).Funcs(tc.funcMap).ParseGlob(pattern)
    if err != nil {
        return err
    }
    
    tc.templates[name] = tmpl
    return nil
}

// GetTemplate retrieves a cached template
func (tc *TemplateCache) GetTemplate(name string) (*template.Template, bool) {
    tc.mutex.RLock()
    defer tc.mutex.RUnlock()
    
    tmpl, exists := tc.templates[name]
    return tmpl, exists
}

// Performance monitoring function
func measureTemplatePerformance(templateName string, renderFunc func()) {
    start := time.Now()
    renderFunc()
    duration := time.Since(start)
    
    // Log performance metrics
    if duration > 100*time.Millisecond {
        log.Printf("SLOW TEMPLATE: %s took %v", templateName, duration)
    }
}

// Optimized handler with template caching
func optimizedHandler(cache *TemplateCache) gin.HandlerFunc {
    return func(c *gin.Context) {
        templateName := "products"
        
        tmpl, exists := cache.GetTemplate(templateName)
        if !exists {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Template not found"})
            return
        }
        
        data := gin.H{
            "title": "Optimized Product Catalog",
            // ... data preparation
        }
        
        measureTemplatePerformance(templateName, func() {
            c.HTML(http.StatusOK, templateName, data)
        })
    }
}

6. Hands-On Practice (30-40 minutes)

Exercise 1: Custom Function Library (10 minutes)

Objective: Create a comprehensive library of custom template functions

Instructions:

  1. Implement date formatting functions (relative time, international formats)
  2. Create string manipulation functions (slugify, capitalize, word count)
  3. Build mathematical functions (average, percentage, rounding)
  4. Add validation functions (email validation, URL validation)

Starter Code:

func createCustomFunctions() template.FuncMap {
    return template.FuncMap{
        // TODO: Add your custom functions here
        "slugify": func(text string) string {
            // Convert text to URL-friendly slug
            return ""
        },
        "wordCount": func(text string) int {
            // Count words in text
            return 0
        },
        "average": func(numbers []float64) float64 {
            // Calculate average of numbers
            return 0
        },
    }
}

Solution:

func createCustomFunctions() template.FuncMap {
    return template.FuncMap{
        "slugify": func(text string) string {
            // Convert to lowercase and replace non-alphanumeric with hyphens
            text = strings.ToLower(text)
            reg := regexp.MustCompile(`[^a-z0-9]+`)
            text = reg.ReplaceAllString(text, "-")
            return strings.Trim(text, "-")
        },
        "wordCount": func(text string) int {
            words := strings.Fields(text)
            return len(words)
        },
        "average": func(numbers []float64) float64 {
            if len(numbers) == 0 {
                return 0
            }
            sum := 0.0
            for _, num := range numbers {
                sum += num
            }
            return sum / float64(len(numbers))
        },
        "isValidEmail": func(email string) bool {
            emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
            return emailRegex.MatchString(email)
        },
        "formatFileSize": func(bytes int64) string {
            const unit = 1024
            if bytes < unit {
                return fmt.Sprintf("%d B", bytes)
            }
            div, exp := int64(unit), 0
            for n := bytes / unit; n >= unit; n /= unit {
                div *= unit
                exp++
            }
            return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
        },
    }
}

Exercise 2: Template Performance Optimization (15 minutes)

Objective: Implement template caching and performance monitoring

Requirements:

  • Create a template cache system with preloading
  • Implement performance measurement and logging
  • Add template hot-reloading for development
  • Build template compilation error handling

Hints:

  • Use sync.RWMutex for thread-safe access
  • Implement template versioning for cache invalidation
  • Add metrics collection for production monitoring

Exercise 3: Secure Template System (15 minutes)

Objective: Build templates with comprehensive security features

Challenge: Create a user-generated content system that:

  • Safely renders user comments with HTML escaping
  • Implements content sanitization functions
  • Handles file upload display securely
  • Validates and escapes dynamic SQL-like queries

Extension Ideas:

  • Add Content Security Policy (CSP) integration
  • Implement template injection detection
  • Create audit logging for template security events

7. Common Pitfalls and Troubleshooting (10 minutes)

Frequent Mistakes

  1. Problem: Custom functions not working in templates Cause: Functions not registered in FuncMap before template parsing Solution: Register all functions before calling LoadHTMLGlob() or template parsing

  2. Problem: Template performance degradation over time Cause: Template recompilation on every request or memory leaks Solution: Implement proper template caching and monitor memory usage

  3. Problem: XSS vulnerabilities with custom HTML functions Cause: Using template.HTML with unsanitized user input Solution: Always sanitize user input and use automatic escaping by default

Debugging Tips

  • Use template execution tracing to identify slow functions
  • Implement template function unit tests for reliable behavior
  • Monitor template memory usage and compilation times
  • Use linting tools to catch template security issues

8. Best Practices and Professional Tips (5 minutes)

Industry Standards

  • Function Naming: Use clear, descriptive names that indicate function purpose
  • Error Handling: Template functions should handle errors gracefully without panicking
  • Performance: Cache expensive operations and avoid database calls in template functions
  • Security: Always validate and sanitize inputs in custom functions

Next Steps in Your Learning Journey

  • Explore template testing strategies and automated validation
  • Learn about template internationalization and localization
  • Study advanced caching strategies for high-performance applications
  • Practice building complete template component libraries

9. Summary and Review (5 minutes)

Key Takeaways

  1. Function Mastery: Built-in and custom functions provide powerful data manipulation capabilities
  2. Performance Optimization: Template caching and compilation strategies are crucial for production applications
  3. Security Awareness: Proper escaping and input validation prevent common template vulnerabilities

Quick Review Questions

  1. How do you register custom functions with Gin’s template system?
  2. What’s the difference between template.HTML and automatic HTML escaping?
  3. Why is template caching important for performance?

For Instructors

Teaching Tips

  • Emphasize security implications of template functions and HTML escaping
  • Show performance profiling tools and how to identify template bottlenecks
  • Demonstrate real-world examples of custom functions from popular applications
  • Practice debugging template function errors and performance issues

Assessment Ideas

  • Custom function library development project
  • Template performance optimization challenge
  • Security audit of template system with vulnerability identification
  • Code review focusing on function design and error handling

Adaptation Notes

  • For beginners: Focus on built-in functions before introducing custom function development
  • For advanced students: Discuss template compilation internals and advanced optimization techniques
  • Online delivery: Provide interactive template function playground for experimentation