What Is Software Engineering?

"Then the LORD said to Moses, 'See, I have chosen Bezalel son of Uri, the son of Hur, of the tribe of Judah, and I have filled him with the Spirit of God, with wisdom, with understanding, with knowledge and with all kinds of skills — to make artistic designs for work in gold, silver and bronze, to cut and set stones, to work in wood, and to engage in all kinds of crafts.'" — Exodus 31:1-5

The Craftsman's Calling

When God wanted the tabernacle built — the sacred tent where His presence would dwell among the Israelites — He did not leave its construction to chance. He called Bezalel by name and filled him with His Spirit, giving him wisdom, understanding, knowledge, and skill in every craft. God cared about the quality of the work. Every measurement was specified. Every material was chosen with purpose. Every detail mattered because the work was being done for God's glory.

Software engineering is a modern craft. Just as Bezalel shaped gold and wood into something that served God's purposes, software engineers shape logic and data into systems that serve people. And just as Bezalel needed skill, understanding, and wisdom — not merely the ability to hammer metal — a software engineer needs far more than the ability to write code.

Programming vs. Software Engineering

Many people use the words "programming" and "software engineering" interchangeably, but they are not the same thing. Consider an analogy: anyone can stack bricks, but not everyone can design and build a house that will stand for a hundred years. The difference is engineering — applying systematic knowledge, proven principles, and disciplined methods to build something reliable.

Programming is the act of writing instructions (code) that a computer can execute. It is a skill, and an important one. But programming alone is like knowing how to cut wood — necessary, but not sufficient to build a cathedral.

Software engineering encompasses the entire process of building software systems: understanding what needs to be built (requirements), planning how to build it (design), writing the code (implementation), verifying it works correctly (testing), releasing it to users (deployment), and keeping it running and improving over time (maintenance). It is the disciplined, systematic application of engineering principles to software creation.

Here is a helpful comparison:

| Aspect | Programming | Software Engineering | |--------|------------|---------------------| | Focus | Writing code that works | Building systems that last | | Scope | A single script or function | An entire application lifecycle | | Time Horizon | "Does it work now?" | "Will it work in five years?" | | Team Size | Often solo | Usually collaborative | | Documentation | Optional notes | Essential blueprints | | Testing | Manual spot-checks | Systematic automated tests | | Process | Write and run | Plan, build, test, deploy, maintain |

The Five Pillars of Software Engineering

Just as a building rests on pillars, good software engineering rests on foundational principles. We will study five essential ones:

1. Reliability — It Must Work Correctly

"Whatever you do, work at it with all your heart, as working for the Lord, not for human masters." — Colossians 3:23

Software must do what it promises to do. A calculator app that sometimes gives wrong answers is worse than useless — it actively harms the people who trust it. Reliability means the software behaves correctly under expected conditions and handles unexpected conditions gracefully. Engineers achieve reliability through careful design, thorough testing, and disciplined error handling.

2. Maintainability — Others Must Be Able to Understand It

"For God is not a God of disorder but of peace." — 1 Corinthians 14:33

Code is read far more often than it is written. A program you write today will be read, modified, and debugged by you and others for months or years to come. Maintainable code is clean, well-organized, and clearly documented. Writing messy code is like a carpenter leaving nails scattered across the floor — it creates hazards for everyone who comes after.

3. Scalability — It Must Grow with Demand

Software that works for ten users but crashes with ten thousand is poorly engineered. Scalable software is designed to handle growth — more users, more data, more features — without requiring a complete rewrite. This requires thinking ahead, choosing appropriate data structures, and designing systems in modular pieces.

4. Collaboration — It Must Be Built as a Team

Bezalel did not build the tabernacle alone. God also called Oholiab and "every skilled person to whom the LORD has given skill and ability" (Exodus 36:1). Software engineering is fundamentally collaborative. Tools like version control, code review, shared documentation, and clear communication practices enable teams to build together without stepping on each other's work.

5. Security — It Must Protect Its Users

"The prudent see danger and take refuge, but the simple keep going and pay the penalty." — Proverbs 27:12

Software that stores personal information, handles financial transactions, or controls physical systems must be built with security as a first-class concern. A software engineer has a moral responsibility to protect the people who use their software. This means validating all inputs, encrypting sensitive data, managing access carefully, and staying informed about known vulnerabilities.

Why TypeScript and Bun?

In this course, we will write our code using TypeScript and run it with Bun. Here is why:

TypeScript is a programming language built on top of JavaScript that adds type safety. Types are like labels that tell both the computer and the programmer what kind of data a variable holds. This catches errors before the program runs — during compilation rather than at runtime. As Proverbs 27:12 says, "The prudent see danger and take refuge." Type checking is the prudent programmer's refuge against bugs.

Bun is a modern JavaScript/TypeScript runtime — the engine that actually executes your code. It is extremely fast, includes a built-in test runner, a package manager, and can run TypeScript directly without a separate compilation step. It simplifies our toolchain so we can focus on learning engineering principles rather than fighting configuration.

A Thought to Carry

Software engineering is not merely a career skill — it is a form of craftsmanship. When done with excellence, it serves people, solves real problems, and brings order where there was chaos. As Christians, we believe that God is a God of order (1 Corinthians 14:33) and that all our work should be done heartily unto the Lord (Colossians 3:23). Whether you build a birdhouse or a database, do it with the care and excellence of Bezalel — filled with God's Spirit, wisdom, and skill.