<![CDATA[ tech - freeCodeCamp.org ]]> https://www.freecodecamp.org/news/ https://cdn.freecodecamp.org/universal/favicons/favicon.png <![CDATA[ tech - freeCodeCamp.org ]]> https://www.freecodecamp.org/news/ Eleventy Sat, 23 May 2026 08:50:46 +0000 60 <![CDATA[ What is Technical Debt and How Do You Manage it? ]]> https://www.freecodecamp.org/news/what-is-technical-debt-and-how-do-you-manage-it/ 681e31e668aa6f9f0c37bb12 Fri, 09 May 2025 16:48:38 +0000 You’ve probably heard someone say, “We’ll fix it later.”

Maybe you’ve said it yourself.

In the rush to launch a feature, meet a deadline, or impress a client, you take a shortcut. The code works – for now. The design passes – for now.

But over time, these choices pile up. They slow you down. They make every change harder. That’s technical debt.

Technical debt is a quiet, creeping cost. It doesn’t show up in metrics like churn or conversion rate. But it eats away at your product’s quality, your team’s velocity, and your ability to innovate.

You don’t notice it right away. Then, suddenly, everything feels slower. Nothing is simple anymore.

One bug fix breaks two new things. Engineers groan when they touch certain parts of the code. That’s when you realize you’re in debt.

Let’s talk about what technical debt really is, how it forms, and how you can deal with it before it kills your product.

What Is Technical Debt?

Think of technical debt like financial debt. When you borrow money, you get something now – at the cost of interest later.

In software, it’s the same. You make a quick decision to save time now, knowing it might cost you more effort down the line.

There’s nothing inherently wrong with that. Sometimes, taking on debt is smart. You might need to ship fast to test an idea or respond to the market.

But if you keep borrowing and never repay, the interest builds. And technical debt doesn’t just grow – it compounds. The longer you leave it, the worse it gets.

You don’t just end up paying more later. You slow down your whole team.

Every new feature takes longer. Bugs multiply. Morale drops. And eventually, your product feels fragile. That’s when the real damage begins.

Types of Technical Debt

Not all debt is the same. Some is like a short-term loan – you know you’re taking it and why. Other debt is like a bad mortgage – no one even knows it’s there until things break.

Here are the most common types:

  • Intentional debt — You cut corners to hit a deadline but log it and plan to fix it. This can be healthy if managed well.

  • Unintentional debt — You didn’t realise the shortcut was harmful. Often happens with new tech or unclear requirements.

  • Environmental debt — Your tools, libraries, or frameworks get outdated. Even if your code is clean, it sits on crumbling infrastructure.

  • Process debt — The way you build software becomes inefficient. Poor handoffs, unclear documentation, or weak testing pipelines all contribute.

Recognising which type you’re dealing with helps you prioritise. Not all debt needs immediate repayment. But all of it needs attention.

How Technical Debt Happens

As you can probably imagine, technical debt shows up in many ways.

Sometimes it’s deliberate. You make a tradeoff. You know it’s a shortcut, and you plan to clean it up later. That’s manageable – if you actually clean it up.

But most technical debt isn’t planned. It sneaks in through decisions that feel small in the moment. A rushed feature. A new hire not trained on the codebase. A spec that changes mid-sprint. Over time, these small cracks become deep fractures.

Here’s a simple example:

// Temporary workaround for product discounts
function applyDiscount(price, productType) {
  if (productType === 'electronics') {
    return price * 0.9; // 10% off
  } else if (productType === 'clothing') {
    return price * 0.8; // 20% off
  } else if (productType === 'books') {
    return price * 0.95; // 5% off
  } else {
    return price;
  }
}

This started as a quick fix. But over time, new product types get added with more exceptions.

Soon, you will have twenty if-else branches. It’s fragile. Every change risks breaking something. That’s technical debt.

The worst part? You might not even notice until a year later, when a bug in that logic takes hours to trace. You wonder, “How did this get so messy?” The answer: one shortcut at a time.

A better long-term approach in the above example would be a configuration-driven system or a discount rules engine.

// Config-driven discount logic
const discountRates = {
  electronics: 0.10,
  clothing: 0.20,
  books: 0.05
};

function applyDiscount(price, productType) {
  const discount = discountRates[productType] || 0;
  return price * (1 - discount);
}

Why Technical Debt Can Be Dangerous

Technical debt slows you down. That’s its most visible cost.

A feature that should take a day now takes a week. Simple changes break unrelated things. Your team spends more time fixing than building.

But the real danger goes deeper. Technical debt makes you afraid to touch your code.

Engineers stop refactoring because “it’s too risky.” You start saying no to new ideas because the system can’t handle them. The product becomes rigid. You stop innovating.

It also hurts your team. Developers don’t like working in messy codebases. It leads to burnout. New hires struggle to onboard.

Your best engineers spend their time firefighting instead of creating. Eventually, people leave. And your debt remains.

How to Manage Technical Debt

You can’t eliminate all technical debt. But you can manage it.

First, treat it like real debt. Track it. Prioritize it. Make regular payments.

Start by writing it down. Every time someone takes a shortcut, log it. You don’t need a fancy tool – a shared doc or Jira tag works fine. Just make it visible.

Next, build time into your workflow to pay it off. Use 10–20% of each sprint to refactor or improve the codebase. Don’t wait for a rewrite. Small, steady work adds up.

Code reviews help too. Encourage your team to ask: “Is this a shortcut?” If yes, make a conscious choice. Leave a clear comment. Note the tradeoff. Now it’s not a hidden cost – it’s a known one.

And when you do pay off debt, celebrate it. Make it part of your culture. The same way you’d celebrate shipping a feature, acknowledge when your team makes the codebase better. That builds pride and ownership.

Knowing When to Refactor

You can’t fix all the debt at once. So how do you choose?

Look for signs of pain. If a file breaks every sprint, fix it. If one part of the system takes days to test, improve it. If new hires always get stuck in one module, clean it up.

Focus on the code you touch often. There’s no point polishing a dead feature. But if something is part of your core flow, invest in it.

Also, listen to your team. Engineers know where the pain lives. If someone says, “This part scares me,” take that seriously. Fear in the codebase is a red flag.

When Debt Becomes Fatal

Sometimes, the debt gets so bad that small fixes won’t save you. The system collapses under its own weight. Everything feels slow. Nothing is safe to change. That’s when teams start talking about rewrites.

But rewrites are risky. They take time. They often miss hidden business logic. And they can carry old debt into new code if not done carefully.

If you must rewrite, do it incrementally. Replace modules one at a time. Add tests. Migrate data with care.

And don’t forget why the old system failed. If you don’t fix the culture, the new system will rot too.

Final Thoughts

Technical debt isn’t evil. It’s part of building software. But like financial debt, it needs discipline. You can’t just ignore it and hope it goes away.

Great products aren’t just well-designed. They’re well-maintained. The teams behind them care about quality — not just in what users see, but in what engineers live with every day.

So the next time you say, “We’ll fix it later,” ask yourself: will you? Or are you just borrowing against the future?

Hope you enjoyed this article. Join my newsletter for similar articles and connect with me on Linkedin.

]]> <![CDATA[ Here Are 850+ Ivy League Courses You Can Take Right Now for Free ]]> https://www.freecodecamp.org/news/ivy-league-free-online-courses-a0d7ae675869/ 66d45eb473634435aafcef96 Tue, 14 Jan 2025 06:00:00 +0000 By Dhawal Shah

The 8 Ivy League schools - Harvard, Yale, Princeton, Columbia, Cornell, Dartmouth, Brown, and the University of Pennsylvania - are among the most prestigious universities in the world. In 2025, all 8 Ivy League schools are ranked in the top-20 of the U.S. News & World Report national university ranking. While these institutions are highly selective and difficult to get into, they offer many of their courses online for free.

Using Class Central's database, I've compiled these courses for you. In total, Ivy League schools currently offer over 1,850 courses that have attracted 60 million enrollments and 1.7 million bookmarks. Looking at the data:

  • Brown University (81 courses)

  • Columbia University (56 courses)

  • Cornell University (14 courses)

  • Dartmouth College (231 courses)

  • Harvard University (357 courses)

  • Wharton School of the University of Pennsylvania (3 courses)

  • University of Pennsylvania (21 courses)

  • Princeton University (8 courses)

  • Yale University (1096 courses)

25a4660a-3947-437a-8781-c7932f6f2c86

The Class Central database has over 250,000 online courses.

For those interested in staying updated on new Ivy League course offerings, you can "Follow" our dedicated collection on Class Central.

Note that figuring out how to audit a course for free on platforms such as Coursera can be a bit confusing. So my colleague Pat and I have written a dedicated guide: How to Sign up for Coursera Courses for Free.

In this guide, Harvard's CS50 courses clearly stands out - the first CS50 course has attracted over 6 million learners on edX alone. For that reason, we created a dedicated guide: Harvard CS50 Guide: How to Pick the Right Course (with Free Certificate) where my colleague Manoel reviews the complete lineup of 14 courses, including 10 that offer free certificates of completion.

Also, recently we published a free developer certificates article with thousand of courses, including several from freeCodeCamp, Google, Microsoft, and Harvard.

More Free Certificates

free-certificates-banner

If you don’t find what you need here, browse Class Central’s catalog of over 250K courses or visit our thematic collections:

Without further ado, here are all the free online courses offered by Ivy League institutions.

Brown University (81 courses)

Columbia University (56 courses)

Cornell University (14 courses)

Dartmouth College (231 courses)

Harvard University (357 courses)

Wharton School of the University of Pennsylvania (3 courses)

University of Pennsylvania (21 courses)

Princeton University (8 courses)

Yale University (1096 courses)

]]> <![CDATA[ How to Create Beautiful Box Shadows in HTML and CSS ]]> https://www.freecodecamp.org/news/how-to-create-beautiful-box-shadows-in-html-and-css/ 66d4601d3bc3ab877dae221c Tue, 04 Jan 2022 16:57:11 +0000 By Manu Arora

Whenever you're designing a card in HTML, box shadows play a vital role in making the cards stand out.

Whether its a pricing page card or even an e-commerce product listing card, box shadows can make or break the look and the entire message that that cards need to convey.

Today, let's understand how to make beautiful box shadows and how to make them stand out.

Understanding Box Shadow Syntax

Here's the basic syntax for a box shadow:

box-shadow: 1px 2px 3px 4px rgba(20,20,20,0.4);

There are 5 important parts in the above code snippet. Let's understand what they mean:

  1. Horizontal Offset: 1px in the above example. This indicates how far the shadow will be from the card horizontally. Positive means to the right, negative means to the left.
  2. Vertical Offset: 2px in the above example. This indicates how far the shadow will be from the card vertically. Positive means to the bottom, negative means to the top.
  3. Blur: 3px in the above example. This indicates how blurry the shadow will look. Higher radius means more blur.
  4. Spread: 4px in the above example. This indicates how far the shadow will spread in all directions.
  5. Color: rgba(20,20,20,0.4) in the above example. This determines the color of the shadow. If not supplied, the default text color will be used. Color values can be Hex, RGB, or HSL.

Let's see the above code in action:

How Box Shadows Affect Cards

Consider the two examples here:

Image

The first example has no box shadow, while the second example has a box shadow. The second one appears to be popping out of the screen (that makes it stand out a little as compared to the first one.)

So, if you need your cards to stand out, box shadows can help you make them really pop.

Let's say you're building an e-commerce application and you want your product cards to stand out. Box shadows can help you achieve this and get your customers to notice your products.

Even if your web application requires your cards to be subtle, you can always go with subtle box shadows to give a more pleasing aesthetic feel to the cards.

How to Use Multiple Layers Of Box Shadows

You can use more than one layer of box shadows in your cards – and you'll likely do this a lot.

The syntax to create multiple layers of box shadows look like this:

box-shadow: rgba(240, 46, 170, 0.4) -5px 5px, rgba(240, 46, 170, 0.3) -10px 10px, rgba(240, 46, 170, 0.2) -15px 15px, rgba(240, 46, 170, 0.1) -20px 20px, rgba(240, 46, 170, 0.05) -25px 25px;

Each individual box shadow is separated by a comma (,). You can add as many as you want but I recommend to limit yourself to at most 5.

The above example looks something like this:

Notice the 5 layers beneath the cards that are in descending order of opacity. When done correctly, it can give a different look altogether to your cards.

Now this specific card might not look perfect because it is designed to explain a certain concept. But let's make it more interesting by adding colors to the shadows.

Remember we talked about adding colors by using the rgba() syntax? Let's put it to use here.

Here, Instead of using the values rgba(0,0,0,0,2) which indicates the color (Black in this snippet), I replaced it with rgba(240, 46, 170, 0.2) with varying opacity in decreasing order. This is one way of adding colors – the limit is your imagination.

How to Use Colored Box Shadows

Even though colors can help you by making your cards stand out visually, they're not always the best option. Sometimes, a plain gray shadow works wonders on a white background. But this totally depends on the theme of your website.

Consider a simple blog application with lots of whitespace and general text content. If you have a card that displays blogs on the website, the best way will be to add a simple yet subtle box shadow to the cards to give them a good pop.

For example: consider the below cards taken directly from my website, where I have listed out all the blogs that I've written for freeCodeCamp so far.

Image

My website is simple and does one job – it showcases my personality and what I do. If I go on to add a red box shadow to the above boxes, it might not look that good. But if I use gray shadow with some amount of blur, it just helps it stand out without being too in-your-face.

So how do you use them correctly? Let's look at an example.

In the above example:

  • Background color: rgb(251 113 133);
  • Box Shadow: box-shadow: rgba(254, 205, 211, 0.1) 0px 4px 16px, rgba(254,205,211,0.1) 0px 8px 24px, rgba(254,205,211, 0.1) 0px 16px 56px;

The box shadow is a lighter shade of the background color that we used in the above example. And there are three layers of shadows.

When we have a background color, it's generally a good idea to have colored shadows of a lighter shade of the background color that is being used. This looks better than having a plain white or black shadow.

How to Use Inner Shadows

All the above examples covered shadows that were 'outside' of the card that we were trying to style. But what if we wanted to have shadows on the inside?

You can use inset box shadows if you want to have box shadows within the holding container.

Consider the below example:

The code for the shadow is: 

box-shadow: rgb(204, 219, 232) 3px 3px 6px 0px inset, rgba(255, 255, 255, 0.5) -3px -3px 6px 1px inset;

The keyword inset is used to specify that we want to use the shadow inwards and not the default behaviour that is outwards.

You can cleverly use inward box shadows in your web applications that have some important information to display. Like wells, or some alert that you're trying to show. In that case, the item appears to be embedded inside the webpage.

Box Shadow Examples

Creating box shadows is hard, not because it is difficult but because it requires some design knowledge to get the best out of it.

I recently created an application that is a curated list of beautiful box shadows that can help your cards stand out. Currently the project is rated #2 on ProductHunt and is helping a lot of developers make their cards beautiful and effective.

You can find the project here: Tailwind Box Shadows.

Currently, You can find box shadows in Vanilla CSS and Tailwind JIT code. Click to copy and paste and you're done. There is also a helper utility to convert CSS box shadows to Tailwind box shadows.

Conclusion

I've been using box shadows in almost all of my projects. It is the most underrated thing that I've ever come across. A good box shadow layout can really improve the visual aspects of your application.

If you liked the article, try implementing these shadows in your application and let me know what changes it brought to your app.

If you have any feedback, you can reach out to me on my Twitter and/or my Personal Website.

]]> <![CDATA[ Server Definition ]]> https://www.freecodecamp.org/news/server-definition/ 66c35e8fc337fbd10a4b595f Thu, 18 Mar 2021 06:23:00 +0000 In computing, a server is a computer or computers that send data over a network. This data can be a website, a program or photo file, or even information about the weather for an app on your phone.

Servers listen for requests from clients, which are other computers or devices. When a server hears a request, it reads it and responds by sending data back to the client.

For example, when you enter freecodecamp.org in the address bar, our server hears the request from your browser. Our server reads what page you want and looks for all the data (HTML, CSS, JavaScript, and photos) for that page. Then when everything is ready, it sends that data back to your browser.

Almost any computer with the correct software can act as a server. But the servers behind many popular websites and services are often built with special hardware. This allows the servers to handle many requests at once, and stay online for long periods of time.

]]> <![CDATA[ IT Definition ]]> https://www.freecodecamp.org/news/it-definition/ 66c35895dae03919d93dc094 Thu, 18 Mar 2021 06:20:00 +0000 IT (pronounced I.T.) stands for information technology.

IT is a broad term that refers to jobs that involve technology in business. Developers, network engineers, UI/UX designers, QA testers, and customer support are all IT jobs.

If the job involves computers, technology, and working with data, it's considered IT.

]]> <![CDATA[ The 10 Most Popular Coding Challenge Websites ]]> https://www.freecodecamp.org/news/the-10-most-popular-coding-challenge-websites-of-2016-fb8a5672d22f/ 66d45e04230dff01669057af Tue, 02 Feb 2021 18:30:00 +0000 By Daniel Borowski

A great way to improve your skills when learning to code is by solving coding challenges. Solving different types of challenges and puzzles can help you become a better problem solver, learn the intricacies of a programming language, prepare for job interviews, learn new algorithms, and more.

Below is a list of some popular coding challenge websites with a short description of what each one offers.

1. TopCoder

Image

TopCoder is one of the original platforms for competitive programming online. It provides a list of algorithmic challenges from the past that you can complete on your own directly online using their code editor. Their popular Single Round Matches are offered a few times per month at a specific time where you compete against others to solve challenges the fastest with the best score.

The top ranked users on TopCoder are very good competitive programmers and regularly compete in programming competitions. The top ranked user maintains his own blog titled Algorithms weekly by Petr Mitrichev where he writes about coding competitions, algorithms, math, and more.

2. Coderbyte

Image

Coderbyte provides 200+ coding challenges you can solve directly online in one of 10 programming languages (check out this example). The challenges range from easy (finding the largest word in a string) to hard (print the maximum cardinality matching of a graph).

They also provide a collection of algorithm tutorials, introductory videos, and interview preparation courses. Unlike HackerRank and other similar websites, you are able to view the solutions other users provide for any challenge aside from the official solutions posted by Coderbyte.

3. Project Euler

Image

Project Euler provides a large collection of challenges in the domain of computer science and mathematics. The challenges typically involve writing a small program to figure out the solution to a clever mathematical formula or equation, such as finding the sum of digits of all numbers preceding each number in a series.

You cannot directly code on the website in an editor, so you would need to write a solution on your own computer and then provide the solution on their website.

4. HackerRank

Image

HackerRank provides challenges for several different domains such as Algorithms, Mathematics, SQL, Functional Programming, AI, and more. You can solve all the challenge directly online (check out this example).

They provide a discussion and leaderboard for every challenge, and most challenges come with an editorial that explains more about the challenge and how to approach it to come up with a solution.

Currently, if you don't solve the problem, then you can't see the solution of others. If you also try to check the editorial before solving the problem, then you won't get the point for solving the problem at all.

As an example, here I haven't solved the problem, and I am trying to check others' submissions:

Image

And here, I haven't solved the problem, and I am trying to check the editorial:

Image

HackerRank also provides the ability for users to submit applications and apply to jobs by solving company-sponsored coding challenges.

5. CodeChef

Image

CodeChef is an Indian-based competitive programming website that provides hundreds of challenges. You are able to write code in their online editor and view a collections of challenges that are separated into different categories depending on your skill level (check out this example). They have a large community of coders that contribute to the forums, write tutorials, and take part in CodeChef’s coding competitions.

6. Exercism.io

Image

Exercism is a coding challenge website that offers 3100+ challenges spanning 52 different programming languages. After picking a language that you'd like to master, you tackle the coding challenges right on your machine (Exercism has their own command line interface that you can download from GitHub).

It is a bit different from other challenge websites, however, because you work with a mentor after completing each challenge. The mentor reviews your answers online and helps you improve them if needed. Once your answers have been approved and submitted, you unlock more challenges.

7. Codewars

Image

Codewars provides a large collection of coding challenges submitted and edited by their own community. You can solve the challenges directly online in their editor in one of several languages. You can view a discussion for each challenges as well as user solutions.

8. LeetCode

Image

LeetCode is a popular Online Judge that provides a list of 190+ challenges that can help you prepare for technical job interviews. You can solve the challenges directly online in one of 9 programming languages. You are not able to view other users' solutions, but you are provided statistics for your own solutions such as how fast your code ran when compared to other users' code.

They also have a Mock Interview section that is specifically for job interview preparation, they host their own coding contests, and they have a section for articles to help you better understand certain problems.

9. SPOJ

Image

Sphere Online Judge (SPOJ) is an online judge that provides over 20k coding challenges. You are able to submit your code in an online editor. SPOJ also hosts their own contests and has an area for users to discuss coding challenges. They do not currently provide any official solutions or editorials like some other websites do, though.

10. CodinGame

Image

CodinGame is a bit different from the other websites, because instead of simply solving coding challenges in an editor, you actually take part in writing the code for games that you play directly online. You can see a list of games currently offered here and an example of one here. The game comes with a problem description, test cases, and an editor where you can write your code in one of 20+ programming languages.

Although this website is different than typical competitive programming websites such as the ones mentioned above, it is still popular amongst programmers who enjoy solving challenges and taking part in contests.

This list was based on a few things: my own experiences using the websites, some Google searches, Quora posts, and articles such as this one and this one. I also frequented some forums and subreddits such as r/learnprogramming to see what websites were usually recommended by the users there. Disclaimer: I work at Coderbyte which is one of the websites mentioned above.

]]> <![CDATA[ What is NFC? Near Field Communication Uses, Chips, Tags, and Readers Explained ]]> https://www.freecodecamp.org/news/what-is-nfc-near-field-communication-uses-chips-tags-and-readers-explained/ 66ac883f33a54a9b1a44793a Tue, 03 Nov 2020 18:00:12 +0000 NFC is everywhere these days. You've probably seen it in your phone settings, or heard about it online.

While the use of NFC for things like contactless payments was growing steadily, it exploded early this year due to the Coronavirus pandemic.

In this article we'll go over what NFC is, what it's used for, some creative ways to use NFC, and more.

What is NFC and how does it work?

NFC stands for near-field communication. It is a standard for devices to communicate with each other wirelessly from a very close distance.

NFC is a subset of another technology called RFID, so let's dig a bit into that before circling back to NFC.

What is RFID?

Radio-frequency identification, or RFID, is a generic term for technologies that use radio waves from a reader to track specific tags. These tags all include an antenna and a tiny chip, and can come in many shapes and sizes.

Highway toll payment devices and those plastic things on clothes and other expensive items in stores are some common examples of RFID tags.

Image A diagram of an RFID tag. NFC tags look very similar – Source

If you've ever seen those big devices on either side of a store entrance, those are just big RFID readers. They're constantly transmitting radio waves and listening for a response.

So what happens if you try to leave a store and there's still a tag on the item you bought?

Most RFID tags are unpowered, so when the antenna in the tag picks up radio waves from the reader, it generates a small amount of electricity. That electricity activates the chip inside the tag, and it sends a signal with the information stored on the chip back to the reader.

In this case, when the reader receives a signal back from the tag on your item, it sounds an alarm.

NFC is a newer, high-frequency version of RFID, and also involves both tags and readers.

NFC's higher frequency means that, while it can transfer data much faster than RFID, it only works from a distance of about 4 cm/1.6 in or less. Meanwhile, RFID works from a distance of up to 12 m/40 ft.

What is NFC used for?

