Performance Optimization in Lua

Advanced ~25 min read

Writing fast, efficient code is crucial for performance-critical applications. In this final lesson, you'll learn how to profile your Lua code, identify bottlenecks, and apply optimization techniques. Let's explore performance optimization in Lua!

Profiling Your Code

Simple Timing

local function benchmark(func, iterations)
    iterations = iterations or 1000000
    
    local start = os.clock()
    for i = 1, iterations do
        func()
    end
    local finish = os.clock()
    
    local elapsed = finish - start
    print(string.format("Time: %.6f seconds", elapsed))
    print(string.format("Per iteration: %.9f seconds", elapsed / iterations))
end

-- Usage
benchmark(function()
    local x = 10 * 20
end)

Profiler Function

local Profiler = {}

function Profiler:new()
    local self = {
        times = {},
        counts = {}
    }
    setmetatable(self, {__index = Profiler})
    return self
end

function Profiler:start(name)
    self.times[name] = os.clock()
end

function Profiler:stop(name)
    if not self.times[name] then return end
    
    local elapsed = os.clock() - self.times[name]
    self.counts[name] = (self.counts[name] or 0) + 1
    self.times[name] = (self.times[name] or 0) + elapsed
end

function Profiler:report()
    print("\n=== Profiler Report ===")
    for name, time in pairs(self.times) do
        local count = self.counts[name]
        print(string.format("%s: %.6fs (%d calls, %.9fs avg)",
            name, time, count, time / count))
    end
end

-- Usage
local prof = Profiler:new()

prof:start("calculation")
-- Do work
prof:stop("calculation")

prof:report()

-- Performance Tips and Best Practices

-- Collection of performance optimization tips for Lua

print("=== Use Local Variables ===")

-- Slow: Global variable access
_G.counter = 0
function incrementGlobal()
    for i = 1, 100000 do
        _G.counter = _G.counter + 1
    end
end

-- Fast: Local variable access
local function incrementLocal()
    local counter = 0
    for i = 1, 100000 do
        counter = counter + 1
    end
    return counter
end

local start = os.clock()
incrementGlobal()
print("Global access:", os.clock() - start)

start = os.clock()
incrementLocal()
print("Local access:", os.clock() - start)

print("\n=== Cache Table Lookups ===")

local math = math  -- Cache global

-- Slow: Repeated global lookup
local function slowMath()
    for i = 1, 100000 do
        math.sqrt(i)
    end
end

-- Fast: Cache function
local function fastMath()
    local sqrt = math.sqrt
    for i = 1, 100000 do
        sqrt(i)
    end
end

start = os.clock()
slowMath()
print("Repeated lookup:", os.clock() - start)

start = os.clock()
fastMath()
print("Cached lookup:", os.clock() - start)

print("\n=== Avoid Function Calls in Loops ===")

local data = {}
for i = 1, 10000 do
    data[i] = i
end

-- Slow: Function call each iteration
local function slowLoop()
    for i = 1, #data do  -- #data called each time
        local v = data[i]
    end
end

-- Fast: Cache length
local function fastLoop()
    local len = #data
    for i = 1, len do
        local v = data[i]
    end
end

start = os.clock()
slowLoop()
print("Function in loop:", os.clock() - start)

start = os.clock()
fastLoop()
print("Cached length:", os.clock() - start)

print("\n=== Use Appropriate Data Structures ===")

-- Arrays for sequential data
local array = {1, 2, 3, 4, 5}

-- Hash tables for key-value pairs
local hash = {name = "Alice", age = 25}

-- Sets using tables
local set = {apple = true, banana = true, cherry = true}

print("Is apple in set:", set["apple"])

print("\n=== Minimize Table Creations ===")

-- Slow: Create table each iteration
local function manyTables()
    for i = 1, 10000 do
        local temp = {x = i, y = i * 2}
    end
end

-- Fast: Reuse table
local function reuseTable()
    local temp = {}
    for i = 1, 10000 do
        temp.x = i
        temp.y = i * 2
    end
end

start = os.clock()
manyTables()
print("Many tables:", os.clock() - start)

start = os.clock()
reuseTable()
print("Reuse table:", os.clock() - start)

print("\n=== Use Numeric For Loops ===")

-- Fastest loop type
for i = 1, 10 do
    -- Fast
end

-- Slower: Generic for with ipairs
for i, v in ipairs({1,2,3,4,5}) do
    -- Slower
end

