{
  "id": 9059490,
  "title": "The Joy of Learning the Basics Again",
  "url": "https://urgent.news/2026/09/22/the-joy-of-learning-the-basics-again",
  "topic": "tech",
  "section": "Tech",
  "published": "2026-09-22T01:28:19.000Z",
  "source": {
    "name": "Dev.to",
    "slug": "dev-to",
    "url": "https://dev.to/sabimantock/the-joy-of-learning-the-basics-again-3o84"
  },
  "original_language": "en",
  "account": "I recently found myself revisiting JavaScript. It wasn't because I hadn't used it before, but because I realized there were many aspects I understood on a surface level but lacked deeper comprehension. Seeing the code but not feeling fully confident in my grasp of it bothered me. Reading JavaScript and comprehending it are two different skills. So, I decided to return to the fundamentals and see if I could fill in those gaps. To my surprise, I found myself enjoying the process more than I anticipated.\n\nStarting with the basics, I revisited simple variable declarations like const userName = 'Sabi'; and const role = 'admin';. These were familiar concepts, but revisiting them with a fresh perspective allowed me to think more deliberately about the differences between const and let. I realized that const variables cannot be reassigned, while let variables can. Understanding the reasoning behind each choice made the concepts stick better than simply memorizing their syntax.\n\nFunctions were another area that revealed some knowledge gaps. I thought I was comfortable with functions, but paying closer attention to the details exposed some areas for improvement. For example, the distinction between parameters and arguments became clearer. In the function checkAccess(role) { return role === 'admin'; }, role is the parameter, while 'admin' is the argument. This simple distinction helped me appreciate the importance of paying attention to the small concepts that often go unnoticed when working with code daily.\n\nArrays and loops were next on my list. Revisiting these concepts reminded me of the power of map(), filter(), find(), some(), every(), and reduce(). These array methods, which I had seen and used before, took on a new level of clarity when I went through them one by one. For instance, using users.filter((user) => user.role === 'admin') to get all admins and users.find((user) => user.name === 'Vandal') to get a specific user became much clearer when I wrote them myself. The same array could be manipulated in different ways based on the desired outcome, and seeing these differences firsthand solidified my understanding.\n\nOne of the more useful moments during this refresher was recognizing callbacks. A callback is simply a function passed into another function for later execution. By recreating the idea manually, I realized that callbacks are not some mystical concept but rather a fundamental aspect of JavaScript functions. This realization made them much less intimidating and easier to work with.\n\nDestructuring, another concept I had used before, stopped feeling like magic during this refresher. I attempted to destructure an array using {}, which led to a mistake that forced me to think more deeply about how JavaScript matched objects and arrays. Objects are matched by property name, while arrays are matched by position. This mistake made me appreciate the underlying mechanics of destructuring and the importance of understanding the differences between objects and arrays.\n\nFinally, spread and rest operators made more sense. Spreading an array, like const updatedUsers = [...users, 'Efo'], creates a new array with the original elements followed by the new element. Destructuring arrays, such as const [firstUser, secondUser] = users, assigns the first element to firstUser and the second element to secondUser. Understanding the distinction between objects and arrays when using these operators helped me grasp their purpose and usage more effectively.",
  "summary": "I’ve been revisiting JavaScript recently. Not because I’ve never used it before, but because I realised there were a lot of things I could recognise when I saw them in code without feeling fully confident that I understood them properly. That distinction started bothering me. I could read JavaScript. I could follow what was happening. But being able to look at code and understand it is not always…",
  "key_points": [],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}