There are a lot of use cases for NFC, but here are some of the most common you'll see.

Contactless payments

These days, the most common thing that NFC is used for is contactless payment. Many newer credit and debit cards include an NFC tag, so you can just hold your card just above a payment terminal rather than swipe or insert it.

Contactless payment enabled credit and debit cards have a symbol on them similar to these:

Image _Most contactless payment cards will have a similar symbol on the front or back – Source_

Most modern phones include an NFC chip, which can act as both an NFC reader/writer and tag.

This chip, paired with a mobile payment app like Google Pay, Apple Pay, and Samsung Pay, means that you might not even need to take your wallet out anymore.

Instead, your phone can act as a virtual NFC tag for your credit or debit card, even if said card doesn't have an actual NFC tag inside it.

Whether you use your contactless card or a mobile payment app, every payment you make involves tokenization for extra security.

Tokenization is when your card's information is used to generate a random, temporary token for each transaction. Then, your card or mobile payment app can send that temporary token safely, rather than transmit your actual card number, name, and other sensitive information.

However you choose to pay, using a contactless payment card, a mobile payment app, or inserting your card's chip are all much safer than the old method of swiping.

Interacting with products

Traditionally RFID is used for tracking inventory in warehouses and stores. But once a product leaves the store, its RFID tag is disabled.

A lot of products now include NFC tags for additional interaction after you leave the store. Nintendo's Amiibo figures are probably the most common recent example of this:

Image If this isn't the cutest NFC tag, I don't know what is – Source

When you scan an Amiibo figure with your Nintendo console, you can get special characters, items, or other additional content, depending on the game and figure you use.

Your Nintendo console can also write information back to the NFC tag in your figure, again, depending on the game and figure.

Other companies like Nike have been including NFC tags in things like sports jerseys and sneakers. This allows you to get personalized content based on the product you scan (recent scores for a team, stats for a specific player, and so on), or even check that a product is genuine.

Data transfer

Unlike RFID, which is typically one-way communication between a reader and a tag, NFC allows for two-way communication.

Some phones are able to use NFC to transfer data like contacts or photos between two devices if you touch them together.

Creative uses for NFC

One of the coolest things you can do with NFC is buy a pack of tags online and program them to do different things with your phone.

For example, if you're tired of always giving your WiFi password out to guests, you could program an NFC tag to automatically connect to your network. Then, all your guests need to do is make sure NFC is enabled and hold their phones near the tag.

You could also program NFC tags to control different smart devices around your house. You could have a tag that toggles a smart lamp on or off, or one that sets the thermostat.

The commands triggered by the NFC tags can also be personalized to specific devices. For example, if you like the room a bit cooler than your partner, when you scan the thermostat tag it can lower the temperature. But when your partner scans it, it could raise the temperature to their preferred setting.

There are a lot of other interesting ways to use NFC tags to make your life just a little bit easier. Check out this video for more ideas and to see how to program your own NFC tags in both iOS and Android:

In summary

Though you might not have heard much about NFC until earlier this year (I certainly hadn't), it will likely become the standard we pay for things.

And considering all the cool stuff you can do with a phone and a pack of NFC tags, it's surprising that NFC isn't more widely adopted.

If you end up programming your own NFC tags, let me know what you did and how you did it over on Twitter.

]]> <![CDATA[ MBR vs GPT: What's the Difference Between an MBR Partition and a GPT Partition? [Solved] ]]> https://www.freecodecamp.org/news/mbr-vs-gpt-whats-the-difference-between-an-mbr-partition-and-a-gpt-partition-solved/ 66ac881f2dd2c39dc134e0c1 Mon, 12 Oct 2020 04:12:00 +0000 If you're building a PC, you might have been asked how you want to install your operating system – MBR or GPT?

The differences between an MBR and GPT partition are pretty straightforward. But there's a lot of background information that will help you get a clearer picture about each type of partition table, and when you should choose one over the other.

In this article we'll go into what a partition is, the difference between an MBR and GPT partition, whether you should upgrade from one type of partition to another, and more.

What's a partition?

A partition is a virtual division of a hard disk drive (HDD) or solid state drive (SSD). Each partition can vary in size and typically serves a different function.

For example, in Windows there is usually a small recovery partition and a large file system partition labeled C:. The C: partition is what most people are familiar with, as it's where you usually install your programs and store your various files.

Image Windows Disk Manager – Source

In Linux, there's typically a root partition (/), one for swap which helps with memory management, and large /home partition. The /home partition is similar to the C: partition in Windows in that it's where you install most of your programs and store files.

Image GParted in Linux – Source

If you bought your computer from a store and the operating system is already installed, then the manufacturer has already taken care of the partitions. You don't need to worry about them unless you want to do something like dual-boot Windows and Linux from the same HDD or SDD.

Even if you're installing the operating system yourself, most times the installer will suggest default partitions and partition sizes. Again, you usually don't need to make any adjustments.

Now that you have a high-level overview of what a partition is, we can dive into the differences between MBR and GPT partitions.

Note: I'll be using the term "drive" to refer to both HDDs and SSDs from now on.

An overview of MBR and GPT partitions

Before a drive can be divided into individual partitions, it needs to be configured to use a specific partition scheme or table.

A partition table tells the operating system how the partitions and data on the drive are organized. For example, the screenshots above show the partition tables on the drive, and each individual partition is shown as a rectangular block.

There are two main types of partition tables: MBR and GPT.

MBR stands for Master Boot Record, and is a bit of reserved space at the beginning of the drive that contains the information about how the partitions are organized. The MBR also contains code to launch the operating system, and it's sometimes called the Boot Loader.

GPT is an abbreviation of GUID Partition Table, and is a newer standard that's slowly replacing MBR.

Unlike an MBR partition table, GPT stores the data about how all the partitions are organized and how to boot the OS throughout the drive. That way if one partition is erased or corrupted, it's still possible to boot and recover some of the data.

If you bought your computer within the last five years or so, it's very likely that it's using GPT partition tables rather than the older MBR tables.

Differences between MBR vs GPT partitions

There are a number of differences between MBR and GPT partitions, but we'll cover some of the main ones here.

First, the maximum capacity of MBR partition tables is only about 2 terabytes. You can use a drive that's larger than 2 terabytes with MBR, but only the first 2 terabytes of the drive will be used. The rest of the storage on the drive will be wasted.

In contrast, GPT partition tables offer a maximum capacity of 9.7 zetabytes. 1 zetabyte is about 1 billion terabytes, so you're unlikely to run out of space anytime soon.

Next, MBR partition tables can have a maximum of 4 separate partitions. However, one of those partitions can be configured to be an extended partition, which is a partition that can be split up into an 23 additional partitions. So the absolute maximum number of partitions an MBR partition table can have is 26 partitions.

GPT partition tables allow for up to 128 separate partitions, which is more than enough for most real world applications.

As MBR is older, it's usually paired with older Legacy BIOS systems, while GPT is found on newer UEFI systems. This means that MBR partitions have better software and hardware compatibility, though GPT is starting to catch up.

We'll take a brief look at both Legacy BIOS and UEFI a bit later in the article.

Should you upgrade from MBR to GPT?

If one of your drives is currently using an MBR partition table, you might be asking yourself if you should upgrade to the newer GPT standard.

In short, probably not. As the saying goes, if it ain't broke, don't fix it.

It's very easy to ruin the MBR sector of the drive, making it impossible to boot up again. Then you'll either need to create a recovery USB drive with Windows or Linux and try to repair the MBR, or completely wipe the drive and reinstall the operating system.

Speaking from experience, it's not worth the headache.

That said, there are some cases where you might consider upgrading from MBR to GPT.

For example, maybe you want to upgrade your drive to one that's greater than 2 terabytes, or you need more than 26 partitions. Even in these cases, you'll need to make sure that your hardware can even support a GPT partition table and a UEFI BIOS.

If you've done the research are positive you want to make the jump to GPT, make sure you have a backup of your drive and all important data. Worst case scenario, you'll be able to roll back without having to reinstall everything and start from scratch.

An overview of BIOS

I've mentioned BIOS a few times before. While it's a bit outside the scope of this article, a basic understanding of BIOS is necessary to understand one of the last main differences between MBR and GPT partitions.

BIOS stands for Basic Input/Output System, and is the software that's stored on a chip on a computer's motherboard that runs when you first turn it on.

Image A BIOS chip on a Gigabyte motherboard – Source

The BIOS does things like configure the keyboard, mouse, and other hardware, set the system clock, test the memory, and so on. Then it looks for a drive and loads the boot loader on the drive, which is either an MBR or GPT partition table.

Usually when you first turn on your computer you'll see a logo from either your computer or motherboard's manufacturer.

Often there's a message below the logo saying which key to press to configure the computer's BIOS. This key is usually Delete, Escape, or F2, though it varies by manufacturer.

As mentioned previously, there are two main types of BIOS – Legacy BIOS and UEFI BIOS:

Image A Legacy BIOS configuration screen – Source

Image A UEFI BIOS Configuration screen – Source

Legacy BIOS are older, and are entirely keyboard driven. They're usually simple in terms of UI, and have either a black or blue-screen-of-death background color.

UEFI stands for Unified Extensible Firmware Interface, and can be thought of as a newer type of BIOS. UEFI often includes graphics to show fan speed, temperature, and CPU clock speeds, and can sometimes be controlled with a mouse or trackpad.

MBR and GPT BIOS

Because MBR is an older standard, it's paired with Legacy BIOS systems (and Legacy BIOS can only access drives with an MBR partition). This is not necessarily a bad thing, as support for Legacy BIOS is better.

But again, one of the most obvious limitations of MBR partitions is that it can only handle drives that are up to 2 terabytes.

The newer GPT standard is paired with UEFI BIOS systems. Though support for both GPT and UEFI BIOS is not as great as MBR/Legacy BIOS, it's gaining ground.

More manufacturers are switching over to UEFI BIOS, which in turn requires drives to use the newer GPT format. But requirement for GPT formatted drives comes with the advantage of a much higher capacity and up to 128 partitions.

In closing

While understanding the difference between MBR and GPT partitions is a bit like peeling an onion, hopefully you got through it without tearing up.

If all you want is a quick reference for the differences between MBR and GPT partitions, here's a handy table:

MBRGPT
Maximum capacity2TB9.7ZB (~9.7 billion terabytes)
Maximum partitions26128
Partition/boot data locationAt the beginning of the driveThroughout the drive
BIOS typeLegacy BIOSUEFI

And please, don't be like my younger self – make sure you have a backup before you mess around with your partitions. Actually, make two backups.

]]> <![CDATA[ How to Test and Play with Web APIs the Easy Way with Postman ]]> https://www.freecodecamp.org/news/how-to-test-and-play-with-web-apis-the-easy-way-with-postman/ 66b8e36e47e3b55b9fb6ee45 Tue, 30 Jun 2020 16:34:32 +0000 In a world where static websites and apps increasingly depend on separately maintained APIs, it can be hard to figure out how they work by just playing around in the browser.

So how can we use Postman to both test our existing APIs and understand how they work?

What is Postman?

Postman is a tool teams can use to reliably test APIs using easy to use configurations. It comes stocked with features you would expect when dealing with APIs, including authentication, setting headers, customizing the payload, and a bunch more that help reduce the friction of using an API.

And it’s not just for testing. The beauty is that this can be used for many aspects of working with APIs for many different members of the team. Maybe a Project Manager wants to verify that things work or might find it easier to make a change straight with the API, or a QA Engineer needs to make sure everything still works, or a developer wants to actively make changes while working on the API itself.

The best part about it – Postman provides collaboration features. The free tier includes exporting and importing collections of saved API requests as well as creating shared links. If you're part of a team, they have paid tiers that allow you to sync up your collections to make sure everyone has the most recent and up to date collection.

What are we going to build / learn?

We’re going to walk through two different example APIs to cover the concepts of Postman.