print("\n=== Avoid Unnecessary Type Conversions ===")

-- Keep numbers as numbers
local n = 42
-- Don't: tostring(n) unless needed

-- Keep strings as strings
local s = "42"
-- Don't: tonumber(s) unless needed

print("\n=== Use Math Operators Efficiently ===")

-- Slow: Power operator for squaring
local function slowSquare(x)
    return x ^ 2
end

-- Fast: Multiplication
local function fastSquare(x)
    return x * x
end

start = os.clock()
for i = 1, 100000 do
    slowSquare(i)
end
print("Power operator:", os.clock() - start)

start = os.clock()
for i = 1, 100000 do
    fastSquare(i)
end
print("Multiplication:", os.clock() - start)

print("\n=== Memory Management ===")

-- Check memory usage
local memBefore = collectgarbage("count")
print("Memory before:", memBefore, "KB")

-- Create some data
local bigTable = {}
for i = 1, 100000 do
    bigTable[i] = i
end

local memAfter = collectgarbage("count")
print("Memory after:", memAfter, "KB")
print("Used:", memAfter - memBefore, "KB")

-- Force garbage collection
collectgarbage("collect")
print("After GC:", collectgarbage("count"), "KB")

print("\n=== Profiling ===")

local function profile(func, name)
    local start = os.clock()
    func()
    local elapsed = os.clock() - start
    print(string.format("%s: %.6f seconds", name, elapsed))
end

profile(function()
    local sum = 0
    for i = 1, 1000000 do
        sum = sum + i
    end
end, "Sum calculation")

print("\n=== Lazy Evaluation ===")

-- Don't compute unless needed
local function expensiveOperation()
    print("Computing...")
    return 42
end

local function lazyExample(condition)
    -- Only compute if needed
    if condition then
        return expensiveOperation()
    end
    return 0
end

print("Result:", lazyExample(false))  -- Doesn't compute

print("\n=== Memoization ===")

local cache = {}

local function fibonacci(n)
    if n <= 1 then return n end
    
    if not cache[n] then
        cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
    end
    
    return cache[n]
end

start = os.clock()
print("Fib(30):", fibonacci(30))
print("Time:", os.clock() - start)

print("\n=== Best Practices Summary ===")
print("1. Use local variables")
print("2. Cache table lookups")
print("3. Use table.concat for strings")
print("4. Minimize table creations")
print("5. Use numeric for loops")
print("6. Cache function references")
print("7. Avoid unnecessary conversions")
print("8. Use appropriate data structures")
print("9. Profile before optimizing")
print("10. Use memoization for expensive computations")

print("\n=== Premature Optimization Warning ===")
print("Remember: Profile first, optimize later!")
print("Readable code > Fast code (until proven slow)")

Output

Click Run to execute your code

Optimization Techniques

1. Use Local Variables

-- Slow: Global lookups
function slow()
    for i = 1, 1000000 do
        local x = math.sin(i)
    end
end

-- Fast: Local cache
function fast()
    local sin = math.sin
    for i = 1, 1000000 do
        local x = sin(i)
    end
end

2. Avoid table.insert() in Loops

-- Slower
local function buildArray1(n)
    local arr = {}
    for i = 1, n do
        table.insert(arr, i)
    end
    return arr
end

-- Faster: Direct assignment
local function buildArray2(n)
    local arr = {}
    for i = 1, n do
        arr[i] = i
    end
    return arr
end

3. Use table.concat() for Strings

-- Slow: String concatenation
local function buildString1(n)
    local s = ""
    for i = 1, n do
        s = s .. tostring(i)
    end
    return s
end

-- Fast: table.concat()
local function buildString2(n)
    local parts = {}
    for i = 1, n do
        parts[i] = tostring(i)
    end
    return table.concat(parts)
end

4. Reuse Tables

-- Slow: Create new table each iteration
for i = 1, 10000 do
    local temp = {}
    temp.x = i
    temp.y = i * 2
    -- Use temp
end

-- Fast: Reuse table
local temp = {}
for i = 1, 10000 do
    temp.x = i
    temp.y = i * 2
    -- Use temp
end

-- Table Performance Optimization in Lua

-- Tables are Lua's primary data structure
-- Optimizing table usage is crucial for performance

print("=== Pre-sizing Tables ===")

-- Slow: Growing table dynamically
local function slowTableGrowth()
    local t = {}
    for i = 1, 100000 do
        t[i] = i
    end
    return t
