<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Joseph Akinwole</title>
    <description>The latest articles on DEV Community by Joseph Akinwole (@joebim).</description>
    <link>https://dev.to/joebim</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F622264%2F6d2907dd-be7a-4033-ac0c-cc93b8a96a3d.jpeg</url>
      <title>DEV Community: Joseph Akinwole</title>
      <link>https://dev.to/joebim</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/joebim"/>
    <language>en</language>
    <item>
      <title>Debugging Without Guessing: A Practical Method for Finding the Real Problem</title>
      <dc:creator>Joseph Akinwole</dc:creator>
      <pubDate>Sat, 21 Nov 2026 22:19:20 +0000</pubDate>
      <link>https://dev.to/joebim/debugging-without-guessing-a-practical-method-for-finding-the-real-problem-4ndf</link>
      <guid>https://dev.to/joebim/debugging-without-guessing-a-practical-method-for-finding-the-real-problem-4ndf</guid>
      <description>&lt;p&gt;Every developer eventually runs into a bug that seems to make no sense.&lt;/p&gt;

&lt;p&gt;The page is blank, even though the component looks fine. A function works with one input and fails with another. An error appears far from the code that caused it. The first instinct is often to change something—anything—and see if the problem goes away.&lt;/p&gt;

&lt;p&gt;That instinct is understandable, but random edits can make a small bug harder to find. A more reliable approach is to slow down, gather evidence, and narrow the problem one step at a time.&lt;/p&gt;

&lt;p&gt;Here’s a practical debugging process you can use whether you’re working on a small script, a website, or an unfamiliar codebase.&lt;/p&gt;

&lt;h1&gt;
  
  
  &lt;strong&gt;1. Describe the problem precisely&lt;/strong&gt;
&lt;/h1&gt;

&lt;p&gt;Start by replacing “it doesn’t work” with a specific description.&lt;/p&gt;

&lt;p&gt;Ask yourself:- What did I expect to happen?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happened instead?&lt;/li&gt;
&lt;li&gt;What steps reproduce it?&lt;/li&gt;
&lt;li&gt;Does it happen every time, or only sometimes?&lt;/li&gt;
&lt;li&gt;Did it start after a particular change?
For example, “the form is broken” is hard to investigate. This is more useful:&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;When I submit the sign-up form with a valid email and an empty password, it shows a loading indicator but never displays a validation message.&lt;/p&gt;

&lt;p&gt;A clear description gives you something you can test. It also prevents you from chasing unrelated issues.&lt;/p&gt;

&lt;h1&gt;
  
  
  &lt;strong&gt;2. Reproduce the issue consistently&lt;/strong&gt;
&lt;/h1&gt;

&lt;p&gt;Before changing code, try to make the bug happen reliably. Record the steps and inputs that trigger it.&lt;/p&gt;

&lt;p&gt;If the problem is inconsistent, look for details that vary:- The order in which actions happen&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The data being used&lt;/li&gt;
&lt;li&gt;The browser or device&lt;/li&gt;
&lt;li&gt;Network availability&lt;/li&gt;
&lt;li&gt;Whether the app was freshly loaded&lt;/li&gt;
&lt;li&gt;Whether an earlier action changed the app’s state
A bug that happens “sometimes” may still follow a pattern. Reproducing it turns that pattern into evidence.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you can’t reproduce the issue, avoid making speculative changes. First gather more information, such as logs, error reports, or a record of the steps that led to it.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;3. Read the error message carefully&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Error messages are not always written in friendly language, but they often tell you where to begin.&lt;/p&gt;

&lt;p&gt;Look for:- The error type&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The file and line number&lt;/li&gt;
&lt;li&gt;The function where it occurred&lt;/li&gt;
&lt;li&gt;The values or operation involved&lt;/li&gt;
&lt;li&gt;The first line in the stack trace that belongs to your code
The last line of a stack trace may show where the error surfaced, not necessarily where it began. Read upward and follow the path through your own code.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Search for the exact error text if you need help understanding it. But treat search results as clues, not automatic fixes. A similar error can have a different cause in your project.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;4. Trace the data, not just the screen&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Many bugs are caused by data being different from what the code expects.&lt;/p&gt;