First, we’ll walk through some simple HTTP requests with a public API for Pokémon.

We’ll then use the Yoda Translator API for one part to demonstrate how to make specific HTTP requests.

Once we understand how the basics work, we’ll use the Lord of the Rings API to learn how authentication works with APIs. For this, you’ll need to register for a free account for an API key.

Part 0: Getting set up with Postman

Before we get started, you’ll need Postman in order to follow along with this walkthrough. The good news, is Postman is available for free on Mac, Windows, and Linux, so you should be able to find a version that works for you.

Get Postman: https://www.postman.com/downloads/

Once downloaded, go through the standard installation instructions, open it up, and we should be ready to go!

Part 1: An introduction to Postman

The first time you open up Postman you’ll immediately be shown a launchpad with a bunch of options to get started.

Image

It might seem a bit overwhelming, but let’s break down some of the key concepts that we’ll need to know.

Requests

A request is kind of what it sounds like, it’s a specific API request. This will be a single type of request, whether it’s a GET or POST to a specific endpoint. You’ll want to create new requests for each type of endpoint which will allow you to move between them when testing.

Collections

A collection is a group of requests. This is handy for organizing your requests into different groups. This could be as simple as two totally different APIs (ie. Twitter vs Slack) or it could be two different groups of APIs for a single API (ie. Twitter Tweets API vs Twitter Accounts API).

Authorization

Authorization is how requests are authenticated with an API, whether by a person making a request or by a computer making that request on your behalf. This commonly comes in the form of an API key which can be a static value assigned to your account or dynamically generated with tools like OAuth.

Environments

Environments will allow you to configure your endpoints to use specific variables that make it easier to use the same endpoints between different environments. For instance, you might have the same /profile endpoint on both your production and development environments, but they have different domains. Environments lets you manage a single request with a variable domain.

Workspaces

We won’t go too far into workspaces in this post, but it allows you to manage and organize different sets of collections. Imagine if you want to use Postman for both work and a personal project, you might have a Work workspace as well as a Personal workspace.

For the purposes of this article, we’ll be covering Requests, Collections, and Authorization.

Part 2: Creating a new Postman request to GET info about Squirtle

Now that we have a better understanding of the different terminology, let’s actually create a request.

At the top left of the UI you should see a but orange button that says New. Go ahead and click that and then select Request.

Image

Before we get into the request itself, it requests a few things.

This first thing requires is a name. We’re going to start off by requesting information about the Pokémon Squirtle, so let’s name this “Pokémon - Squirtle”.

It also requires a collection, so click Create Collection and let’s name the collection “My Favorite Pokémon”.

Image

Click the orange checkmark button next to the collection name then hit Save.

At this point we’ll have a new request, so let’s build that request.

There are two things we’ll first need to fill out for our first request:

Image

And once you make sure those are correct, you can simply hit the blue Send button on the right and we’ve successfully made our first request!

Image

We immediately get a few things we can see:

  • Body: at the bottom we should now see the response body of the API request. For our Squirtle API, we should have a JSON object with data like abilities, base_experience, and forms.
  • Status: on the right, we should see the HTTP status code. “200 Ok” is a good sign and it means it was successful!
  • Time: simply how long the request took to finish
  • Size: the size in KB (in our example) of the response data

You can also hover over Status, Time, and Size and get a more in depth look at each option.

So we made our first request!

Once thing to notice before we move on is that our request looks like it’s in a browser tab. If we’re done with that particular request, we can close the tab and click Save to make sure all of our changes are there for next time!

Part 3: Creating a collection of requests in Postman for the PokéAPI

Now that we’ve created a request, let’s create a collection of them. Technically we already had to create a new collection for Part 2, but we’ll create a new one to learn how collections themselves work.

At the top left of the UI, click the orange New button again and select Collection.

Image

Similar to a request, it asks for a name so let’s call this “PokéAPI”. Optionally you can add a description, then click Create at the bottom.

Image

On the left, you’ll now see your collection. You can select and expand the folder since we’ll be working with it.

Before we add a request, the PokéAPI has different types of requests, so it makes sense to organize it a little more thoroughly. So let’s click the three dots next to the PokéAPI collection and select Add Folder.

Image

Similar to the others, this asks for a name. Folders are kind of like collections inside of a collection, so you get similar options. Let’s name this one “Pokémon” and click the orange Save button like before.

Now let’s add our requests! First, click the three dots next to the Pokémon folder, similar to how we added a folder to the collection, but this time select Add Request.

Image

Let’s name this request “Pokemon”. While it might be confusing that we have a Pokemon request inside of the Pokémon folder, Pokemon is just one of the endpoints of the Pokémon group.

Now, let’s use the same exact API that we used with our Squirtle request before:

And similar to before, when we hit the blue Send button, we should see a successful request!

Image

Now let’s add another request. Follow the same process as before to create a new request under the PokéAPI Pokémon folder and let’s name this request “Abilities”.

If you scroll through the response from the first Squirtle endpoint, you see a lot of other API urls. At the top, we have abilities and we have two different ones — “torrent” and “rain-dish”.

Choose your favorite Squirtle ability and copy the url value into the new Abilities request we just created, I’m going to use rain-dish.

We can leave the Request Type as GET, hit the blue Send button, and we can again see a successful response!

Image

Here we get a lot of information about our Squirtle ability Rain Dish and some of the details come in different languages which is cool!

So now we have a new PokéAPI collection with a Pokémon folder representing the group of Pokémon API endpoints including Pokemon and abilities.

We’re going to stop Part 3 with those 2 requests, but feel free to continue on and add as many of the PokéAPI requests as you’d like!

Part 4: Making POST requests with Postman to translate sentences to sound like Yoda

So far we’ve only made GET requests, but what if we wanted to make a POST request where we need to actually send some data?

For making a POST request, we’re going to use the Yoda Translator API from funtranslations.com. While this API only takes a single parameter, it’s still a good public endpoint we can use to understand the concept.

First, let’s create a new collection with a new request:

  • Collection: Fun Translations
  • Request: Yoda

This time, instead of a GET request, our request configuration will be:

Image

Now this time, if we hit the blue Send button, we’ll notice we don’t get a successful 200 response, we get a 400!

Image

We never actually set up any data to be posted to the API and it requires that data, so let’s add it.

Right below the Request URL, click Body. Then instead of none, select raw as the body type. Finally, on the far right of the types, change Text to JSON.

Image

Then, in the space below it, you can add the following:

{
    "text": "Hello, I am learning how to test APIs with Postman!"
}

And now click the blue Send button again and we get a successful response!

Image

We can apply this concept to pretty much any API. Postman doesn’t only permit you to post JSON, it allows you to use the other formats that we see listed in the Body Type section, meaning you have a lot of options depending on what the API you’re using requires.

Part 5: Authenticating requests to the Lord of the Rings API with an API Key

For the rest of the walkthrough, we’re going to use the Lord of the Rings API.

First up, the Lord of the Rings API requires authentication in order to make requests using an API key. So to start, you’ll before we dive in, you’ll need to go create a free account.

https://the-one-api.herokuapp.com/sign-up

Once you sign up and log in, the first thing you’ll see is your API key! Either copy this key down or remember where you can find it for later. If you leave the page, you can always grab it by navigating to Welcome and then Account in the navigation of the API website.

To get started, let’s first create a new collection and request:

Once you’re set with the above, click Send, and you’ll notice immediately it gives a response that says 401 and that it’s unauthenticated.

Image

Because this API requires the API key, this is exactly what we expected. So let’s click on the Authorization tab. We can then select a Type of Bearer Token, and on the right, we can paste in our key that we just set up with the Lord of the Rings API.

And as soon as we hit Send, we now see a successful response!

Image

This worked really great, but what if we have a bunch of requests that use a single key. Do we have to manage that on each request?

Instead of managing it on each individual request, we can manage it on the collection. Let’s first build another request.

Under our Lord of the Rings collection and in the Movie folder, create a new request:

In this request, let’s use an ID from the response of the first request, I’m going to use 5cd95395de30eff6ebccde5b which is the ID of The Two Towers, so the request URL will look like:

https://the-one-api.herokuapp.com/v1/movie/5cd95395de30eff6ebccde5b

Image

Now, instead of setting our token in the request Authorization, we’re going to leave the type as Inherit auth from parent. Click on the three dots next to the collection and select Edit.

Image

Here, we’re going to do the same exact thing we did with the first request but on the Collection configuration. Select the Authorization tab, under type select Bearer Token, and in the Token field again paste your token.

Image

Finally, click Update and hit the blue Send button again and we can see a successful request!

Image

We can now go back to our All Movies request and update the Authorization to use a Type of Inherit auth from parent and it should still continue to work!

Image

What else can we do with Postman?

While I covered a lot of the basics, there’s quite a lot more you can do with Postman. Here are a few of my favorites.

Environment Variables

If you’re working as a developer on a project, it’s likely that your team uses multiple environments, such as a development and production environment. Instead of creating and maintaining completely separate requests, you can add an environment variable and instead change that variable when switching between environments!

Variables apply to many scenarios, but that’s a common use. Check out Postman’s docs to learn how.

https://learning.postman.com/docs/postman/variables-and-environments/variables/

Import and Export Collections and Data

A great thing about Postman is once you have your requests all organized, you can export them for others to use. This also means that you can import collections from other team members. This makes it much easier to make sure everyone’s using the same collection.

Bonus: you can even store these files in a Git repository, as they’re just JSON.

But keep in mind - if you’re using Authorization on the collection like we went over in this guide, you’ll want to make sure you don’t include that when exporting your collection.

https://learning.postman.com/docs/postman/collections/importing-and-exporting-data/

Automated testing

Once you have a set of requests in a collection and even better, if you’re storing them in Github, you can begin to use those requests as part of a way to manage automated testing of your API.

While there are a few solutions for doing this, Postman includes a Collection runner built right into the app and Newman is a command line tool that lets you run tests right from the terminal.

https://www.postman.com/use-cases/api-testing-automation/

What’s your favorite way to test and play with APIs?

Share with me on Twitter!

]]> <![CDATA[ How to Create a Travel Bucket List Map with Gatsby, React Leaflet, & Hygraph ]]> https://www.freecodecamp.org/news/how-to-create-a-travel-bucket-list-map-with-gatsby-react-leaflet-graphcms/ 66b8e3580cedc1f2a4f7069b Tue, 23 Jun 2020 14:45:00 +0000 Traveling is fun and we all have a lot of places we want to visit, but rarely do we have time to do it all at once. That’s what bucket lists are for! How can we create a custom mapping app that we can show all of our the destinations on our bucket list?

Note: As of July 2022, GraphCMS is now Hygraph.

What are we going to build?

We’re going to build a mapping app with Gatsby managed by a CMS that will both display markers on a map and show our locations in a simple text-based list for our bucket list locations.

Image Demo of a Travel Bucket List mapping app

We’ll spin up the app with a Gatsby Starter for Leaflet and then we’ll use GraphCMS to create and manage the list of locations for our map!

Woah, a mapping app?

Yup. If you haven't played with maps before, don't be discouraged! It's not as bad as you probably think. If you'd rather start with mapping basics, you can read more about how mapping works first.

Step 1: Creating a new app with Gatsby Starter Leaflet

We’ll start off with Gatsby Starter Leaflet. This is going to give us a basic React application with our mapping tools already built in.

Creating a new Gatsby app with Gatsby Starter Leaflet

To get started, navigate to where you want to create your new app and run:

gatsby new my-travel-bucket-list https://github.com/colbyfayock/gatsby-starter-leaflet

Note: you can replace my-travel-bucket-list with whatever you want. This will be used to create the new folder for the app.

Once you run that, Gatsby will pull down the Starter and install the dependencies. After it’s complete, navigate to that directory and run the development command:

cd my-travel-bucket-list
yarn develop
# or
npm run develop

Once it’s finished location, your app should be ready to go!

Cleaning our some demo code