end

-- Faster: Direct assignment (Lua handles this well)
local function fastTableGrowth()
    local t = {}
    for i = 1, 100000 do
        t[i] = i
    end
    return t
end

-- Note: Lua 5.1+ handles table growth efficiently
-- Pre-allocation isn't as critical as in other languages

print("=== Array vs table.insert ===")

-- Slower: Using table.insert
local function withInsert()
    local t = {}
    for i = 1, 10000 do
        table.insert(t, i)
    end
    return t
end

-- Faster: Direct assignment
local function withAssignment()
    local t = {}
    for i = 1, 10000 do
        t[i] = i
    end
    return t
end

-- Benchmark
local start = os.clock()
withInsert()
print("table.insert:", os.clock() - start)

start = os.clock()
withAssignment()
print("Direct assignment:", os.clock() - start)

print("\n=== Table Reuse ===")

-- Slow: Creating new tables
local function manyTables()
    for i = 1, 10000 do
        local temp = {x = i, y = i * 2}
        -- use temp
    end
end

-- Faster: Reusing table
local function reuseTable()
    local temp = {}
    for i = 1, 10000 do
        temp.x = i
        temp.y = i * 2
        -- use temp
    end
end

start = os.clock()
manyTables()
print("Many tables:", os.clock() - start)

start = os.clock()
reuseTable()
print("Reuse table:", os.clock() - start)

print("\n=== Table Iteration ===")

local data = {}
for i = 1, 10000 do
    data[i] = i
end

-- Slower: pairs (checks all keys)
local function withPairs()
    local sum = 0
    for k, v in pairs(data) do
        sum = sum + v
    end
    return sum
end

-- Faster: ipairs (optimized for arrays)
local function withIpairs()
    local sum = 0
    for i, v in ipairs(data) do
        sum = sum + v
    end
    return sum
end

-- Fastest: numeric for
local function withNumericFor()
    local sum = 0
    for i = 1, #data do
        sum = sum + data[i]
    end
    return sum
end

start = os.clock()
withPairs()
print("pairs:", os.clock() - start)

start = os.clock()
withIpairs()
print("ipairs:", os.clock() - start)

start = os.clock()
withNumericFor()
print("numeric for:", os.clock() - start)

print("\n=== Table Copying ===")

-- Shallow copy
local function shallowCopy(t)
    local copy = {}
    for k, v in pairs(t) do
        copy[k] = v
    end
    return copy
end

-- Deep copy (recursive)
local function deepCopy(t)
    if type(t) ~= "table" then
        return t
    end
    
    local copy = {}
    for k, v in pairs(t) do
        copy[k] = deepCopy(v)
    end
    return copy
end

print("\n=== Table Concatenation ===")

-- Slow: String concatenation
local function slowConcat()
    local result = ""
    for i = 1, 1000 do
        result = result .. tostring(i)
    end
    return result
end

-- Fast: table.concat
local function fastConcat()
    local t = {}
    for i = 1, 1000 do
        t[i] = tostring(i)
    end
    return table.concat(t)
end

start = os.clock()
slowConcat()
print("String concat:", os.clock() - start)

start = os.clock()
fastConcat()
print("table.concat:", os.clock() - start)

print("\n=== Avoid Table Lookups in Loops ===")

local config = {
    settings = {
        timeout = 30
    }
}

-- Slow: Repeated lookups
local function slowLookup()
    for i = 1, 10000 do
        local timeout = config.settings.timeout
        -- use timeout
    end
end

-- Fast: Cache lookup
local function fastLookup()
    local timeout = config.settings.timeout
    for i = 1, 10000 do
        -- use timeout
    end
end

start = os.clock()
slowLookup()
print("Repeated lookups:", os.clock() - start)

start = os.clock()
fastLookup()
print("Cached lookup:", os.clock() - start)

print("\n=== Table.remove Performance ===")

-- Slow: Removing from beginning
local function removeFromStart()
    local t = {}
    for i = 1, 1000 do
        t[i] = i
    end
    
    for i = 1, 500 do
        table.remove(t, 1)  -- Shifts all elements
    end
end

-- Faster: Removing from end
local function removeFromEnd()
    local t = {}
    for i = 1, 1000 do
        t[i] = i
    end
    
    for i = 1, 500 do
        table.remove(t)  -- No shifting needed
    end
end

start = os.clock()
removeFromStart()
print("Remove from start:", os.clock() - start)