&lt;p&gt;Suppose a function expects a user object with an &lt;code&gt;email&lt;/code&gt; property. The problem might be that the value is &lt;code&gt;null&lt;/code&gt;, the property has a different name, or the data hasn’t loaded yet.&lt;/p&gt;

&lt;p&gt;Follow the value through the steps where it changes:- Where does the data come from?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What shape does it have at that point?&lt;/li&gt;
&lt;li&gt;Which functions transform it?&lt;/li&gt;
&lt;li&gt;Where is it used?&lt;/li&gt;
&lt;li&gt;Does it still match what the next step expects?
Logging a value can help, but log the relevant context too. Instead of printing only &lt;code&gt;undefined&lt;/code&gt;, inspect the object and the code path that produced it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Be careful not to log passwords, access tokens, personal data, or other sensitive information.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;5. Find the smallest failing case&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Complex inputs can hide the cause. Try reducing the problem to the simplest case that still fails.&lt;/p&gt;

&lt;p&gt;If a function processes a long list, test it with one item. If a form has many fields, test only the field that seems related. If a page has several components, temporarily isolate the one involved.&lt;/p&gt;

&lt;p&gt;The goal is to remove details that don’t affect the bug. Once you have a small failing example, it becomes easier to understand and test.&lt;/p&gt;

&lt;p&gt;This is also useful when asking someone else for help. A short example that reproduces the problem is usually more helpful than a large project with no clear starting point.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;6. Change one thing at a time&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;When you make several changes at once, it becomes difficult to know which one mattered.&lt;/p&gt;

&lt;p&gt;Instead, form a small hypothesis:&lt;/p&gt;

&lt;p&gt;I think this value is missing because the request hasn’t completed before the component renders.&lt;/p&gt;

&lt;p&gt;Then make one targeted change or add one observation to test that idea. If the result doesn’t support your hypothesis, undo or reconsider the change before moving on.&lt;/p&gt;

&lt;p&gt;This makes debugging a process of learning, rather than trial and error.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;7. Use breakpoints when logs aren’t enough&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Logs show selected moments. A debugger lets you pause the program and inspect what is happening step by step.&lt;/p&gt;

&lt;p&gt;Breakpoints are useful when you need to check:- Which branch of a conditional runs&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What a variable contains before and after a function call&lt;/li&gt;
&lt;li&gt;How many times a loop executes&lt;/li&gt;
&lt;li&gt;Whether a callback is reached&lt;/li&gt;
&lt;li&gt;Where execution stops or takes an unexpected path
Step through the code slowly and compare what you observe with what you expected. Avoid inspecting every variable in the application; focus on the values connected to your current hypothesis.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;8. Check recent changes&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;If the issue began recently, review what changed around that time. Look at your latest edits, dependency updates, configuration changes, and data changes.&lt;/p&gt;

&lt;p&gt;Version control makes this easier. You can compare the current code with an earlier working version or temporarily test whether a recent change introduced the problem.&lt;/p&gt;

&lt;p&gt;The key is to use the change history as evidence. A recent edit is a reasonable place to investigate, but don’t assume it is the cause until you’ve tested that idea.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;9. Confirm the fix—and check nearby behavior&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;A bug disappearing once is not enough. Repeat the exact steps that originally reproduced it.&lt;/p&gt;

&lt;p&gt;Then test a few nearby cases. If the issue involved an empty password, try a valid password and another invalid input. A fix for one case should not quietly break another.&lt;/p&gt;

&lt;p&gt;Where possible, add a test that captures the bug. That way, if the same issue returns later, an automated check can catch it.&lt;/p&gt;

&lt;p&gt;A useful test should describe the behavior you want, not the implementation detail you happened to change.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;10. Know when to ask for help&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Debugging independently is valuable, but struggling in silence for too long is not.&lt;/p&gt;