Because we’re using a Starter, it has a little bit of demo code. Let’s clean that out to avoid any confusion.

Open up the src/pages/index.js file.

First, remove everything inside of mapEffect except the first line and set up an alias for leafletElement to map:

async function mapEffect({ leafletElement: map } = {}) {
  if ( !map ) return;
}

With that gone, we can remove the markerRef definition at the top of the IndexPage component, remove the ref={markerRef} prop from our <Marker> component, and the useRef import next to React.

Now, we can remove all of the variables that start with popup and time, including:

  • timeToZoom
  • timeToOpenPopupAfterZoom
  • timeToUpdatePopupAfterZoom
  • popupContentHello
  • popupContentGatsby

Lastly, you can remove all of the following lines:

import L from 'leaflet';
...
import { promiseToFlyTo, getCurrentLocation } from 'lib/map';
...
import gatsby_astronaut from 'assets/images/gatsby-astronaut.jpg';
...
const ZOOM = 10;

Once done, we should be ready to go with a basic app with a map!

Image New app with Gatsby Starter Leaflet

Follow along with the commit!

Step 2: Creating and managing a list of travel locations with GraphCMS

Creating a GraphCMS account

To get started with GraphCMS, you’ll need an account. I’m not going to walk you through this part, but the good news is they have a generous free tier that makes it easy to sign up for us to use for our demo!

Sign up for GraphCMS

Alternatively, if you already have an account, you can make sure you’re logged in.

Creating a new GraphCMS project

Once logged in, we’ll want to create a new project. We’re going to create one manually, so once at the GraphCMS Dashboard, select Create new project:

Image Creating a new project in GraphCMS

Here, you can enter whatever you’d like for the Name and Description such as:

  • Name: My Travel Bucket List
  • Description: The locations that I want to travel to some day!

Below that you’ll see a map where you’ll select a Region. This is where your database data will live, so while it probably doesn’t matter too much for our purposes, you can choose the one that’s closest to you.

Image Configuring a new project in GraphCMS

After you select your options, go ahead and click Create Project.

Image Selecting the Personal plan in GraphCMS

Next, you’ll be presented with billing options. Since we’re just creating a demo, under Personal select Continue at which point we’ll be dropped into our new GraphCMS project dashboard.

Creating a new Content Model Schema with GraphCMS

In GraphCMS, a Content Model refers to a specific type of data that has specific properties associated with it. In our case, our Model will be a Destination, which will be defined by a Name and a Location.

First, navigate to the Schema section of GraphCMS in the left sidebar and select Create Model.

Image Creating a new Schema Model in GraphCMS

Once selected, you’ll see a popup that asks for a bit more information. Here, you can type in “Destination” as the Display Name, which will also fill in most of the other fields. We’ll leave those as is.

Image Configuring a new Model in GraphCMS

Feel free to add a description if you’d like, but it’s not required. Then select Create model.

Now that we have our Model, we need our properties.

First, select Single line text in the right list of fields and add a Display Name of “Name”. This will also fill out App Id which you can leave as is. Then click Create.

Image Adding and configuring a new text field in GraphCMS

Next, scroll down in the field options on the right and under Location select Map. Add “Location” as the Display Name, which will set the App Id as “location” which you can leave as is. Then same as before, click Create.

Image Adding and configuring a new map field in GraphCMS

Now we have a Content Model which we’ll use to create our locations!

Image Destination content Model in GraphCMS

Creating our locations

Finally, let’s create our locations. Navigate over to Content in the GraphCMS dashboard, make sure you’ve selected Destination under System (should be the only one), and select Create New.

Image Create new Destination Content in GraphCMS

Now we can start adding all of our locations! First, add the name of your location in the Name field, then you can use the Search box under Location to find that location on the map.

Image Adding a new Destination Content item in GraphCMS

Once you’re good, hit Save and publish. This will create your first location!

Follow those same steps and create as many locations as you want.

Image List of Destination Content items in GraphCMS

We’ll use these for our map and bucket list.

Step 3: Querying our GraphCMS location data with Gatsby and GraphQL

Now that we have our locations, let’s use them!

Adding a plugin to Gatsby to query our GraphQL data

First, we need to add a new plugin to our Gatsby project to query our GraphQL data. In your terminal make sure your development server isn’t running and run:

yarn add gatsby-source-graphql
# or
npm install gatsby-source-graphql

Next, open up your gatsby-config.js file in the root of your project and add the following to your plugins:

{
  resolve: 'gatsby-source-graphql',
  options: {
    typeName: 'GCMS',
    fieldName: 'gcms',
    url: '[API ENDPOINT]',
  }
}

This will be what sources our data from GraphCMS, but we need an endpoint.

Finding our API endpoint for GraphCMS

Open back up your browser and head over to your GraphCMS project. After selecting Settings in the left navigation, select API Access.

Image API Access in GraphCMS

Before we copy our API Endpoint, first we need to update our permissions so we can query our API. Under Public API Permissions, check the box next to Content from stage Published and click Save.

Image Configuring API permissions in GraphCMS

Next, copy the URL under Endpoints:

Image Copying API Endpoint in GraphCMS

And paste that in to your gatsby-config.js file that we modified above:

{
  resolve: 'gatsby-source-graphql',
  options: {
    typeName: 'GCMS',
    fieldName: 'gcms',
    url: 'https://[region-id].graphcms.com/v2/[project-id]/master',
  },
},

Note: your URL will have actual values inside of [region-id] and [project-id].

Save your gatsby-config.js file and start your development server backup (yarn develop) and we’re ready to go!

Querying our locations via GraphQL

Finally, let’s actually query our data so that we’ll be able to use it in our app.

We’re going to create a new React Hook that we’ll be able to use to grab our locations anywhere within our app.

Under src/hooks/index.js, add the following line to the existing list:

export { default as useDestinations } from './useDestinations';

This will allow us to more conveniently import our hook which we’ll create next.

Under src/hooks, create a new file useDestinations.js and paste in this code:

import { graphql, useStaticQuery } from 'gatsby';

export default function useDestinations() {
  const { gcms = {} } = useStaticQuery( graphql`
    query {
      gcms {
        destinations {
          id
          name
          location {
            latitude
            longitude
          }
        }
      }
    }
  ` );

  let { destinations } = gcms;

  return {
    destinations,
  };
}

Here, we’re:

  • Importing the graphql and useStaticQuery utilities from Gatsby
  • We’re creating a new function (or hook) that is exported by default
  • In that function, we’re using useStaticQuery to create a new GraphQL query which asks GraphCMS to return the data structure we defined.
  • That query returns a value which we destructure immediately to grab the gmcs object
  • We destructure destinations from gmcs and return it as part of a new object from our hook

With this, we can now use our hook anywhere in our app!

Head over to your src/pages/index.js file, first import our new hook:

import { useDestinations } from 'hooks';

And at the top of the IndexPage component, query our data:

const { destinations } = useDestinations();

This puts all of our locations into the destinations variable. We can test that this works by console logging it out:

console.log('destinations', destinations);

And once we open up our browser and look in our web developer tools console, we can see our location data!

Image Logging destinations data to the web console

Step 4: Creating a bucket list of destinations and adding them to the map

We’re going to start with creating a simple text list of our destinations. This will let us see all of our destinations in an easy to read format.

Creating a text list of our destinations

Inside of our IndexPage and above “Still Getting Started?”, let’s add the following code:

<h2>My Destinations</h2>
<ul>
  { destinations.map(destination => {
    const { id, name } = destination;
    return <li key={id}>{ name }</li>
  })}
</ul>

This code:

  • Adds a new header for our list
  • Creates a new unordered list
  • Loops through our destinations and creates a new list item for each destination that include’s the location’s name

Once we hit save and reload, we should see our list under our map!

Image New basic list of destinations in the app

The list looks a little odd though right? We probably want to format it a little better to fit into the page.

Open up src/assets/stylesheets/pages/_home.scss and inside of the .home-start class, add:

.home-start {

  ...

  ul {
    list-style: none;
    padding: 0;
    margin: 1.2em 0;
  }

Let’s also modify the h2 to space things out a little better:

.home-start {

  ...

  h2 {

    margin-top: 2em;

    &:first-child {
      margin-top: 0;
    }

  }

Once you hit save and reload, it should look a little better.

Image Destinations in the app with cleaned up styles

Feel free to make additional changes, but we’ll leave it there for now.

Adding our destinations to the map

Now we can finally add our destinations to the map!

Inside of our <Map> component, we already have a <Marker>. This allows us to easily add a marker to the map given a position. We’ll take this concept and combine it with our text list to add our locations to the map.

Let’s update our <Map> code to match the following:

<Map {...mapSettings}>
  { destinations.map(destination => {
    const { id, name, location } = destination;
    const position = [location.latitude, location.longitude];
    return <Marker key={id} position={position} />
  })}
</Map>

Here we:

  • Loop through our destinations to dynamically create a new list of components inside our <Map>
  • Inside each loop instance, we destructure our date from destination
  • We create a new position array with the latitude and longitude
  • Create a new Marker where we use our position to add it to the map

This gives us our markers on the map!

Image Markers for each destination in the mapping app

But we want to know what each of those locations are, so let’s also add a popup to each marker that will show the name.

First, we need to import Popup from react-leaflet:

import { Marker, Popup } from 'react-leaflet';

Then, let’s update our <Marker> component to return:

return (
  <Marker key={id} position={position}>
    <Popup>{ name }</Popup>
  </Marker>
);

And once we save and open back up our map, you can now click on each marker and see our destinations name!

Image Popup for each destination marker in the mapping app

Before we’re done, center the map

Previously, our demo map centered on Washington, DC. Let’s update that to the center of the world since our map doesn’t focus on the United States.

Update the LOCATION variable to:

const LOCATION = {
  lat: 0,
  lng: 0,
};

And with that, we have our map!

Image Final mapping app with markers and popups for each destination

Follow along with the commit!

What else other features can we add to our app?

Add a way to check off each location

Inside GraphCMS, you can add a new field to your Destination content model that allows you to select whether you visited each location or not.

With this value, we can add it to our query and update our map with some kind of indicator like a checkmark to show that we’ve checked it off our bucket list!

Customize your map background styles

We’re using a public version of OpenStreetMap which is open source, but Mapbox offers some cool maps we can use to make it look a little more impressive.

If you want to get started changing your map styles, you can check out this other walkthrough of mine to learn how to use Mapbox.

Check out the blog post or watch the video!

Style the map markers with a custom image

You can check out my video walk through on how to change the markers to a custom image.

Take that a step further and use the feature above to dynamically show a different marker image when you’ve checked off a location.

Check out the video on Egghead.io!

Want to learn more about maps?

Check out some of my other tutorials and videos:

What’s on your travel bucket list?

Let me know on Twitter!

]]> <![CDATA[ Front End Developer vs Back End Developer – Definition and Meaning In Practice ]]> https://www.freecodecamp.org/news/front-end-developer-vs-back-end-developer-definition-and-meaning-in-practice/ 66b8e3260cedc1f2a4f70691 Thu, 18 Jun 2020 14:45:00 +0000 Websites and applications are complex! Buttons and images are just the tip of the iceberg. With this kind of complexity, you need people to manage it, but which parts are the front end developers and back end developers responsible for?

The many layers of development

Whether you’re working on a website or a native iOS app, all development environments share a common theme — there’s a front end to an application and a back end.

This line can get blurry, especially given the rise of javascript and the serverless world. With the tooling somewhat merging together, we might sometimes wonder if we’re a full stack developer.

But we’re not all full stack

As much as we might all want to be, we’re not all full stack developers. Personally, I find myself able to be productive in the back end of an application, but it’s not my strength and I much prefer to be heads down building UIs.

And some people are the opposite, where they are strongest dealing with building APIs in the back end of an application and while they can build out a UI, it might be more of a prototype-like experience than a fleshed out application.

So what is the difference between Front End Development and Back End Development?

