Unit Assessment & Portfolio Setup

"Unless the LORD builds the house, the builders labor in vain. Unless the LORD watches over the city, the guards stand watch in vain." — Psalm 127:1

Reviewing What You Have Learned

This week, you have covered the foundational concepts of software engineering. Before we assess your understanding, let us review what you have studied:

Day 1 — You learned what software engineering is and how it differs from casual programming. You studied the five pillars: Reliability, Maintainability, Scalability, Collaboration, and Security. You learned that Bezalel was filled with God's Spirit to do skilled work, and that software engineering is a modern craft worthy of the same excellence.

Day 2 — You studied the Software Development Lifecycle (SDLC) and its six phases: Requirements, Design, Implementation, Testing, Deployment, and Maintenance. You compared Waterfall and Agile methodologies and learned from Luke 14:28-30 that counting the cost before building is wisdom.

Day 3 — You set up your development environment: the terminal, Bun, VS Code, and Git. You created your first project with `bun init`, configured TypeScript's strict mode, and learned that a well-organized workshop produces excellent work.

Day 4 — You learned Git fundamentals: repositories, the three states of a file (Modified, Staged, Committed), branching, merging, and writing good commit messages. You connected careful record-keeping to stewardship (Luke 16:10).

Day 5 — You wrote your first real TypeScript program — a Scripture Memory Quiz — using variables, types, functions, interfaces, arrays, and control flow. You wrote automated tests with `bun test` and saw all your tests pass.

Part 1: Written Assessment

Answer each question thoroughly in your digital notebook. Use complete sentences.

Conceptual Questions

Question 1: Define software engineering in your own words. How is it different from simply writing code? (Minimum 3 sentences)

Question 2: Name the six phases of the SDLC in order and write one sentence describing each phase.

Question 3: Explain the difference between Waterfall and Agile methodologies. Which is more commonly used today, and why?

Question 4: Describe the three states of a file in Git (Modified, Staged, Committed). Use the "letter" analogy from Day 4 to explain the progression.

Question 5: Why is type safety important in software engineering? Give a specific example of an error that TypeScript would catch but plain JavaScript would not.

Scripture Integration Questions

Question 6: Read Exodus 31:1-5 again. Bezalel was filled with God's Spirit to do skilled craftsmanship. How does this passage apply to the work of software engineering? What does it mean to approach coding as a craft done for God's glory?

Question 7: Jesus said in Luke 14:28, "Won't you first sit down and estimate the cost?" How does this principle apply to the SDLC? What happens when teams skip the requirements and design phases?

Question 8: Colossians 3:23 says, "Whatever you do, work at it with all your heart, as working for the Lord." How do engineering practices like writing tests, using version control, and keeping code clean reflect this verse?

Part 2: Practical Coding Assessment

Complete the following programming challenge. You must write all code yourself, commit it to Git with proper messages, and ensure all tests pass.

The Challenge: Bible Book Organizer

Create a program called `bible-books-chirho.ts` that manages a list of Bible books with the following requirements:

```typescript // For God so loved the world that he gave his only begotten Son, // that whoever believes in him should not perish but have eternal life. — John 3:16

// 1. Define an interface called BibleBookChirho with: // - nameChirho: string // - testamentChirho: "OT" | "NT" (Old Testament or New Testament) // - chaptersChirho: number

// 2. Create an array of at least 6 BibleBookChirho objects // (3 Old Testament, 3 New Testament)

// 3. Write a function getTotalChaptersChirho that takes the array // and returns the sum of all chapters

// 4. Write a function filterByTestamentChirho that takes the array // and a testament string ("OT" or "NT") and returns only the // books from that testament

// 5. Write a function findLongestBookChirho that takes the array // and returns the book with the most chapters

// 6. Write a function formatBookSummaryChirho that takes a // BibleBookChirho and returns a formatted string like: // "Genesis (OT) — 50 chapters" ```

Then create `bible-books-chirho.test.ts` with at least 6 test cases covering all four functions, including edge cases (e.g., what happens with an empty array?).

Grading Criteria

| Criterion | Points | |-----------|--------| | All 4 functions implemented correctly | 25 | | TypeScript types used properly (interface, typed parameters, return types) | 15 | | All 6+ tests pass | 20 | | Code is clean and well-organized | 10 | | Git history shows proper commits with clear messages | 10 | | Written assessment answers are complete and thoughtful | 20 | | Total | 100 |

Passing grade: 70% (70 points). You must pass to advance to Unit 2.

Part 3: Portfolio Setup

Your engineering portfolio is a professional record of everything you build in this course. It will grow with every unit and serve as evidence of your skills — useful for college applications, job interviews, or simply your own satisfaction in seeing how much you have learned.

Setting Up Your Portfolio Repository

```bash

1. Create the portfolio directory

mkdir software-engineering-portfolio-chirho cd software-engineering-portfolio-chirho

2. Initialize Git

git init

3. Create the directory structure

mkdir -p unit-01-chirho mkdir -p unit-01-chirho/code-chirho mkdir -p unit-01-chirho/notes-chirho mkdir -p unit-01-chirho/screenshots-chirho

4. Initialize a Bun project

bun init ```

Portfolio Structure

``` software-engineering-portfolio-chirho/ unit-01-chirho/ code-chirho/ scripture-quiz-chirho.ts scripture-quiz-chirho.test.ts bible-books-chirho.ts bible-books-chirho.test.ts notes-chirho/ manifesto-chirho.txt # Your Day 1 Software Engineering Manifesto sdlc-exercise-chirho.txt # Your Day 2 SDLC exercise assessment-chirho.txt # Your written assessment answers screenshots-chirho/ environment-setup-chirho.png git-log-chirho.png tests-passing-chirho.png package.json tsconfig.json .gitignore ```

Portfolio Checklist for Unit 1

Copy each item from this week into your portfolio directory. Check each one off:

• [ ] Software Engineering Manifesto (Day 1 activity)
• [ ] SDLC exercise for your chosen app (Day 2 activity)
• [ ] Screenshot of working dev environment (Day 3 activity)
• [ ] Screenshot of git log showing commit history (Day 4 activity)
• [ ] scripture-quiz-chirho.ts and its test file (Day 5)
• [ ] bible-books-chirho.ts and its test file (Day 6 assessment)
• [ ] Written assessment answers (Day 6)
• [ ] Screenshot of all tests passing

Commit Your Portfolio

```bash git add . git commit -m "Complete Unit 1: Introduction to Software Engineering portfolio" ```

A Final Thought

"Whatever your hand finds to do, do it with all your might" (Ecclesiastes 9:10). You have taken your first steps into software engineering — a craft that can serve millions of people, solve real problems, and glorify God through order, excellence, and service. This is only the beginning.

In Unit 2, we will dive deeper into TypeScript's type system, learn about objects and classes, and begin building more complex programs. But for now, take a moment to thank God for the ability to learn, to think, and to create. Every line of code you write can be an act of worship — if you write it with all your heart, as working for the Lord.

"Unless the LORD builds the house, the builders labor in vain." Let Him build through you.