start = os.clock()
removeFromEnd()
print("Remove from end:", os.clock() - start)

print("\n=== Weak Tables for Caching ===")

-- Use weak tables for caches to allow garbage collection
local cache = {}
setmetatable(cache, {__mode = "v"})  -- Weak values

local function getCached(key)
    if not cache[key] then
        cache[key] = expensiveComputation(key)
    end
    return cache[key]
end

function expensiveComputation(x)
    return x * x
end

print("Cached value:", getCached(10))
print("Cached value:", getCached(10))  -- Uses cache

Output

Click Run to execute your code

Memory Management

Garbage Collection

-- Check memory usage
local function getMemoryUsage()
    return collectgarbage("count")
end

print("Memory:", getMemoryUsage(), "KB")

-- Force garbage collection
collectgarbage("collect")

-- Set GC parameters
collectgarbage("setpause", 100)  -- Pause between collections
collectgarbage("setstepmul", 200)  -- GC step multiplier

Weak Tables

-- Weak table for caching
local cache = {}
setmetatable(cache, {__mode = "v"})  -- Weak values

function getCachedValue(key)
    if not cache[key] then
        cache[key] = expensiveComputation(key)
    end
    return cache[key]
end

Algorithm Optimization

Memoization

-- Slow: Recursive fibonacci
local function fib1(n)
    if n <= 1 then return n end
    return fib1(n - 1) + fib1(n - 2)
end

-- Fast: Memoized fibonacci
local function memoize(func)
    local cache = {}
    return function(n)
        if not cache[n] then
            cache[n] = func(n)
        end
        return cache[n]
    end
end

local fib2
fib2 = memoize(function(n)
    if n <= 1 then return n end
    return fib2(n - 1) + fib2(n - 2)
end)

print(fib2(30))  -- Much faster!

Early Exit

-- Slow: Check all items
local function findItem1(items, target)
    local found = false
    for i, item in ipairs(items) do
        if item == target then
            found = true
        end
    end
    return found
end

-- Fast: Early exit
local function findItem2(items, target)
    for i, item in ipairs(items) do
        if item == target then
            return true
        end
    end
    return false
end

-- Performance: Algorithm Optimization

-- Example 1: Efficient Table Insertion
print("=== Table Insertion Performance ===")

-- Inefficient: Using table.insert in loop
local function slow_build_table(n)
    local t = {}
    for i = 1, n do
        table.insert(t, i)  -- Slower
    end
    return t
end

-- Efficient: Direct index assignment
local function fast_build_table(n)
    local t = {}
    for i = 1, n do
        t[i] = i  -- Faster
    end
    return t
end

