Compiling 2025: Year of Growth 🌱

Ernest Yoyowah — Tue, 07 Jan 2025 11:49:48 +0000

This is a submission for the 2025 New Year Writing challenge: Compiling 2025.

Introduction

2024 was the year I set my foundation, navigating internships, contracts, and learning opportunities while balancing challenges in college and life. Now, 2025 is here, and I’m stepping into The Year of Growth 🌱. This is the year I take bold steps toward becoming the well-rounded software engineer, and musician I’ve envisioned. Here’s how I’m planning to make it happen!

🎯 Main Goals for 2025

🖥️ Become a Better Software Engineer

Deep dive into Full-Stack Development: JavaScript, TypeScript, ReactJS, and Node.js.
Build practical projects while mastering design patterns and runtime concepts.

🎹 Excel as a Musician

Strengthen keyboard skills: ear training, soloing, and exploring music technology like VSTs and DAWs.
Expand both local (Ghanaian worship styles) and foreign (advanced chord progressions) repertoires.

💬 Enhance Communication Skills

Refine articulation, presentation skills, and tone to improve speaking presence.

🎓 Succeed Academically

Achieve a minimum GPA of 3.4 with consistent performance.

💼 Secure Professional Experience

Obtain a full-time role or freelance gigs to enhance industry exposure.

📅 Quarterly Quest (Jan – March 2025)

Morning Manifesto

"I am a great and renowned software engineer, architect, and musician through Christ who strengthens me. 🙌"

Focus Areas

🖥️ Software Engineering: Full-Stack Development

JavaScript (JS)
- Study runtime concepts: execution context, event loop, and transpilers.
- 📖 Resource: You Don’t Know JS (YDKJS).
- 👉 Key Deliverable: Build a project using advanced runtime concepts.
TypeScript (TS)
- Understand its use for type safety and transpilation.
- 📖 Resource: TypeScript Handbook.
- 👉 Key Deliverable: Refactor an existing JS project into TS.
ReactJS
- Master design patterns, state management, hooks, and reusable components.
- 📖 Resource: React Design Patterns by Michele Bertoli.
- 👉 Key Deliverable: Build a feature-rich web app using reusable components.
Node.js
- Learn advanced patterns and middleware.
- 📖 Resource: Node.js Design Patterns.
- 👉 Key Deliverable: Build a REST API with Node.js and Express.

🎹 Musician: Keyboardist and Music Technologist

Ear Training
- Local focus: Ghanaian worship & praise (horns/trumpets, advanced voicings).
- Foreign focus: 251 and 736 progressions.
- 👉 Key Deliverable: Transcribe 5 songs (3 local, 2 foreign).
Music Technology (MuTech)
- Explore VSTs and DAWs for music production.
- Tools: FL Studio or Ableton Live.
- 👉 Key Deliverable: Produce one instrumental track using DAWs.

💬 Communication Skills

Record and review presentations to refine articulation, tone, and voice projection.
👉 Key Deliverable: Deliver a 3–5 minute presentation on a technical topic.

🎓 College

Allocate daily study hours for core courses.
👉 Key Deliverable: Complete assignments on time and prep early for exams.

💼 Job

Polish resume and LinkedIn profile.
Start applying for full-time roles and freelance gigs.
👉 Key Deliverable: Secure 3 interviews or freelance opportunities.

Looking Ahead

2025 is a year of intentional growth—professionally, creatively, and personally. With faith, focus, and consistent effort, I believe I can achieve everything I’ve set out to do. 🚀

✨ Let’s make this year amazing! 🎉

Connect With Me

🌐 Portfolio
💼 LinkedIn
🖥️ GitHub

🚀 From Code to Execution: How JavaScript Code Runs in Your Browser

Ernest Yoyowah — Fri, 03 Jan 2025 17:53:12 +0000

## From Developer's Editor to JS Engine

After a program leaves a developer's editor, it undergoes several transformations before being executed by a JavaScript (JS) engine:

Summary of the Process

Transpilation by Babel: Converts modern JavaScript into older versions for compatibility.
Packaging by Webpack: Bundles transpiled code and project assets into deployable files.
Parsing by JS Engine: Breaks code into tokens and generates an Abstract Syntax Tree (AST).
Bytecode Generation by Ignition: Converts AST into bytecode for efficient interpretation.
Interpretation by Ignition: Executes bytecode for fast program startup.
Just-In-Time Compilation by TurboFan: Optimizes hot code into machine code for peak performance.
Execution: The optimized machine code is executed directly by the CPU.

1. Transpilation by Babel

Description: Babel is a popular tool used to convert modern JavaScript code (written using the latest language features) into backward-compatible versions that can run on older browsers or environments. This process is known as transpilation.
Output: Transpiled JavaScript code.

2. Packaging by Webpack (and Other Build Processes)

Description: Webpack is a module bundler commonly used in modern JavaScript development. It takes the transpiled code from Babel, along with other project files (stylesheets, images, etc.), and bundles them into a single output file or multiple files, ready for deployment.
Output: Bundled JavaScript files along with other assets.

Processing by JS Engine

Once the bundled JavaScript code is delivered to a JS engine, the following steps occur:

3. Parsing (Tokenization and AST Generation)

Tokenization (Lexical Analysis): The code is broken down into smaller units called tokens. Each token represents a specific syntactical element (e.g., variables, operators, or keywords).
Syntax Analysis (AST Generation): The tokens are used to create an Abstract Syntax Tree (AST), which represents the syntactic structure of the code. This step also checks for syntax errors in the program.
Output: AST representation of the code.

4. Bytecode Generation by Ignition (Intermediate Representation)

Description: The AST is processed by the Ignition interpreter, which converts it into bytecode, a compact, intermediate representation of the code. This bytecode is designed to be executed efficiently by the engine.
Output: Bytecode ready for execution by Ignition.

5. Interpretation by Ignition

Description: The bytecode generated in the previous step is executed by the Ignition interpreter. This allows for rapid program startup by directly interpreting the bytecode instructions.
Output: Results from executing the bytecode.

6. Just-In-Time Compilation by TurboFan

Description: During execution, frequently used code paths (hot code) are identified. These hot paths are optimized by the TurboFan JIT compiler, which compiles the bytecode into machine code for the target platform. This step significantly improves performance for hot code.
Output: Optimized machine code.

7. Execution of Machine Code

Description: The optimized machine code is executed directly by the CPU, providing the best possible performance for the program.
Output: Final program results.

Key Concepts in the Execution Pipeline

Tokenization: Breaking code into recognizable units (tokens) as part of the parsing phase.
AST Generation: Creating a structured representation of the code for further processing.
Bytecode: An intermediate representation used for quick interpretation by Ignition.
JIT Compilation: TurboFan compiles hot code into optimized machine code for faster execution.
Execution: The final stage where JavaScript code produces its desired outcomes.

The V8 engine combines interpretation and compilation to balance startup speed and execution performance. The pipeline starts with parsing and bytecode generation by Ignition, followed by interpretation, and transitions to optimized machine code execution through TurboFan for hot code paths. This dynamic approach ensures efficient JavaScript execution in modern applications.

DEV Community: Ernest Yoyowah