Even if you are a full stack developer, that doesn’t mean there’s not a division of responsibilities.

Image Front End Engineer vs Back End Engineer

So what do those look like?

What is Front End Development?

The front end of an application typically refers to the layer that represents the UI (user interface). This can include anything from a static site with HTML and CSS to a full React app that powers the UI.

What did Front End Development traditionally look like?

Javascript currently rules the front end web, but that wasn’t always the case. While it could have been used to add little bits of interaction to a site, typically front ends were rendered using server-side templating languages like framework-driven PHP and Template Toolkit (Perl).

This grew to be super popular in practice with home grown frameworks or tools like Wordpress that used PHP to drive a massive community of developers who built their websites with those tools.

The way it worked was the templating language was able to get its data straight from the server as it was rendered. When a browser requested the page directly from the origin (the server itself), whatever data the template would need, the application logic would provide at that time.

Some of the more traditional front end tools include:

But as time went on, javascript kept getting more mature as a language and browsers kept getting more powerful, which led to the idea that we could move more of that work to the browser to build faster and more interactive experiences.

What does Front End Development look like now?

Now it’s common to see javascript-heavy websites and apps built using UI frameworks like React, Vue, and Angular. These tools provide abstractions that allow developers to build complex UIs with reusable patterns like components.

When the browser loads the page, the page receives an initial HTML document that also includes the script tag to the javascript (same as always). But once that javascript loads, it reaches out to APIs using browser requests that when completed, update the page to fill in any kind of dynamic data that you’d typically get along with that first HTML document.

Image It's like building a website... with more steps

While it sounds like more steps, it commonly provides a faster initial page load and render, not to mention it has a great developer experience. By delivering less on that first request and prioritizing what loads after that, it usually ends up as a better user experience.

Some of the front end tools that are more common and growing in popularity include:

But those APIs, whether ones we pay for or create ourselves, need to be built somewhere. That’s where the back end comes in.

What is Back End Development?

The back end layer is usually where the business logic occurs. This can be super complex like the rules that determine revenue for an e-commerce company or something more common like a user profile.

What did Back End Development traditionally look like?

The back ends of applications were historically built using server-side languages like PHP or Ruby. The idea is that you have a server that you need to perform complex operations on, so the way to do that is with a language that server would understand.

On each request to the server, the backend would perform the full stack of the operations, including rendering out the front end. By using frameworks or DIY architectures, the back end would accept the request, figure out what it should do with that request, run any business logic needed with the request, and provide the front end any data that it would need to display a response to that request.

Image Back end giving the front end a 500 Internal Server Error

Some of the more traditional back end tools include:

What does Back End Development look like now?

Back end stacks look somewhat similar to the way they did before, aside from newer code patterns, except more often you’ll see the back ends provide data through APIs via HTTP requests instead of directly to the templates the front end team are working on.

While the foundation isn’t super different, it actually be comes increasingly complex as you have to deal with different security implications that could compromise your system if not properly configured such as leaving an API open to the public that returns sensitive user data.

But also how the server operates can be completely different. While previously, we might run our python on our own managed server (we still can), we can now make use of serverless functions with tools like AWS Lambda that simplify how we manage code.

While “serverless” doesn’t necessarily mean there are literally no servers, it means that as a service, the developer doesn’t have to worry about maintaining that server and can instead just focus on the code they need to run.

Some of the back end tools that are more common and growing in popularity include:

Where things get fuzzy

Part of the twist with back ends is now you can write your back end with javascript. With the inception of Node.js, developers were given the ability to use their favorite browser language to do most of the same things they were used to and familiar with but now on a server.

Image Never stopped to think if we should write JS on a server

While not everyone is fond of running javascript as a server side language, it became a little easier to use the same language to write the full stack of an application. This changed the game a bit as far as front ends and back ends were concerned.

But it’s also started to come full circle where you now see systems that build APIs right next to the front end similar to what you might see in a traditional stack.

Front End vs Back End

Regardless of the stack, there will always be the separation of concerns. The UI and all of the interaction, whether rendered on the server or in the browser, is what makes the front end the front end and the data and business logic, whether coming from the server in your company’s closet or a managed function, is what makes the back end the back end.

Whether you prefer to work on the user facing features or build the logic that lets them do things, there are plenty of resources to get started.

Resources to learn

Front End

Back End

All the above

]]> <![CDATA[ How to Sync VS Code Settings Between Multiple Devices and Environments ]]> https://www.freecodecamp.org/news/how-to-sync-vs-code-settings-between-multiple-devices-and-environments/ 66b8e36c682e4a25eed261a2 Tue, 16 Jun 2020 14:45:45 +0000 All developers like their text editor a certain way, but it can be tough to make sure all of your environments have the same configuration. How can we make sure our VS Code configuration is the same wherever we use it?

What is VS Code?

Visual Studio Code, or VS Code, is an all-inclusive code editor that takes all of the features you want out of working with code and puts them in one editor to make you ultra productive.

Image VS Code editor

It’s been the “cool kid on the block” for a little while now and has been increasingly growing in popularity at least in the JavaScript community. Microsoft has put a lot of effort into making it something people want to use (and they’re doing a great job at that).

What will we use?

We’re going to use a VS Code extension called Settings Sync that makes use of Github’s Gist feature to store a private JSON configuration file in the cloud.

How does it work?

The extension uses Github’s OAuth to log in to your Github account. Once approved, VS Code obtains an access token and reaches out to both store and download your settings file to a private Github Gist.

Once it’s set up, you can then configure the extension on any other instance of VS Code and immediately download your configuration to sync up your editor.

Step 0: VS Code

We’ll assume for this walkthrough you have VS Code already installed. While you don’t need to have any special configuration, having something different than the default (like a color theme) will help you see it work.

Let’s get started!

Step 1: Install Settings Sync

The first thing we need to do is install the extension. You can do this a few ways — you can visit the webpage and hit Install which will open up VS Code or you can search for the extension in the Extensions panel.

Image VS Code Settings Sync extension

Once installed, it will open up a new tab with the Settings Sync dashboard.

Image Settings Sync dashboard after installation

Step 2: Authorize access to Github

To get started with Github, click the Login with Github button in the Settings Sync dashboard.

Image Log in to Settings Sync with Github

This will open up Github in your default web browser and ask you to log in. While you can use any Github account you want, it would probably make most sense to use your personal account.

Image Successful Github login to Settings Sync

Once you’re logged in, you should now see Success! in your browser.

Step 3: Upload your current settings

Now that you’re connected to Github, you’re ready to upload your settings.

Open up your Command Palette with CMD+Shift+P (on Mac) or navigate to View and Command Palette. Type “Sync Upload” which will filter the commands and hit enter once the Sync: Update/Upload Settings option is selected.

Image Update/Upload Settings command in Settings Sync

When doing this, you might be prompted with screen that asks if you want to force upload — press Yes.

Image Force upload new settings in Settings Sync

At this point, Settings Sync will create a new Gist in your Github account with your configuration settings. Once it’s done you should see a success message.

Image Successful settings upload in Settings Sync

You should now be able to visit gist.github.com and find a new private cloudSettings Gist that includes all of your VS Code settings!

Step 4: Syncing your configuration to another environment

To sync your VS Code configuration to another computer or VS Code environment, you want to first follow steps 1 and 2 above — installing the extension and logging in to Github.

The difference is this time, you’ll want to configure VS Code to download your settings instead of upload them.

To get started, first open back up your Sync Settings dashboard. If this is a new installation like we’re assuming here, you can open up the Command Palette and type “sync download” and hit enter which will open up that dashboard. Here, click Edit Configuration this time.

Image Edit Settings Sync configuration

On this screen, you should see your Github Access Token, but you should also see an empty field for Gist ID. Here, we want to first grab the ID from our cloudSettings Gist URL:

Image VS Code cloudSettings Gist ID

And then paste that value inside of our Gist ID input in VS Code.

Image Adding Gist ID to Settings Sync configuration

Once it’s there, you can open the Command Palette again, type “sync download”, and hit enter, and Sync Settings will fetch your VS Code configuration from the Gist and update your local settings with that configuration!

Step 5: Updating your configuration

From here on, any time you want to make a new change to your stored configuration, you’ll want to use both the Update/Upload and Download features like we used above.

To update a new tweak to your configuration, type “sync update” and hit enter:

Image Update command for Settings Sync

And to download your configuration to sync up another editor, type “sync download” and hit enter:

Image Download settings command for Settings Sync

These commands will both update your cloudSettings Gist and download from it to sync up your VS Code instances

What’s your favorite VS Code trick?

Share it with me on Twitter!

Join the conversation

]]> <![CDATA[ How to Grow Your Audience and Share Your Content with the World ]]> https://www.freecodecamp.org/news/how-to-grow-your-audience-and-share-your-content-with-the-world/ 66b8e35f684cb75ad7f76d1e Thu, 11 Jun 2020 14:45:00 +0000 Building quality content can be a really rewarding task. But for those just starting out or those who don't yet have a large audience, that content can easily get buried amongst the other million tweets on Twitter. How can we expand our reach and help our content impact more people?

Creating our content for the masses

Every content creator has been there – you just wrote an article that you're super excited about and think it's going to be a massive hit. But you quickly find that overnight success never came when you wake up hoping to find thousands of likes on the tweet only to find none.

But that might not have anything to do with your article. It could absolutely be groundbreaking, but unfortunately there's not many people around to see it.

Social networks don't tend to prioritize their feeds based on how good your article is, but how much interaction and engagement that post received. While that kind of makes sense, that doesn't play well for people just starting out.

So how do we expand that reach? While the obvious route is to buy your way to the top with ads, I'm going to focus on more natural ways we can build our audience.

What do I mean by building an audience?

Your favorite web developers or social media influencers didn't start with 100,000 followers – most of them worked really hard to get where they are. That process is what building an audience is all about.

By creating content, you're working to find others who enjoy your take or get inspired by it. Ideally, those same people will follow you on their favorite platform with the hope that your next piece will inspire them just the same.

Your audience is those people who followed you or are actively engaging with the content you create. The ones who are supporting you by giving a thumbs up to your new video. The ones who subscribe to your newsletter because they're eager to see the awesome work you did that week.

By working hard on your content, being consistent, and finding your voice, you'll naturally build that audience. But to build that audience, people first need to see it. So how can we get it in front of people?

Leveraging larger platforms and publications

While your new blog might not have anyone subscribed to your RSS feed, there are platforms out there with large audiences that are actively looking for more authors.

By leveraging these audiences, you're helping to get your foot in the door. While you might need to give up a little bit of ownership of the article by writing it somewhere that's not your own blog, you're providing a means for more people to read your content and find out who you are.

This process can take many forms, but I'm going to focus on a few things:

  • Syndicating with other platforms
  • Contributing to other publications
  • Sharing on content curation platforms

Syndicating with other platforms

Syndicating your content can be one of the more effective means of getting access to a larger network while holding on to a lot of the benefits of hosting your own content.

Not all platforms are the same, but most of the ones I'm going to go over allow you to provide a canonical link to your own website. What this does is allow you to publish your work on different platforms all while the "SEO juice" ultimately flows back to your own blog.

While it's important from an SEO perspective, it's also generally a good way to keep your content hosted on your own website where you know you'll maintain it for the foreseeable future. If one of those platforms ends up closing down, you still have all of your content safe at home.

So what are some platforms that we can syndicate with and how can you set it up?

Dev.to

Dev.to is the choice platform for developers who want to share their knowledge and open up conversation to the larger tech community. They provide an incredibly welcoming and safe space where developers experienced and new can publish their work.

The great part about it is that everyone seems to get a bit of a fair chance at getting their work out to the world. While they have similar features to other networks where you can follow your favorite authors, newer authors still show up in the content feed giving you a chance to be seen.

To syndicate on dev.to, you'll want to set up the canonical link in the post configuration. When editing the content, you'll want to look for the settings icon, where you'll then be provided with an input where you can add the original URL for your post.