local n = 10
print("Building table with", n, "elements")
print("Slow method:", #slow_build_table(n), "elements")
print("Fast method:", #fast_build_table(n), "elements")

-- Example 2: String Concatenation
print("\n=== String Concatenation ===")

-- Inefficient: Using .. in loop
local function slow_concat(n)
    local s = ""
    for i = 1, n do
        s = s .. i .. ","  -- Creates new string each time
    end
    return s
end

-- Efficient: Using table.concat
local function fast_concat(n)
    local t = {}
    for i = 1, n do
        t[i] = i
    end
    return table.concat(t, ",")
end

local count = 10
print("Slow concat:", slow_concat(count))
print("Fast concat:", fast_concat(count))

-- Example 3: Memoization for Fibonacci
print("\n=== Memoization ===")

-- Without memoization (slow for large n)
local function fib_slow(n)
    if n <= 1 then
        return n
    end
    return fib_slow(n - 1) + fib_slow(n - 2)
end

-- With memoization (fast)
local fib_cache = {}
local function fib_fast(n)
    if n <= 1 then
        return n
    end
    if not fib_cache[n] then
        fib_cache[n] = fib_fast(n - 1) + fib_fast(n - 2)
    end
    return fib_cache[n]
end

print("Fibonacci(10) slow:", fib_slow(10))
print("Fibonacci(10) fast:", fib_fast(10))
print("Fibonacci(20) fast:", fib_fast(20))

-- Example 4: Efficient Searching
print("\n=== Binary Search vs Linear Search ===")

-- Linear search (O(n))
local function linear_search(arr, target)
    for i, v in ipairs(arr) do
        if v == target then
            return i
        end
    end
    return nil
end

-- Binary search (O(log n)) - requires sorted array
local function binary_search(arr, target)
    local low, high = 1, #arr
    while low <= high do
        local mid = math.floor((low + high) / 2)
        if arr[mid] == target then
            return mid
        elseif arr[mid] < target then
            low = mid + 1
        else
            high = mid - 1
        end
    end
    return nil
end

local sorted_array = {2, 5, 8, 12, 16, 23, 38, 45, 56, 67, 78}
local target = 23

print("Linear search for", target, "found at:", linear_search(sorted_array, target))
print("Binary search for", target, "found at:", binary_search(sorted_array, target))

-- Example 5: Efficient Sorting
print("\n=== Sorting Algorithms ===")

-- Bubble sort (O(n²)) - slow
local function bubble_sort(arr)
    local n = #arr
    for i = 1, n do
        for j = 1, n - i do
            if arr[j] > arr[j + 1] then
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
            end
        end
    end
    return arr
end

-- Quick sort (O(n log n)) - fast
local function quick_sort(arr, low, high)
    low = low or 1
    high = high or #arr
    
    if low < high then
        local function partition(arr, low, high)
            local pivot = arr[high]
            local i = low - 1
            for j = low, high - 1 do
                if arr[j] <= pivot then
                    i = i + 1
                    arr[i], arr[j] = arr[j], arr[i]
                end
            end
            arr[i + 1], arr[high] = arr[high], arr[i + 1]
            return i + 1
        end
        
        local pi = partition(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)
    end
    return arr
end

local unsorted = {64, 34, 25, 12, 22, 11, 90}
local arr1 = {64, 34, 25, 12, 22, 11, 90}
local arr2 = {64, 34, 25, 12, 22, 11, 90}

print("Original:", table.concat(unsorted, ", "))
print("Bubble sort:", table.concat(bubble_sort(arr1), ", "))
print("Quick sort:", table.concat(quick_sort(arr2), ", "))

-- Example 6: Loop Optimization
print("\n=== Loop Optimization ===")

-- Inefficient: Recalculating length
local function slow_loop(arr)
    local sum = 0
    for i = 1, #arr do  -- #arr calculated each iteration
        sum = sum + arr[i]
    end
    return sum
end

-- Efficient: Cache length
local function fast_loop(arr)
    local sum = 0
    local n = #arr  -- Calculate once
    for i = 1, n do
        sum = sum + arr[i]
    end
    return sum
end

local numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print("Sum (slow):", slow_loop(numbers))
print("Sum (fast):", fast_loop(numbers))

-- Example 7: Avoiding Global Variables
print("\n=== Local vs Global Variables ===")

-- Slower: Using global
global_sum = 0
local function use_global(arr)
    for i = 1, #arr do
        global_sum = global_sum + arr[i]
    end
    return global_sum
end

-- Faster: Using local
local function use_local(arr)
    local sum = 0
    for i = 1, #arr do
        sum = sum + arr[i]
    end
    return sum
end

print("Using global:", use_global(numbers))
print("Using local:", use_local(numbers))

print("\n=== Algorithm Optimization Complete ===")

Output

Click Run to execute your code

Common Performance Pitfalls

Avoid These:

Global variables: Slower than local
Repeated table lookups: Cache in locals
String concatenation in loops: Use table.concat()
Creating tables in loops: Reuse when possible
Unnecessary function calls: Inline simple operations
Premature optimization: Profile first!

Performance Best Practices

Best Practices:

Profile before optimizing: Find real bottlenecks
Use local variables: Faster than globals
Cache table lookups: Especially in loops
Choose right data structures: Arrays vs hash tables
Avoid unnecessary allocations: Reuse tables
Use appropriate algorithms: O(n) vs O(n²)
Lazy evaluation: Compute only when needed
Batch operations: Reduce overhead

Before and After Optimization

Before: Slow Code

function processData(data)
    local result = ""
    for i = 1, #data do
        result = result .. tostring(data[i])
        if math.sqrt(data[i]) > 10 then
            result = result .. " (large)"
        end
    end
    return result
end

After: Optimized Code

function processData(data)
    local parts = {}
    local sqrt = math.sqrt
    local tostring = tostring
    local n = #data
    
    for i = 1, n do
        local value = data[i]
        parts[#parts + 1] = tostring(value)
        if sqrt(value) > 10 then
            parts[#parts + 1] = " (large)"
        end
    end
    
    return table.concat(parts)
end

Improvements:

Use table.concat() instead of string concatenation
Cache math.sqrt and tostring in locals
Cache #data outside loop
Use direct array assignment

Practice Exercise

Optimize this code:

-- Exercise: Performance & Optimization
-- TODO: Complete the following exercises

-- 1. Optimize this string concatenation
local function slowConcat()
    local s = ""
    for i = 1, 1000 do
        s = s .. tostring(i)
    end
    return s
end

-- Optimized version:
-- local function fastConcat()
--     -- your code here
--     -- use table.concat
-- end

-- 2. Optimize this table lookup
local config = {
    settings = {
        timeout = 30
    }
}

local function slowLookup()
    for i = 1, 10000 do
        local timeout = config.settings.timeout
        -- use timeout
    end
end

-- Optimized version:
-- local function fastLookup()
--     -- your code here
--     -- cache the lookup
-- end

-- 3. Optimize this global access
_G.counter = 0

function incrementGlobal()
    for i = 1, 10000 do
        _G.counter = _G.counter + 1
    end
end

-- Optimized version:
-- local function incrementLocal()
--     -- your code here
--     -- use local variable
-- end

-- 4. Optimize this table creation
local function manyTables()
    for i = 1, 10000 do
        local temp = {x = i, y = i * 2}
        -- use temp
    end
end

-- Optimized version:
-- local function reuseTable()
--     -- your code here
--     -- reuse single table
-- end

-- 5. Optimize this math operation
local function slowSquare(x)
    return x ^ 2
end

-- Optimized version:
-- local function fastSquare(x)
--     -- your code here
--     -- use multiplication
-- end

-- 6. Create a memoized fibonacci function
local function fibonacci(n)
    if n <= 1 then return n end
    return fibonacci(n - 1) + fibonacci(n - 2)
end

-- Memoized version:
-- local cache = {}
-- local function fibonacciMemo(n)
--     -- your code here
--     -- use cache to store results
-- end

-- 7. Optimize this loop
local data = {}
for i = 1, 10000 do
    data[i] = i
end

local function slowLoop()
    for i = 1, #data do  -- #data called each time
        local v = data[i]
    end
end

-- Optimized version:
-- local function fastLoop()
--     -- your code here
--     -- cache the length
-- end

-- 8. Create a string buffer
-- TODO: Implement a string buffer that efficiently builds strings
local function createStringBuffer()
    -- your code here
    -- return table with append() and toString() methods
end

-- local buf = createStringBuffer()
-- buf.append("Hello")
-- buf.append(" ")
-- buf.append("World")
-- print(buf.toString())

-- 9. Profile a function
-- TODO: Write a profiling function
local function profile(func, name)
    -- your code here
    -- measure execution time using os.clock()
end

-- profile(function()
--     local sum = 0
--     for i = 1, 1000000 do
--         sum = sum + i
--     end
-- end, "Sum")

-- 10. Optimize this array iteration
local array = {}
for i = 1, 10000 do
    array[i] = i
end

local function slowIteration()
    for k, v in pairs(array) do
        -- process
    end
end

-- Optimized version:
-- local function fastIteration()
--     -- your code here
--     -- use numeric for loop or ipairs
-- end

Output

Click Run to execute your code

Summary

In this lesson, you learned:

Profiling code with timing and profiler functions
Optimization techniques (local variables, table operations)
Memory management and garbage collection
Algorithm optimization (memoization, early exit)
Common performance pitfalls to avoid
Performance best practices
Before/after optimization examples

🎉 Congratulations!

You've completed the Lua tutorial!

You've learned everything from basic syntax to advanced topics like coroutines, OOP, modules, error handling, and performance optimization. You now have the skills to build robust, efficient Lua applications.

What's next?

Build real projects to practice your skills
Explore Lua frameworks (LÖVE for games, OpenResty for web)
Contribute to open-source Lua projects
Dive deeper into LuaJIT for maximum performance
Learn C API for extending Lua

Keep coding and happy Lua programming! 🚀

Previous File I/O

Next Back to Lua Home

Profiling Your Code

Simple Timing

Profiler Function

Optimization Techniques

1. Use Local Variables

2. Avoid table.insert() in Loops

3. Use table.concat() for Strings

4. Reuse Tables

Memory Management

Garbage Collection

Weak Tables

Algorithm Optimization

Memoization

Early Exit

Common Performance Pitfalls

Performance Best Practices

Before and After Optimization

Before: Slow Code

After: Optimized Code

Practice Exercise

Summary

🎉 Congratulations!

Enjoying these tutorials?