Great question! This is a classic JavaScript event loop behavior. `fetch()` is asynchronous and returns a Promise, but it doesn’t block execution — so the JS engine immediately moves to the next line (`console.log('done')`) while the network request happens in the background. To wait for the response, you need to use `.then()` or `async/await`. Would you like a quick example showing both approaches?

Yes, that's expected??nd dangerous. Once you call `delete` on a pointer, the memory it pointed to is deallocated, but the pointer itself still holds the old (now invalid) address. Dereferencing it results in undefined behavior, commonly manifesting as a segmentation fault. To avoid this: 1. **Set the pointer to `nullptr` immediately after `delete`** ??dereferencing `nullptr` will crash predictably (often with a clear null-pointer exception in debug builds), making bugs easier to spot. 2. **Prefer smart pointers** like `std::unique_ptr` or `std::shared_ptr`, which automatically manage lifetime and prevent use-after-free by design. 3. **Use static analysis tools** (e.g., AddressSanitizer with `-fsanitize=address`) to catch these issues during testing. Also, avoid raw `new`/`delete` unless you have a specific low-level need??odern C++ strongly encourages RAII and smart pointers for safety and clarity.

That hanging behavior is almost certainly due to in-flight HTTP requests still being processed when the server abruptly closes its listener ??`http.ListenAndServe` doesn?? wait for active connections to finish. The fix is to use `http.Server` with explicit graceful shutdown: create the server manually, start it in a goroutine, and call `srv.Shutdown()` (not `srv.Close()`) when receiving a signal. `Shutdown()` waits for active requests to complete (with a configurable timeout) before closing the listener. You??l also want to handle signals like `os.Interrupt` or `syscall.SIGTERM`, and set timeouts (`ReadTimeout`, `WriteTimeout`, `IdleTimeout`) to prevent indefinite hangs from slow clients. This pattern is idiomatic Go and avoids connection resets or data loss during deployment rollouts.

Great question ??never hardcode API keys! The standard and secure approach is to use environment variables with a .env file (ignored by Git) and a package like dotenv. First, install dotenv: `npm install dotenv`. Then create a `.env` file in your project root with `GITHUB_TOKEN=your_actual_token_here`, and add `.env` to your `.gitignore`. In your app, load it early: `require('dotenv').config();`, then access it via `process.env.GITHUB_TOKEN`. For production, set the variable directly in your hosting environment (e.g., Heroku config vars or AWS ECS secrets). Bonus tip: Use short-lived tokens or fine-grained GitHub PATs with minimal permissions instead of classic tokens when possible.