&lt;p&gt;When you ask for help, share:- What you expected&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happened&lt;/li&gt;
&lt;li&gt;How to reproduce it&lt;/li&gt;
&lt;li&gt;The relevant error message&lt;/li&gt;
&lt;li&gt;What you have already tried&lt;/li&gt;
&lt;li&gt;A small code example, if possible
That gives someone else a clear starting point and avoids repeating steps you’ve already taken.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;A quick debugging checklist&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Before you finish, ask:- Can I reproduce the bug?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Do I understand the exact expected and actual behavior?&lt;/li&gt;
&lt;li&gt;Have I read the full error message and relevant stack trace?&lt;/li&gt;
&lt;li&gt;Have I checked the values flowing into the failing code?&lt;/li&gt;
&lt;li&gt;Did I test a smaller example?&lt;/li&gt;
&lt;li&gt;Did I change one thing at a time?&lt;/li&gt;
&lt;li&gt;Have I confirmed the fix and checked nearby cases?
## &lt;strong&gt;The real skill is reducing uncertainty&lt;/strong&gt;
Good debugging isn’t about knowing every answer in advance. It’s about asking questions that make the problem smaller and clearer.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Reproduce the issue. Gather evidence. Follow the data. Test one idea at a time. Confirm the fix.&lt;/p&gt;

&lt;p&gt;The next time a bug appears, try resisting the urge to rewrite the whole thing. Start with one precise question:&lt;/p&gt;

&lt;p&gt;What do I know for sure, and what can I test next?&lt;/p&gt;

&lt;p&gt;That question is often the fastest route to the answer.&lt;/p&gt;

</description>
      <category>beginners</category>
      <category>debugging</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Building Delve: Making Language Practice Feel Like an Adventure</title>
      <dc:creator>Joseph Akinwole</dc:creator>
      <pubDate>Sat, 21 Nov 2026 22:07:45 +0000</pubDate>
      <link>https://dev.to/joebim/building-delve-making-language-practice-feel-like-an-adventure-2cgi</link>
      <guid>https://dev.to/joebim/building-delve-making-language-practice-feel-like-an-adventure-2cgi</guid>
      <description>&lt;p&gt;Learning a language takes more than memorising vocabulary. You need opportunities to use what you learn: to read, listen, respond, make mistakes, and try again. But practising can feel intimidating or repetitive, especially when it’s reduced to drills and flashcards.&lt;/p&gt;

&lt;p&gt;That idea was at the heart of &lt;strong&gt;Delve&lt;/strong&gt;, an AI-powered language-learning game I worked on during my internship at HNG. Delve brings language practice into an interactive world where players explore different environments, complete quests, and speak with 3D characters.&lt;/p&gt;

&lt;p&gt;The goal was to make learning feel less like completing a lesson and more like taking part in an experience.## &lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why make language learning a game?&lt;/strong&gt;&lt;br&gt;
Games give people a reason to keep going. A quest creates a goal. A new location encourages exploration. A character gives you someone to talk to.&lt;/p&gt;

&lt;p&gt;These elements can also give language practice more context. Instead of learning a word in isolation, a player might encounter it while trying to complete a task or understand a character. The language becomes part of the situation, which can make practice feel more meaningful.&lt;/p&gt;

&lt;p&gt;That doesn’t mean adding game features automatically makes an educational experience effective. The learning still needs to matter. The game should give players useful reasons to read, listen, and respond—not just reward them for clicking through.## &lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Building a world for practice&lt;/strong&gt;&lt;br&gt;
In Delve, players can explore different worlds and complete quests. Each quest gives them something to work toward, while the environment helps make the experience feel like a place rather than a sequence of exercises.&lt;/p&gt;

&lt;p&gt;This structure creates a natural loop:- Explore a place.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Meet a character or discover a task.&lt;/li&gt;
&lt;li&gt;Use language to understand what’s happening or decide what to do.&lt;/li&gt;
&lt;li&gt;Continue the adventure.
A loop like this can help connect practice to purpose. The player isn’t only answering a question because it appeared on screen; they’re using language as part of moving forward.## &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Making characters part of the learning experience&lt;/strong&gt;&lt;br&gt;
Delve also includes 3D characters. Their presence helps give the world a more social dimension. Instead of practising against a blank interface, players can interact with characters as part of the game.&lt;/p&gt;

&lt;p&gt;That matters because conversation is central to learning a language. People need to get comfortable understanding others and expressing their own ideas. Character interactions can provide a low-pressure place to practise those skills.&lt;/p&gt;