Image Adding a canonical URL to a dev.to post

Medium

Medium has suffered a lot of criticism lately due to its aggressive tactics and monetization strategies, but it's still an effective platform for newcomers who don't have an audience to get in front of.

Medium's large network of users and content curation makes it a great platform for expanding your reach. But it doesn't stop at posting there.

To be effective with your Medium posts, you want to look to get published with an existing Medium publication. Better Programming is one of the larger developer publications that are always looking for new authors to contribute.

Submitting to a Medium publication will help you take advantage of not only Medium's network, but that publication's network that gives you a better chance of getting selected by Medium's curation team and landing in someone's newsletter inbox.

Adding a canonical link to your Medium posts is a bit trickier though. To do this, you must "import" your story rather than copy and pasting it in. The good news, is Medium also tries to import all of the content, ideally making it a bit easier to add (remember to review all of the formatting!).

On your Stories page, you can find the Import button.

Image Importing a story on Medium

Once it's imported, you won't really be able to see much, but once you preview the page, you can view the source and find the canonical link added.

Image Canonical link in Medium post source

Contributing to other publications

While you might have to give up ownership of your content, writing for other publications or writing as a "guest post" is a great way to get started and gain some ground where you might not have had any before.

Depending on the publisher, you might not ever get the opportunity to post it on your own website, but you're trading that for the privilege to get your work out to potentially millions of people instead of the 10 unique visitors from the month of May.

This can even open up the door to more opportunities. This helps give your name recognition and authority that can help in your job search or simply another chance to write for the same publisher or a different bigger one.

The good news – is there's an endless supply of big name publishers that you can submit your work to. Here are a few you can get started with:

Each of these publications have different processes of getting published. So be patient and keep working hard at your content.

Note: know of another publisher that offers writing opportunities? Let me know and I'll add them above!

Sharing on content curation platforms

It would be great if we all had a massive Twitter following where we could post about our new blog, but that's typically not the case. So while you should absolutely set up a social media profile and get your content out there, I'll focus on other platforms here.

Reddit

Though there are certainly rules about self-promotion depending on the subreddit, Reddit's a massive community of real people who are curious and eager to learn about something new.

Learn about the different tech or webdev subreddits that are out there. Start getting involved with other people's posts. Develop a relationship with the people there and show why your content has value.

Hacker News

Hacker News is tough. It's hard to get noticed and on the front page. And even when you get on the front page, there's a good chance you'll get a lot of criticism you never expected to get.

But if you can have thick skin and learn to take the heat should you get noticed, Hacker News can be an incredible way to broadcast to the world. People have turned into overnight successes by ending up on the front page of Hacker News whether they're the ones who posted it there or not.

More platforms

While those are two of the big ones, there are a ton more. Here are a few more to get you started:

Other notable places

Chat-based Communities

There are a ton of communities using platforms like Slack or Discord that are incredibly supportive in helping each other grow. While you shouldn't simply spam your content, try to start a conversation around it. Talk about why the topic is important to you or how your tutorial can help others in their code journey.

Newsletters

This is something a lot of people regret not starting earlier – myself included. It's not too much effort to start a newsletter with a platform that has a free tier and keep it in your back pocket until you see some growth. No one's going to judge you for waiting a few months to put out content, but once you begin to grow your audience, they'll be excited to see all of your new work.

Other people's newsletters

You don't have to have your own newsletter to get into someone's inbox, there are already a ton of newsletter curators doing a lot of hard work to find great content around the web, but if they don't see it, how can they include it?

Most newsletter publications love to receive submissions. This helps their publication grow and include content from people who might not have a good opportunity on their own.

While you can Google around and find a newsletter that makes sense for you, here are a few that I follow along with that I know would love to see your work:

Building your "brand"

"Brand" is a funny word and can come sometimes come with negative connotations. But really as an author, your goal should be to build a presence that you carry with you consistently through all of your different outlets of work.

For instance, when possible, try to always use the same username when creating author profiles. You can find me mostly anywhere at @colbyfayock – it makes it easy for people to find me on a new network.

Also try to use the same picture. While it's definitely fun to customize your different profiles depending on who's there, the benefit of using the same picture is people will come to recognize you by that picture. They'll instantly be able to remember they saw your blog post when they see your tweet come through their feed.

Be patient, your time will come

You're not going to find an overnight success without spending a lot of money, so be patient. Content development is hard, it takes time to both build an audience and figure out your voice.

But chances are, if this is your first article you've ever written, maybe that first publisher you sent it to wasn't interested in it.

THAT'S OKAY! Don't give up! Send it to another publisher and try the original one for your next article. When I first started out, it took a few articles before I got accepted as an author to freeCodeCamp's Medium publication.

The more you write, the more you'll learn about what's effective. It's not a sprint – be patient and just keep up the hard work.

Overcoming the fear of sharing your work

Most of these things aren't easy to do. The idea that you might have to face critical feedback of your work is absolutely scary!

But overcoming this fear is an important step of the process. I personally struggled with this when I began writing, but the more you put yourself our there, the less scary it becomes and you'll quickly notice there aren't as many bad people out there looking to say bad things about your work.

Instead, you're opening yourself up to an opportunity to learn and grow. Though not everyone's the same, the tech community can be overwhelmingly welcoming and supportive. The more you share and put yourself out there, the more receptive people will be to wanting to hear what you have to say.

How do you share your work?

Let me know on Twitter!

]]> <![CDATA[ What are Github Actions and How Can You Automate Tests and Slack Notifications? ]]> https://www.freecodecamp.org/news/what-are-github-actions-and-how-can-you-automate-tests-and-slack-notifications/ 66b8e39047c23b7ae1ad0bdf Wed, 03 Jun 2020 14:45:00 +0000 Automation is a powerful tool. It both saves us time and can help reduce human error.

But automation can be tough and can sometimes prove to be costly. How can Github Actions help harden our code and give us more time to work on features instead of bugs?

What are Github Actions?

Actions are a relatively new feature to Github that allow you to set up CI/CD workflows using a configuration file right in your Github repo.

Previously, if you wanted to set up any kind of automation with tests, builds, or deployments, you would have to look to services like Circle CI and Travis or write your own scripts. But with Actions, you have first class support to powerful tooling to automate your workflow.

What is CI/CD?

CD/CD stands for Continuous Integration and Continuous Deployment (or can be Continuous Delivery). They're both practices in software development that allow teams to build projects together quickly, efficiently, and ideally with less errors.

Continuous Integration is the idea that as different members of the team work on code on different git branches, the code is merged to a single working branch which is then built and tested with automated workflows. This helps to constantly make sure everyone's code is working properly together and is well-tested.

Continuous Deployment takes this a step further and takes this automation to the deployment level. Where with the CI process, you automate the testing and the building, Continuous Deployment will automate deploying the project to an environment.

The idea is that the code, once through any building and testing processes, is in a deployable state, so it should be able to be deployed.

What are we going to build?

We're going to tackle two different workflows.

The first will be to simply run some automated tests that will prevent a pull request from being merged if it is failing. We won't walk through building the tests, but we'll walk through running tests that already exist.

In the second part, we'll set up a workflow that sends a message to slack with a link to a pull request whenever a new one is created. This can be super helpful when working on open source projects with a team and you need a way to keep track of requests.

Part 0: Setting up a project

For this guide, you can really work through any node-based project as long as it has tests you can run for Part 1.

If you'd like to follow along with a simpler example that I'll be using, I've set up a new project that you can clone with a single function that has two tests that are able to run and pass.

Image A function with two tests

If you'd like to check out this code to get started, you can run:

git clone --single-branch --branch start git@github.com:colbyfayock/my-github-actions.git

Once you have that cloned locally and have installed the dependencies, you should be able to run the tests and see them pass!

Image Passing tests

It should also be noted that you'll be required to have this project added as a new repository on Github in order to follow along.

Follow along with the commit!

Part 1: Automating tests

Tests are an important part of any project that allow us to make sure we're not breaking existing code while we work. While they're important, they're also easy to forget about.

We can remove the human nature out of the equation and automate running our tests to make sure we can't proceed without fixing what we broke.

Step 1: Creating a new action

The good news, is Github actually makes it really easy to get this workflow started as it comes as one of their pre-baked options.

We'll start by navigating to the Actions tab on our repository page.

Image Github Actions starting page

Once there, we'll immediately see some starter workflows that Github provides for us to dive in with. Since we're using a node project, we can go ahead and click Set up this workflow under the Node.js workflow.

Image Setting up a Node.js Github Action workflow

After the page loads, Github will land you on a new file editor that already has a bunch of configuration options added.

We're actually going to leave this "as is" for our first step. Optionally, you can change the name of the file to tests.yml or something you'll remember.

Image Adding a new Github Action workflow file

You can go ahead and click Start commit then either commit it directory to the master branch or add the change to a new branch. For this walkthrough, I'll be committing straight to master.

To see our new action run, we can again click on the Actions tab which will navigate us back to our new Actions dashboard.

Image Viewing Github Action workflow events