&lt;p&gt;AI can make these interactions feel more flexible than a fixed set of dialogue choices. At the same time, AI in a learning game needs to serve the player’s progress. Interactions should be understandable, relevant to the situation, and helpful when a player gets stuck. The technology is valuable when it supports the learning experience—not simply because it is AI.## &lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Balancing learning and play&lt;/strong&gt;&lt;br&gt;
One of the interesting design challenges in a project like Delve is balance. If the experience feels too much like a traditional lesson, players may lose the sense of adventure. If the game focuses only on exploration and rewards, the language-learning purpose can disappear.&lt;/p&gt;

&lt;p&gt;Quests can help bridge that gap. A well-framed task gives the player a clear objective while creating a reason to use language. Character interactions can do something similar by making communication part of the experience.&lt;/p&gt;

&lt;p&gt;The challenge is to make these pieces work together. The player should understand what they’re trying to do, feel motivated to continue, and have chances to practise along the way.## &lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What I learned from the project&lt;/strong&gt;&lt;br&gt;
Working on Delve during my HNG internship gave me the opportunity to contribute to a project that combines game design and language learning. It also reinforced an important product lesson: features are most useful when they support a clear purpose.&lt;/p&gt;

&lt;p&gt;A 3D character is more than a visual element when the player can interact with them. A quest is more than a task when it creates a reason to use the language being learned. And AI is most meaningful when it helps make the experience more engaging or responsive.&lt;/p&gt;

&lt;p&gt;The project also made me think about how people learn through participation. In many learning experiences, the user reads or watches first and practises later. Delve explores a different approach: put the player in a world where practice is part of what they do.## &lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Looking ahead&lt;/strong&gt;&lt;br&gt;
Delve’s concept points to an exciting possibility: language learning that feels active, social, and connected to a story. Exploring worlds, taking on quests, and interacting with 3D characters can give learners more reasons to engage with a new language.&lt;/p&gt;

&lt;p&gt;For me, the project was a chance to work on an experience with a clear goal: make language practice feel like something people want to return to. I’m proud to have contributed to Delve during my internship at HNG, and I’m excited by the ways interactive experiences can make learning more approachable.&lt;/p&gt;

</description>
      <category>nextjs</category>
      <category>typescript</category>
      <category>threejs</category>
      <category>3d</category>
    </item>
    <item>
      <title>React vs Angular: Tips to help you choose ⚔️💻</title>
      <dc:creator>Joseph Akinwole</dc:creator>
      <pubDate>Sun, 30 Jun 2024 00:10:01 +0000</pubDate>
      <link>https://dev.to/joebim/react-vs-angular-tips-to-help-you-choose-49ca</link>
      <guid>https://dev.to/joebim/react-vs-angular-tips-to-help-you-choose-49ca</guid>
      <description>&lt;p&gt;Web apps are the most preferred for websites in 2024, they are known for their efficiency in building user-friendly apps, just like adding icing to a beautiful wedding cake. In other words, they make the best UI and functionalities that also run faster.&lt;/p&gt;

&lt;p&gt;Today, I will be comparing two notable frontend frameworks for building web applications &lt;strong&gt;ReactJS&lt;/strong&gt; and &lt;strong&gt;AngularJS&lt;/strong&gt; which are both javascript-based frameworks and explore their qualities and uniqueness under the hood as this will be helpful to anyone looking to learn to code with any of both.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;React&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;React shines as a speedy and adaptable JavaScript library for building user interfaces. It mostly works with managing reusable components, making it a great choice for projects that require quick changes and a focus on a smooth user experience. Unlike a full-fledged framework, React offers flexibility, allowing you to integrate it with other libraries and tools during your development process.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Angular&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Angular is all about structure. it is really best at tackling complex web applications because of its strong foundation with built-in features for switching pages, working with dependencies, and more. Angular also works alongside typeScript which still focuses on a more structured code. If you are looking to work on projects that focus more on aligned rules, then angular is your guy 👍.&lt;/p&gt;

&lt;h2&gt;
  
  
  Framework Comparison
&lt;/h2&gt;

&lt;p&gt;To best classify their differences, I will be considering these three simple criteria,&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Structure vs. Flexibility&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Personally, I see Angular as a pre-built Lego set with clear instructions, where every approach follows a particular structure with built-in features. React is the opposite. it's like a big box of regular Legos, giving you more freedom to design and build how you see fit. So if you prefer more flexibility in your code, you should just go for React&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Learning Curve&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Angular has a more steeper learning curve because it is quite comprehensive with strict rules and uses TypeScript which is a superset of JavaScript. This adds more features like type-checking, code quality and more, requiring in-depth knowledge of javascript to use. React is more easier to learn for beginners as it focuses on core JavaScript concepts. The best way to think of it is like learning to ride a bike with training wheels (Angular with TypeScript) versus starting on a regular bike (React with JavaScript).  While the training wheels provide initial support, they might take a bit longer to master. Although, Once you get the hang of React, working with Angular can feel more natural and flexible.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Speed and Performance&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;React is known for its speed, especially in smaller apps, because of its virtual DOM system that helps with updates. While, Angular with its structured framework, might be a bit slower to start, but it can be very efficient for complex applications by providing ways to manage data and components smoothly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Conclusion&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Even though it seems like I'm taking the side of reactJS, I can assure you that both frameworks are exceptional and can equally make fully functional and beautiful applications. Now, you should be able to choose which to learn first as a start to your coding journey and I wish you all the best of luck 👍 &lt;/p&gt;

&lt;p&gt;Want to learn more about coding and development opportunities? Check out these resources:&lt;/p&gt;

&lt;p&gt;HNG Internship Program: &lt;a href="https://hng.tech/internship"&gt;https://hng.tech/internship&lt;/a&gt;, &lt;br&gt;
HNG Hire Platform: &lt;a href="https://hng.tech/hire"&gt;https://hng.tech/hire&lt;/a&gt;&lt;/p&gt;

</description>
      <category>react</category>
      <category>angular</category>
      <category>frontend</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Font Loading API: A Fun and Powerful Tool for Making Your Web Pages Look Amazing</title>
      <dc:creator>Joseph Akinwole</dc:creator>
      <pubDate>Mon, 23 Oct 2023 23:25:19 +0000</pubDate>
      <link>https://dev.to/joebim/font-loading-api-a-fun-and-powerful-tool-for-making-your-web-pages-look-amazing-4a35</link>
      <guid>https://dev.to/joebim/font-loading-api-a-fun-and-powerful-tool-for-making-your-web-pages-look-amazing-4a35</guid>
      <description>&lt;p&gt;The Font Loading API is a JavaScript API that allows developers to load fonts asynchronously. This means that fonts can be loaded in the background, without blocking the rendering of the page. This can improve the performance and user experience of web applications.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Benefits of using the Font Loading API&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;There are several benefits to using the Font Loading API, including:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Improved performance: The Font Loading API can improve the performance of web applications by loading fonts asynchronously. This means that the page can start rendering before all of the fonts have loaded, which can improve the perceived load time of the application.&lt;/li&gt;
&lt;li&gt;Better user experience: The Font Loading API can also improve the user experience of web applications by preventing the "Flash of Unstyled Text" (FOUC). The FOUC occurs when the page is rendered using a fallback font before the desired font has loaded. This can make the page look unprofessional and can be jarring for users.&lt;/li&gt;
&lt;li&gt;Support for multiple fonts: The Font Loading API supports loading multiple fonts at the same time. This can be useful for applications that use a variety of fonts, such as web editors or design tools.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;How to implement the Font Loading API&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;To implement the Font Loading API, you can use the following steps:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Create a new FontFace object for each font that you want to load.&lt;/li&gt;
&lt;li&gt;Set the &lt;code&gt;src&lt;/code&gt; property of each FontFace object to the URL of the font file.&lt;/li&gt;
&lt;li&gt;Call the &lt;code&gt;load()&lt;/code&gt; method on each FontFace object.&lt;/li&gt;
&lt;li&gt;Once all of the FontFace objects have been loaded, developers can use the &lt;code&gt;document.fonts&lt;/code&gt; property to access the loaded fonts.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Here is an example of how to use the Font Loading API to load a single font:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;fontFace&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;FontFace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;MyFont&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;url(my-font.woff2)&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="nx"&gt;fontFace&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;load&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nx"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="c1"&gt;// The font has been loaded successfully.&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;To load multiple fonts at the same time, developers can use the following code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;fonts&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
  &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;FontFace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;MyFont1&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;url(my-font-1.woff2)&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
  &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;FontFace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;MyFont2&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;url(my-font-2.woff2)&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;];&lt;/span&gt;