From there, you can click on Node.js CI and select the commit that you just made above and you'll land on our new action dashboard. You can then click one of the node versions in the sidebar via build (#.x), click the Run npm test dropdown, and we'll be able to see the output of our tests being run (which if you're following along with me, should pass!).

Image Viewing logs of a Github Action workflow

Follow along with the commit!

Step 2: Configuring our new action

So what did we just do above? We'll walk through the configuration file and what we can customize.

Image Github Action Node.js workflow file

Starting from the top, we specify our name:

name: Node.js CI

This can really be whatever you want. Whatever you pick should help you remember what it is. I'm going to customize this to "Tests" so I know exactly what's going on.

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

The on key is how we specify what events trigger our action. This can be a variety of things like based on time with cron. But here, we're saying that we want this action to run any time someone pushes commits to master or someone creates a pull request targeting the master branch. We're not going to make a change here.

jobs:
  build:
    runs-on: ubuntu-latest

This next bit creates a new job called build. Here we're saying that we want to use the latest version of Ubuntu to run our tests on. Ubuntu is common, so you'll only want to customize this if you want to run it on a specific environment.

    strategy:
      matrix:
        node-version: [10.x, 12.x, 14.x]

Inside of our job we specify a strategy matrix. This allows us to run the same tests on a few different variations.

In this instance, we're running the tests on 3 different versions of node to make sure it works on all of them. This is definitely helpful to make sure your code is flexible and future proof, but if you're building and running your code on a specific node version, you're safe to change this to only that version.

    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v1
      with:
        node-version: ${{ matrix.node-version }}
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test

Finally, we specify the steps we want our job to run. Breaking this down:

  • uses: actions/checkout@v2: In order for us to run our code, we need to have it available. This checks out our code on our job environment so we can use it to run tests.
  • uses: actions/setup-node@v1: Since we're using node with our project, we'll need it set up on our environment. We're using this action to do that setup for us for each version we've specified in the matrix we configured above.
  • run: npm ci: If you're not familiar with npm ci, it's similar to running npm install but uses the package-lock.json file without performing any patch upgrades. So essentially, this installs our dependencies.
  • run: npm run build --if-present: npm run build runs the build script in our project. The --if-present flag performs what it sounds like and only runs this command if the build script is present. It doesn't hurt anything to leave this in as it won't run without the script, but feel free to remove this as we're not building the project here.
  • run: npm test: Finally, we run npm test to run our tests. This uses the test npm script set up in our package.json file.

And with that, we've made a few tweaks, but our tests should run after we've committed those changes and pass like before!

Image Logs of passing tests in Github Action workflow

Follow along with the commit!

Step 3: Testing that our tests fail and prevent merges

Now that our tests are set up to automatically run, let's try to break it to see it work.

At this point, you can really do whatever you want to intentionally break the tests, but here's what I did:

Image Code diff - https://github.com/colbyfayock/my-github-actions/pull/1

I'm intentionally returning different expected output so that my tests will fail. And they do!

Image Failing status checks on pull request

In my new pull request, my new branch breaks the tests, so it tells me my checks have failed. If you noticed though, it's still green to merge, so how can we prevent merges?

We can prevent pull requests from being merged by setting up a Protected Branch in our project settings.

First, navigate to Settings, then Branches, and click Add rule.

Image Github branch protection rules

We'll then want to set the branch name pattern to *, which means all branches, check the Require status checks to pass before merging option, then select all of our different status checks that we'd like to require to pass before merging.

Image Setting up a branch protection rule in Github

Finally, hit Create at the bottom of the page.

And once you navigate back to the pull request, you'll notice that the messaging is a bit different and states that we need our statuses to pass before we can merge.

Image Failing tests preventing merge in pull request

Note: as an administrator of a repository, you'll still be able to merge, so this technically only prevents non-administrators from merging. But will give you increased messaging if the tests fail.

And with that, we have a new Github Action that runs our tests and prevents pull requests from merging if they fail.

Follow along with the pull request!

Note: we won't be merging that pull request before continuing to Part 2.

Part 2: Post new pull requests to Slack

Now that we're preventing merge requests if they're failing, we want to post a message to our Slack workspace whenever a new pull request is opened up. This will help us keep tabs on our repos right in Slack.

For this part of the guide, you'll need a Slack workspace that you have permissions to create a new developer app with and the ability to create a new channel for the bot user that will be associated with that app.

Step 1: Setting up Slack

There are a few things we're going to walk through as we set up Slack for our workflow:

  • Create a new app for our workspace
  • Assign our bot permissions
  • Install our bot to our workspace
  • Invite our new bot to our channel

To get started, we'll create a new app. Head over to the Slack API Apps dashboard. If you already haven't, log in to your Slack account with the Workspace you'd like to set this up with.

Image Creating a new Slack app

Now, click Create New App where you'll be prompted to put in a name and select a workspace you want this app to be created for. I'm going to call my app "Gitbot" as the name, but you can choose whatever makes sense for you. Then click Create App.

Image Configuring a new Slack app

Once created, navigate to the App Home link in the left sidebar. In order to use our bot, we need to assign it OAuth scopes so it has permissions to work in our channel, so select Review Scopes to Add on that page.

Image Reviewing Slack app scopes

Scroll own and you'll see a Scopes section and under that a Bot Token section. Here, click Add an OAuth Scope. For our bot, we don't need a ton of permissions, so add the channels:join and chat:write scopes and we should be good to go.

Image Adding scopes for a Slack app Bot Token

Now that we have our scopes, let's add our bot to our workspace. Scroll up on that same page to the top and you'll see a button that says Install App to Workspace.

Image Installing Slack app to a workspace

Once you click this, you'll be redirected to an authorization page. Here, you can see the scopes we selected for our bot. Next, click Allow.

Image Allowing permission for Slack app to be installed to workspace

At this point, our Slack bot is ready to go. At the top of the OAuth & Permissions page, you'll see a Bot User OAuth Access Token. This is what we'll use when setting up our workflow, so either copy and save this token or remember this location so you know how to find it later.

Note: this token is private - don't give this out, show it in a screencast, or let anyone see it!

Image Copying OAuth Access Token for Slack bot user

Finally, we need to invite our Slack bot to our channel. If you open up your workspace, you can either use an existing channel or create a new channel for these notifications, but you'll want to enter the command /invite @[botname] which will invite our bot to our channel.

Image Inviting Slack bot user to channel

And once added, we're done with setting up Slack!

Image Slack bot was added to channel

Create a Github Action to notify Slack

Our next step will be somewhat similar to when we created our first Github Action. We'll create a workflow file which we'll configure to send our notifications.

While we can use our code editors to do this by creating a file in the .github directory, I'm going to use the Github UI.

First, let's navigate back to our Actions tab in our repository. Once there, select New workflow.

Image Setting up a new Github Action workflow

This time, we're going to start the workflow manually instead of using a pre-made Action. Select set up a workflow yourself at the top.

Image Setting up a Github Action workflow manually

Once the new page loads, you'll be dropped in to a new template where we can start working. Here's what our new workflow will look like:

name: Slack Notifications

on:
  pull_request:
    branches: [ master ]

jobs:
  notifySlack:

    runs-on: ubuntu-latest

    steps:
    - name: Notify slack
      env:
        SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
      uses: abinoda/slack-action@master
      with:
        args: '{\"channel\":\"[Channel ID]\",\"blocks\":[{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Pull Request:* ${{ github.event.pull_request.title }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Who?:* ${{ github.event.pull_request.user.login }}\n*Request State:* ${{ github.event.pull_request.state }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"<${{ github.event.pull_request.html_url }}|View Pull Request>\"}}]}'

So what's happening in the above?

  • name: we're setting a friendly name for our workflow
  • on: we want our workflow to trigger when there's a pull request is created that targets our master branch
  • jobs: we're creating a new job called notifySlack
  • jobs.notifySlack.runs-on: we want our job to run on a basic setup of the latest Unbuntu
  • jobs.notifySlack.steps: we really only have one step here - we're using a pre-existing Github Action called Slack Action and we're configuring it to publish a notification to our Slack

There are two points here we'll need to pay attention to, the env.SLACK_BOT_TOKEN and the with.args.

In order for Github to communicate with Slack, we'll need a token. This is what we're setting in env.SLACK_BOT_TOKEN. We generated this token in the first step. Now that we'll be using this in our workflow configuration, we'll need to add it as a Git Secret in our project.

Image _Github secrets including SLACK_BOTTOKEN

The with.args property is what we use to configure the payload to the Slack API that includes the channel ID (channel) and our actual message (blocks).

The payload in the arguments is stringified and escaped. For example, when expanded it looks like this:

{
  "channel": "[Channel ID]",
  "blocks": [{
    "type": "section",
    "text": {
      "type": "mrkdwn",
      "text": "*Pull Request:* ${{ github.event.pull_request.title }}"
    }
  }, {
    "type": "section",
    "text": {
      "type": "mrkdwn",
      "text": "*Who?:*n${{ github.event.pull_request.user.login }}n*State:*n${{ github.event.pull_request.state }}"
    }
  }, {
    "type": "section",
    "text": {
      "type": "mrkdwn",
      "text": "<${{ github.event.pull_request._links.html.href }}|View Pull Request>"
    }
  }]
}

Note: this is just to show what the content looks like, we need to use the original file with the stringified and escaped argument.

Back to our configuration file, the first thing we set is our channel ID. To find our channel ID, you'll need to use the Slack web interface. Once you open Slack in your browser, you want to find your channel ID in the URL:

https://app.slack.com/client/[workspace ID]/[channel ID]

Image Channel ID in Slack web app URL

With that channel ID, you can modify our workflow configuration and replace [Channel ID] with that ID:

with:
  args: '{\"channel\":\"C014RMKG6H2\",...

The rest of the arguments property is how we set up our message. It includes variables from the Github event that we use to customize our message.

We won't go into tweaking that here, as what we already have will send a basic pull request message, but you can test out and build your own payload with Slack's Block Kit Builder.

Follow along with the commit!

Test out our Slack workflow

So now we have our workflow configured with our Slack app, finally we're ready to use our bot!

For this part, all we need to do is create a new pull request with any change we want. To test this out, I simply created a new branch where I added a sentence to the README.md file.

Image Code diff - https://github.com/colbyfayock/my-github-actions/pull/2

Once you create that pull request, similar to our tests workflow, Github will run our Slack workflow! You can see this running in the Actions tab just like before.

As long as you set everything up correctly, once the workflow runs, you should now have a new message in Slack from your new bot.

Image Slack bot automated message about new pull request

Note: we won't be merging that pull request in.

What else can we do?

Customize your Slack notifications

The message I put together is simple. It tells us who created the pull request and gives us a link to it.

To customize the formatting and messaging, you can use the Github Block Kit Builder to create your own.

If you'd like to include additional details like the variables I used for the pull request, you can make use of Github's available contexts. This lets you pull information about the environment and the job to customize your message.

I couldn't seem to find any sample payloads, so here's an example of a sample github context payload you would expect in the event.

Sample github context

More Github actions

With our ability to create new custom workflows, that's not a lot we can't automate. Github even has a marketplace where you can browse around for one.

If you're feeling like taking it a step further, you can even create your own! This lets you set up scripts to configure a workflow to perform whatever tasks you need for your project.

Join in the conversation!

What do you use Github actions for?

Share with me on Twitter!

]]> <![CDATA[ The Fibonacci Sequence – Explained in Python, JavaScript, C++, Java, and Swift ]]> https://www.freecodecamp.org/news/the-fibonacci-sequence-in-5-different-programming-languages-1c6514c749e5/ 66c36157e4cb1ff6521c827c Mon, 01 Jun 2020 15:38:00 +0000 By Pau Pavón

The Fibonacci sequence is, by definition, the integer sequence in which every number after the first two is the sum of the two preceding numbers. To simplify:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …

It has many applications in mathematics and even trading (yes, you read that right: trading), but that’s not the point of this article. My goal today is to show you how you can compute any term of this series of numbers in five different programming languages using recursive functions.

Recursive functions are those functions which, basically, call themselves.

I want to note that this isn’t the best method to do it — in fact, it could be considered the most basic method for this purpose. This is because the computing power required to calculate larger terms of the series is immense. The number of times the function is called causes a stack overflow in most languages.

All the same, for the purposes of this tutorial, let’s begin.

First of all, let’s think about what the code is going to look like. It’ll include:

· A recursive function F (F for Fibonacci): to compute the value of the next term.

· Nothing else: I warned you it was quite basic.

Our function will take n as an input, which will refer to the _n_th term of the sequence that we want to be computed. So, F(4) should return the fourth term of the sequence.

Let’s plan it. The code should, regardless the language, look something like this:

function F(n) if n = 0
return 0 if n = 1
return 1 else
return F(n-1) + F(n-2)

Note: the term 0 of the sequence will be considered to be 0, so the first term will be 1; the second, 1; the third, 2; and so on. You get it.

Let’s analyze the function for a moment. If it gets 0 as an input, it returns 0. If it gets 1, it returns 1. If it gets 2… Well, in that case it falls into the else statement, which will call the function again for terms 2–1 (1) and 2–2 (0). That will return 1 and 0, and the two results will be added, returning 1. Perfect.

Now you can see why recursive functions are a problem in some cases. Imagine you wanted the 100th term of the sequence. The function would call itself for the 99th and the 98th, which would themselves call the function again for the 98th and 97th, and 97th and 96th terms…and so on. It would be really slow.

But the good news is that it actually works!

So let’s start with the different languages. I won’t give too much detail (actually, no detail at all) to make your reading experience better. There isn’t too much to detail anyways.

Let’s jump into it:

Python

def F(n): if n == 0:
return 0 if n == 1:
return 1 else:
return F(n-1) + F(n-2)

Swift

func F(_ n: Int) -> Int { if n == 0 { return 0
} if n == 1 { return 1
} else { return F(n-1) + F(n-2)
}}

JavaScript

function F(n) { if(n == 0) { return 0;
} if(n == 1) { return 1;
} else { return F(n-1) + F(n-2);
}}

Java

public static int F(int n) { if(n == 0) { return 0;
} if(n == 1) { return 1;
} else { return F(n-1) + F(n-2);
}}

C++

int F(int n) { if(n == 0) { return 0;
} if(n == 1) { return 1;
} else { return F(n-1) + F(n-2);
}}

And that’s it. I chose these languages just based on popularity — or at least because these 5 are the most common ones that I use They’re in no particular order. They could be classified by syntax difficulty, in my opinion, from Python (easiest) to C++ (hardest). But that depends on your personal opinion and your experience with each language.

I hope you liked this article and, if you have any questions/recommendations or just want to say hi, comment below!

]]>