&lt;span class="nx"&gt;fonts&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;forEach&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;fontFace&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;fontFace&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;load&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nx"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// The font has been loaded successfully.&lt;/span&gt;
  &lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Once the fonts have been loaded, you can then use the &lt;code&gt;document.fonts&lt;/code&gt; property to access the loaded fonts. For example, the following code will get the &lt;code&gt;MyFont1&lt;/code&gt; font:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;myFont1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;document&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;fonts&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;MyFont1&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then use the &lt;code&gt;myFont1&lt;/code&gt; variable to apply the font to elements on the page. For example, the following code will set the font of the &lt;code&gt;&amp;lt;h1&amp;gt;&lt;/code&gt; element to &lt;code&gt;MyFont1&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="nb"&gt;document&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;querySelector&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;h1&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nx"&gt;style&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;fontFamily&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;myFont1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Conclusion&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The Font Loading API is a powerful tool that can be used to improve the performance and user experience of web applications. It is especially useful for applications that use a variety of fonts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Additional tips for implementing the Font Loading API&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Use a fallback font: It is always a good idea to specify a fallback font in case the desired font cannot be loaded.&lt;/li&gt;
&lt;li&gt;Use a font loader: There are a number of third-party font loaders available that can simplify the process of loading fonts asynchronously.&lt;/li&gt;
&lt;li&gt;Optimize your font files: Make sure that your font files are optimized for web use. This can be done by using a tool such as Font Squirrel Webfont Generator.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I hope this guide has been helpful. If you have any questions, please leave a comment below.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>javascript</category>
      <category>api</category>
      <category>font</category>
    </item>
    <item>
      <title>Internships Goals</title>
      <dc:creator>Joseph Akinwole</dc:creator>
      <pubDate>Tue, 17 Aug 2021 11:04:09 +0000</pubDate>
      <link>https://dev.to/joebim/internships-goals-7le</link>
      <guid>https://dev.to/joebim/internships-goals-7le</guid>
      <description>&lt;p&gt;It's zuri internship again! And I'm glad to be part of it. It's been two days since my entry on the frontend pathway and my goal is to learn more on frontend web development and be grounded in my career path as a frontend developer. &lt;br&gt;
     I seek to brighten my design concept and explore many frontend frameworks and frontend tools for making better UI experience. Being able to have the right attitude to work is one important skill for a developer and I will be looking to attain knowledge on important work ethics and how to handle different technical situations I find myself in.&lt;br&gt;
     Most importantly, I would love to connect with a whole lot of awesome people along my field and learn from them. &lt;br&gt;
     I have been able to ground myself in some helpful frontend tutorials which I will be linking below and I'm glad to run this internship. Go! Zuri!&lt;br&gt;
&lt;a href="https://internship.zuri.team"&gt;https://internship.zuri.team&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Git&lt;br&gt;
&lt;a href="https://youtube.com/playlist?list=PLxuUHF3OiqfVlhMh2XaA7gx_NaavKM7C9"&gt;https://youtube.com/playlist?list=PLxuUHF3OiqfVlhMh2XaA7gx_NaavKM7C9&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figma&lt;br&gt;
&lt;a href="https://youtu.be/1MbQaYCCzzI"&gt;https://youtu.be/1MbQaYCCzzI&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Nodejs&lt;br&gt;
&lt;a href="https://youtu.be/fBNz5xF-Kx4"&gt;https://youtu.be/fBNz5xF-Kx4&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;HTML&lt;br&gt;
&lt;a href="https://youtu.be/UB1O30fR-EE"&gt;https://youtu.be/UB1O30fR-EE&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Css&lt;br&gt;
&lt;a href="https://youtu.be/yfoY53QXEnI"&gt;https://youtu.be/yfoY53QXEnI&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;React&lt;br&gt;
&lt;a href="https://www.youtube.com/playlist?list=PLC3y8-rFHvwgg3vaYJgHGnModB54rxOk3"&gt;https://www.youtube.com/playlist?list=PLC3y8-rFHvwgg3vaYJgHGnModB54rxOk3&lt;/a&gt;&lt;/p&gt;

</description>
      <category>javascript</category>
      <category>design</category>
    </item>
  </channel>
</rss>
