Why CExtUp?

CExtUp was born out of my desire to simplify the initial setup process and provide a modern development environment for Chrome extensions. By using Bun—a modern JavaScript runtime, bundler, and package manager—instead of Node.js, CExtUp offers an insanely fast and efficient development experience that is actually pleasant to use.

Key Features

• Quick Scaffolding: CExtUp automates the creation of a new Chrome extension project, setting up a basic structure and all necessary files with just one command.

• Bun-Powered: The integration with Bun ensures that builds are quick and the development server is responsive, allowing for rapid prototyping and testing.

• TypeScript Ready: With out-of-the-box support for TypeScript, developers can write safer and more maintainable code from the get-go.

• Serverless Edge Functions: For those who need backend logic, CExtUp is pre-configured to use Vercel Serverless Edge Functions, though it's flexible enough to work with other serverless platforms, or even with a self-hosted solution.

Getting Started

To get started with CExtUp, simply run the following command:

bunx cextup
# or
npx cextup

This interactive CLI will guide you through naming your new extension and create a directory with that name, populated with a well-organized set of files and folders for your project.

A Thoughtful Project Structure

CExtUp generates a project with a clear and logical structure:

• src/: Contains the source files for your Chrome extension, including background scripts, content scripts, and the manifest file.

• types/: Houses TypeScript type definitions to ensure type safety.

• api/: If you opt for serverless functions, this is where they'll live.

• scripts/: Includes build and serve scripts to facilitate development.

Development Workflow

Once you've scaffolded your project with CExtUp, the development workflow is straightforward:

1. Install Bun if you haven't already:

curl -fsSL https://bun.sh/install | bash

1. Install dependencies:

cd your-extension-name
bun i

1. Start the development server and watch for changes:

bun start

Alternatively, to build the extension without starting the server:

bun ./scripts/build.ts

Loading Your Extension

To test your extension in Chrome, navigate to chrome://extensions, enable Developer Mode, and click Load unpacked. Select the extension directory from your project. Remember to reload the extension after making changes to see them reflected in the browser.

Let me know if you try out CExtUp and if you find it useful. Contributions, feedback, and discussions are welcome—feel free to reach out through GitHub issues or pull requests.

Go follow me if you want to see what else I'm making!

• tmux - Kind of obvious. I’m assuming you already have this.

• spotify-tui - We’ll mostly just be using this for the spt playback CLI command to get the playback info.

• spotifyd- We need this for the “song changed” hook and so we don’t need the Spotify app open.

• bash - You already know.

• homebrew - Skip this if you’re not on macOS. I’ll be using it to download all of these tools and also to launch the spotifyd daemon. Again, I’m going to assume you already have this.

• Spotify - You'll probably need this, eh? I'm pretty sure you need Spotify Premium for this to work, but I'm not positive.

Prerequisites

Before we get started, go make a Spotify developer account if you don’t already have one. Then create a new app in the developer dashboard. The name and description don’t matter, but make sure you add http://localhost:8888/callback to the "Redirect URIs" section - spotify-tui requires this and we’ll revisit it later.

Installing the Tools

Now let’s get our tools. If you're on macOS, use the following command:

brew install spotify-tui
brew install spotifyd

For Linux users, you can install the tools using your package manager or by following the instructions on their respective GitHub repositories (spotify-tui and spotifyd).

Creating the Script

Now we can get a little crazy with some bash scripting. We’re going to gloss over this, but essentially it uses the spt playback subcommand from spotify-tui to get the current song in a specified format, then uses the current date in seconds to calculate the scroll position if the playback info is longer than a certain number of characters. It does some tempfile file things to store the state and saves us from calling the Spotify API too many times.

Save this script anywhere you want but let’s name it spt_status.sh.

#!/usr/bin/env bash

tmpdir="$TMPDIR/spt_status"
data_file="$tmpdir/current.txt"

if [ ! -d "$tmpdir" ]; then
    printf "\rInitializing..."

    # create the directory
    mkdir "$tmpdir"

    # initialize the data file
    echo "null" >"$data_file"
    echo "false" >>"$data_file"

    printf "\rInitialized successfully!"

    exit 0
fi

# the first line of the data file is the output of the last run
output=$(head -n 1 "$data_file" 2>/dev/null)

# the second line is whether or not we've already updated
updated=$(tail -n 1 "$data_file" 2>/dev/null)

if [ "$1" = "--update" ]; then
    printf "\rUpdating..."

    # only get the playback information if we haven't already updated
    if [ "$updated" != "true" ]; then
        # write the playback information to the data file
        echo "null" >"$data_file"

        # write that we've updated to the data file
        echo "true" >>"$data_file"
    fi

    exit 0
fi

# get the output from the data file
output=$(head -n 1 "$data_file" 2>/dev/null)

# if the output is null, get the playback information
if [ "$output" = "null" ]; then
    # format options:
    # %a: artist, %b: album, %p: playlist, %t: track, %h: show,
    # %f: flags (shuffle, repeat, like), %s: playback status, %v: volume, %d: current device

    # get the playback information
    pb=$(/usr/local/bin/spt playback --format "%s %a: %t" 2>/dev/null || echo "null")

    # write the playback information to the data file
    echo "$pb" >"$data_file"

    # write that we haven't updated to the data file
    echo "false" >>"$data_file"

    # get the output from the data file
    output=$(head -n 1 "$data_file" 2>/dev/null)
fi

# remove all newlines from the output
output=$(echo "$output" | tr -d '\n')

# max length of the output
max_length=35

# the speed at which the text should scroll (characters per second)
scroll_speed=10

if [ "$output" = "null" ]; then
    # if the output is null, print an error message and exit
    printf "\rSomething went wrong..."

    exit 1
fi

if [ ${#output} -gt $max_length ]; then
    # get the current time in seconds
    current_time=$(date +%s)

    # first character is the play/pause symbol
    play_pause_symbol="${output:0:2}"

    # the rest of the output is the track information
    output=${output:2}

    # calculate the scroll position based on the current time and scroll speed
    scroll_position=$((current_time * scroll_speed % (${#output} + max_length)))

    # create a padded version of the output with spaces
    padded_output="${output}$(printf '%*s' $((max_length)) '')${output}"

    # extract the substring to display based on the scroll position
    displayed_output="${padded_output:$scroll_position:(($max_length - 2))}"

    printf "\r%s%s " "$play_pause_symbol" "$displayed_output"

    exit 0
fi

padded_output="${output}$(printf '%*s' $((max_length + 1 - ${#output})) '')"
printf "\r%s" "$padded_output"

Make sure you run chmod +x spt_status.sh to make it executable.

Configuring the Daemon

Now, we’re almost ready to see it in action, but there are a couple of things we need to do first.

For macOS users, we’ll make a small modification to the .plist file that brew uses to launch the daemon. Open up /usr/local/Cellar/spotifyd/0.3.4/homebrew.mxcl.spotifyd.plist (modify to match your version) and look for this section around line 17:

<key>ProgramArguments</key>
<array>
    <string>/usr/local/opt/spotifyd/bin/spotifyd</string>
    <string>--no-daemon</string>
    <string>--backend</string>
    <string>portaudio</string>
</array>

Add the following to the array after <string>portaudio</string>:

<string>--on-song-change-hook</string>
<string>/path/to/spt_status.sh --update</string>

Note that this needs to be the full path to our script.

For Linux users, you can create a systemd service file to launch the daemon. Create a file named spotifyd.service in ~/.config/systemd/user/ with the following content:

[Unit]
Description=Spotifyd Daemon

[Service]
ExecStart=/usr/bin/spotifyd --no-daemon --backend alsa --on-song-change-hook "/path/to/spt_status.sh --update"
Restart=always
RestartSec=12

[Install]
WantedBy=default.target

Replace /path/to/spt_status.sh with the full path to the script you created earlier.

Launching the Daemon

From here, we can launch our daemon:

For macOS users:

brew services start spotifyd

For Linux users:

systemctl --user enable --now spotifyd.service

Configuring spotify-tui and tmux

We need to run spt one time to configure it, so do that now and follow the messages, entering your Spotify app’s client and secret tokens when prompted. Then press d and select spotifyd from the devices list. If it’s not showing up in the list of available devices, you might need to open the official app and select “spotifyd” as your playback device. You can then close the Spotify app.

We’re almost there, I promise. All that’s left is to open up your tmux config (probably at ~/.tmux.conf) and make a couple of small tweaks:

# .tmux.conf

# ...rest of file

# update the status bar every second
set -g status-interval 1

# show our widget
set -g status-right ' #(spt_status.sh)'

# ...rest of file

Wrapping Up

Whew! We did it. If you have any open tmux sessions, exit them with tmux kill-server and start up a new one. Play a song with either the official app or with spotify-tui, and you should see our new widget on the right.

If you liked this, let me know in the comments and give me a follow! Also, don’t hesitate to let me know if something isn’t working or if I overlooked anything.

I'm also on Twitter @techsavvytravvy and sometimes I stream on Twitch - come hang out!

Bye!

Why a Full-Time Job?

There are a lot of reasons why you might want to make the switch from freelancing to a full-time job. Maybe you're tired of the unstable income, or the constant hustle to find new clients. Maybe you're ready for benefits and a regular paycheck. Or maybe you're just ready for a change of pace.

There are a few things to consider before making the switch. First, let's look at the pros and cons of a full-time job.

Pros and Cons

There are some obvious advantages to a full-time job:

• Regular income: You'll know how much you're going to be paid, and when you're going to be paid, which can be a huge relief after the uncertainty of freelancing.

• Benefits: Health insurance, vacation days, 401k matching, and other benefits can be extremely valuable, especially if you have a family.

• Stability: A full-time job offers a lot more stability than freelancing, both in terms of income and workload.

• Opportunities for growth: A full-time job will give you the opportunity to work with a team, learn new skills, and advance in your career.

Of course, there are also some disadvantages to consider:

• Less flexibility: You'll have to work set hours, and may have less control over your workload and projects.

• Less freedom: You may have to dress a certain way, or adhere to other rules and regulations that you didn't have to worry about as a freelancer.

• Less independence: You'll be working for someone else, and will have to answer to a boss.

Overall, there are a lot of factors to consider before making the switch from freelancing to a full-time job. It's important to weigh the pros and cons and decide what's right for you.

The Job Market for Programmers

If you've decided that a full-time job is the right move for you, the next step is to start looking for positions. The job market for programmers is very competitive, so it's important to take the time to find the right position.

Choosing the Right Position

When you're looking for a programming position, it's important to consider your skills and experience. Do you want to work in a specific language or framework? Do you want to work in a specific industry? Do you want to work on a particular type of project?

It's also important to consider the company you want to work for. Do you want to work for a big company or a small startup? Do you want to work in a corporate environment, or a more relaxed atmosphere? Do you want to work remotely, or in an office?

There are a lot of factors to consider when choosing the right position. It's important to take the time to find a position that's a good fit for you.

Interviewing and Code Tests

Once you've found a few positions that you're interested in, it's time to start applying. The interview process for programming positions can be very competitive. Many companies require a code test as part of the interview process.

If you're not familiar with code tests, they are basically a way for companies to assess your skills. They usually involve solving a problem or writing code to complete a task. Code tests can be very difficult, so it's important to practice before you take one.

There are a few resources that can help you prepare for a code test:

• LeetCode: The gold standard for interview code questions. There is a wide range of programming challenges, as well as articles and tutorials on various programming topics.

• CodeWars: Similar to LeetCode, they offer a somewhat more fun platform with many code challenges.

• HackerRank: Another site with challenges to help you prepare for a code test.

Practicing for a code test is a great way to prepare for the interview process. It's also a good way to assess your skills and see if you're ready for a full-time job. Just be aware that you don't necessarily need to be a master of algorithms to get the job you want, and the actual test might end up being a more practical application of your skills.

How to Make the Transition

Making the transition from freelancing to a full-time job can be a big change. Here are a few tips to help you make the transition:

• Start looking for positions early: The sooner you start looking, the better. It can take a while to find the right position, so it's important to start early.

• Keep your options open: Don't limit yourself to one type of position or company. The more options you have, the better.

• Be prepared for the interview process: Practice for code tests and interviews. The more prepared you are, the better.

• Be patient: The process can take some time, so it's important to keep your eyes on the prize.

Making the transition from freelancing to a full-time job can be a big change, but it's definitely doable. If you're thinking of making the switch, I hope this article helped you.

The Bottom Line

Making the switch from freelancing to a full-time job is a big decision. There are a lot of factors to consider, and the process can be competitive. But if you're ready for a change, a full-time job can be a great opportunity.

Which do you prefer: a full-time job or freelancing? Let me know in the comments!

Be sure to follow me for more like this.

Pros

Popular

Python is one of the most popular programming languages in the world. It's used by major companies like Google, Facebook, Instagram, Netflix, and Dropbox. If you're looking for a language with a large community and good job prospects, Python is a good choice.

Being popular also means that there is a large community of developers who can help you if you get stuck, and it also means that there are many libraries and frameworks available to help you with your development.

Batteries Included

Python comes with a lot of standard library modules that provide functionality that would otherwise need to be provided by third-party libraries. This means that you don't have to worry about installing extra libraries when you're starting a new project, and it also means that you have more options available to you out of the box.

Need to parse JSON? There's a module for that. Want to do some complex math? There's a module for that, too. Python's "batteries included" approach saves you time and effort.

Easy to Learn

Python is considered a beginner-friendly language. Its syntax is clean and straightforward. And there's a lot of documentation and resources available to help you learn. If you're just starting out, Python is a good language to learn.

Free and Open-Source

Python is free to use. You can download it from the Python website and use it without paying a licensing fee. And Python is open-source, which means its source code is available for anyone to view and contribute to.

Portable

Python is a portable language. This means you can run Python programs on any platform that supports Python, including Windows, Mac, Linux, and Raspberry Pi. This makes Python a good choice for cross-platform development.

Interpreted

Python is an interpreted language. This means that Python programs are executed by an interpreter, not by a compiler. Interpreted languages are usually easier to debug because you can see what's happening as the program is running.

Cons

Slow

Compared to compiled languages, Python is considered slow. It's not suitable for tasks that need to be completed quickly, such as real-time video processing or games. If speed is important, you should look for a language that's faster, such as C++ or Rust.

Interpreted

Because Python is interpreted, it's not suitable for tasks that require a lot of processing power. If you need to do something that's computationally intensive, like machine learning or data analysis, you'll be better off with a language like C++.

Not statically typed

Python is not a statically typed language. This means that you don't have to declare the types of variables before using them. This can make Python code less reliable, because it's easy to make mistakes that go undetected.

Not good for mobile

Python is not a good choice for mobile development. If you want to develop apps for Android or iOS, you should use a language like Java or Swift.

Hard to test

Python code can be hard to test. This is because Python is interpreted, and because it's not statically typed. It can be difficult to catch all the potential errors in Python code.

Conclusion

Python is a popular, versatile language that's easy to learn. But it has its drawbacks. It's slower, interpreted, and not great for mobile app development. Testing can also be a challenge. If you're looking for a language that's easy to use and has a large community, Python is a good choice. But if you need a language that's optimized for speed, you might look elsewhere.

The Importance of Mental Health

Developers are often seen as independent and strong-willed people who don't need help. While this is sometimes true, we have to remember that we are, in fact, human. Everyone struggles, and everyone needs help sometimes.

Mental health is just as important for developers as it is for anyone else. In fact, it is arguably more important because of the demands of the job.

Programming requires you to be able to focus for long periods of time, handle stress, and deal with difficult challenges. If your mental health is not in good shape, you will quickly become overwhelmed and will not be able to perform at your best.

The Stigma Around Mental Health in Tech

“Mental health problems? No way, not me! I just grind 80 hours a week and get paid.”

Mental health is still seen as a taboo topic, and developers are especially reluctant to talk about it. We're supposed to be the smart ones, the successful ones. We're not supposed to have problems with our brains.

Mental health problems are often seen as a weakness, and people who suffer from these issues worry they'll be viewed as less capable. This is especially true in the tech community, where people are expected to be able to work long hours and handle difficult challenges.

This stigma is one of the reasons why so many developers don't seek help when they are struggling. Many people fear that they will be seen as weak or less capable if they admit that they are having difficulties. This is a dangerous way of thinking, and it is far removed from the truth.

The Reality of Mental Health in the Community

The reality of mental health in the tech community is that it is a very real and very serious issue that most people experience. Developers are just as susceptible to mental health issues as anyone else. In fact, due to the nature of the job, programmers are actually at a higher risk for developing mental health issues. One study showed that around 62% of developers had problems with their mental health at some point in their career!

The most common mental health issues among programmers are anxiety, depression, and general stress. These are all very serious problems that can have a major impact on your ability to do your job. If you are struggling with any of these issues, it is important to seek help from a professional before the situation gets worse.

The Consequences of Neglecting Mental Health

As a developer, you're probably used to neglecting your mental health. After all, there's always another line of code to write, another bug to fix, or another feature to add. Who has time to worry about their mental health when there's work to be done?

Unfortunately, neglecting your mental health can have some serious consequences. For example, you might find yourself struggling to concentrate, feeling irritable or anxious, or experiencing depression.

You might be ignoring your well-being because of work, but it’s eventually going to make you less productive. If you are struggling with mental health issues, you will not be able to focus or be the 10x developer you set out to be. Burnout can lead to errors in your code, missed deadlines, and a general decline in the quality of your work.

It can also lead to isolation. When you are struggling with mental health issues, it is easy to withdraw from social activities and become isolated. This isolation can make your mental health problems worse, and it make it more difficult to get help when you need it.

How to Take Care of Your Mental Health

I would like to preface this section by saying that I am a developer, not a psychologist, and there are plenty of people much more qualified than me to speak on this topic.

That said, there are some obvious things that you can do to take care of your mental health as a developer, and sometimes we all need a reminder of the basics:

• Get enough sleep

  This may seem like an obvious one, but it's important to get enough sleep when you're a developer. Developers are known for being night-owls, but when you're sleep-deprived you're more likely to make mistakes and your productivity will suffer.

• Eat healthy

  Just like your physical health, what you eat affects your mental health. Eating unhealthy food will make you feel sluggish and can lead to mental health issues such as anxiety and depression. So make sure to eat plenty of fruits, vegetables, and whole grains. The All-Coffee Diet just isn't going to cut it.

• Exercise

  Working at a desk all day isn't great for anyone, even if it's a cool convertible standing desk. Exercise is not only good for your physical health, but it's also good for your mental health. It releases endorphins, which have mood-boosting effects. So make sure to get some exercise every day, even if it's just a brisk walk around the block.

• Take breaks

  When you're feeling overwhelmed or stressed, take a break. Step away from your computer and take a few deep breaths. Or go for that walk we just talked about. Taking breaks will help you clear your head and come back to your work refreshed.

• Connect with other developers

  It's important to connect with other developers, because they understand the challenges you're facing. Join an online community or attend meetups to meet other developers in your area. Talking to other developers can help you feel less alone and can give you helpful insights.

• Don’t be afraid to seek professional help

  There is no shame in finding help from a therapist or counselor. In fact, getting professional help is one of the best things that you can do for your mental health and unfortunately, only a small percentage of developers actually do it.

Conclusion

The importance of maintaining your mental health cannot be overstated. Whether you're a developer, programmer, or software engineer, it is important to be honest with yourself about how you are feeling and to seek help if you are struggling.

Don't forget, we're all in this together and nobody is better off ignoring their mental well-being. Take care of that big, beautiful brain and live to code another day!

* The command line interface may differ slightly for various operating systems, but for the most part everything covered in this article should work on all of them.

Why do I need the command line?

There are many reasons you might want to learn and use the command line interface, but it's especially important if one of these describes you:

1. You're a programmer who needs to work with code or other text-based files on a regular basis

2. You want to do something that can't be done with a GUI, or would be very time consuming

3. You're a sysadmin who needs to automate tasks or manage hundreds of servers from the command line

4. You're a power user who wants to be able to customize your system to do exactly what you want it to do

5. You need to learn how to use the command line in order to pass a class or get a job.

6. You want to be an ethical hacker and you love the challenge of getting a computer to do what you want it to do by typing in arcane commands

7. You're a masochist who enjoys typing in commands instead of using a mouse

Of course, this isn't an exhaustive list and if nothing else the CLI can actually be pretty fun to use and customize. Plus, everyone knows that using the CLI automatically makes you L33T.

Common Use Cases

The list of what you can do with the CLI is limited only by your imagination (and hardware), but these are some common uses:

• Create and delete files
• Move, copy, and rename files
• Search for text in files
• Install and remove software
• Connect to remote servers
• Perform system administration tasks

Some History

The command line interface (CLI) is a text-based interface that allows users to interact with a computer using text commands. The CLI was first developed in the early 1970s, when computer users began to need a way to interact with the growing number of computer systems. The CLI was initially developed for use with the Unix operating system, but it has since been adapted for use with other operating systems, such as Microsoft Windows and Apple macOS.

The CLI is typically used by advanced users who are comfortable working with text-based commands. The CLI has a learning curve and is not always the easiest way to interact with a computer, so many users prefer to use a graphical user interface (GUI) instead. However, the CLI can be faster and more powerful than a GUI, so it is still used by many users who need to get work done quickly.

Opening a Terminal

To use the command line, you need to open a terminal. On Linux and Mac, this can be done by opening the "Terminal" application. On Windows, you can use the "Command Prompt" application.

On Linux, the Terminal applicationcan be opened by pressing the CTRL + ALT + T keys simultaneously.

On Mac, the command line interface can be opened by pressing the CMD + SPACE keys simultaneously and then typing "terminal" into the Spotlight search bar. The Terminal app can also be found in the Utilities folder inside Applications.

On Windows, the command line interface can be opened by pressing the Windows key + R keys simultaneously and then typing "cmd" into the Run dialog box.

Navigating the Filesystem

You can't do much if you don't know how to navigate the filesystem on your computer. To do this, you use the cd command to enter a folder. You can type an absolute path, a relative path, or prefix with ~/ to enter a folder relative to the home directory of the user:

# absolute paths start with forward slash
cd /etc/

# relative paths start with the folder name, or a period referring to the current directory
cd etc/
cd ./etc/

# paths relative from home start with a tilde
cd ~/Documents/

* Anything on a line after a # is ignored. These are used to add comments

You can also traverse into parent folders by using .. to go up one directory:

# go up one directory
cd ..

# go up two directories, then into the folder named 'project'
cd ../../project

If you forget where you are, you can use the pwd to display the current directory.

To list files in the current directory, use the ls command:

ls

Options are often added to commands to alter their behavior. These are usually passed with two hyphens and an option name, or a single hyphen and a letter for shorthand. In most cases they can be combined to further tailor the command.

Let's use options to recursively list files and folders or sort them by size:

# list all files in the directory and its subfolders
ls -R

# list files sorted by size
ls -S

If you want to list files in a specific directory, use the ls command followed by the absolute path (starting with / to the directory:

ls /etc/

If you're in an empty folder, there's probably not a lot to look at, so let's change that.

Create and Remove

To create a file, enter the folder where you want the file to live (you know how to do that, right?) and use the touch command, followed by the name of the file—be sure to include the extension!

touch test.txt

If you want it gone, remove it with rm:

rm test.txt

But what about folders? Just use the mkdir command to create a directory:

mkdir test-folder

To remove a folder, we'll use the rm command again, but with an important option passed to it:

rm -r test-folder

The -r options tell the command that we want to recursively remove a folder and all of its contents.

** Note: The rm command deletes files permanently and does not move them to Trash. Be careful!

Now that we have some files and folders, let's look at a how we can move them around.

Moving Files and Folders

Let's move some things around using the mv command. We do this by targeting a source file or folder, and then adding a destination:

# move a file inside a folder
mv sourcefile.txt destination-folder/

There are few very important caveats when using mv to move a file or folder.

1. When moving a file inside of a folder, the destination directory must already exist. If it doesn't then the file will be renamed instead. This can be mitigated by adding a trailing slash (/) to the destination folder name, in which case it will throw an error if it does not exist. It's generally a good practice to end directory names with a trailing forward slash to avoid confusion.

2. By default, if a file already exists with the same name inside the destination folder, it will be overwritten without prompting you. I recommend overriding this by using the "interactive" option -i, which will ask when a file would be overwritten.

Knowing how mv behaves is important, since we'll be using the same command to rename files:

# rename the "original.txt" file to "updated.txt"
mv original.txt updated.txt

You can also change the filename and move it inside a folder, all in one command!

mv original.txt destination-folder/updated.txt

Now we can move and rename our files, but what if we want to duplicate them?

Copy

The cp command is short and sweet, just add the file or files that you want to copy, and the directory that you want it to be copied into. If you want to copy a file into the same directory, include the new name of the duplicated file.

For example:

# copy a file into a directory
cp test.txt myfolder/

# copy multiple files into a directory
cp test1.txt test2.txt myfolder/

# copy a file into the same directory
cp original.txt duplicate.txt

Clear

Let's wrap up with a nice and easy one. The clear command does exactly what it says: it clears the console and gives you a clean slate if things get a bit too cluttered.

clear

Done and done.

Conclusion

Of course, this just scratches the surface of what can be done in the terminal. There are plenty of resources around if you want to learn more, like this article by Artūras B on Hostinger or the Command Line Crash Course on MDN.

The command line interface is a powerful and versatile tool that can be used to perform a wide variety of tasks on a computer. With a little practice, you can use the CLI to do everything from managing files and folders to installing software and performing system administration. It can be daunting at first, but once you get the hang of it, you'll wonder how you ever lived without it.

Next time, we'll look at some more exciting features of the command line interface like piping, the superuser, permissions, personalization, and more!

Let me know in the comments if this was helpful or if you have any questions.

Be sure to follow me for more like this!

Maybe you want to make music, but you don't want to spend money on a DAW or expensive equipment. Or maybe you're just too lazy to learn an instrument. Either way, I have the perfect solution for you: create a playable synthesizer using Tone.js! For this short guide, all you'll need is basic knowledge of HTML, CSS, and JavaScript.

What Is Tone.js?

Tone.js is a JavaScript library for creating interactive music in the browser. With Tone.js, you can create sound files and play them back, create synthesizers and samplers, and much more. You can even use Tone.js to create entire songs! For our purposes, we'll just be using it to create a simple synthesizer that we can play with our mouse or keyboard.

Create a Project

First, we need to create a new project. We'll do this by creating a new folder on our computer and giving it a name. I'm going to call mine "tone-synth". Inside this folder, we'll create three new files: index.html, style.css, and script.js. These are the files that we'll be working with in this tutorial.

Make the Synth

Let's get to work making each part of a simple monophonic synth. We'll want to make a nice piano UI in HTML, style it with CSS, then make it play notes when we click each piano key as well as map each note to the keyboard.

HTML

First, we'll create our HTML and add links to the stylesheet as well as the . We'll start with a simple structure that looks like this:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Vite App</title>
    <link rel="stylesheet" href="style.css" />
</head>

<body>
  <!-- our piano will go here -->

  <script src="https://cdn.jsdelivr.net/npm/tone@14.7.77/build/Tone.min.js"></script>
  <script src="main.js"></script>
</body>

</html>

Now, let's add the HTML for our piano keys. We'll use a simple structure of <div>s with each representing a key, and give it a class to target in CSS. We'll also give each key a data-note value to tell Tone.js what note to play, as well as a data-key to map it to the QWERTY keyboard.

<div class="piano">
  <div class="key white" data-note="C3" data-key="a"></div>
  <div class="key black" data-note="C#3" data-key="w"></div>
  <div class="key white" data-note="D3" data-key="s"></div>
  <div class="key black" data-note="D#3" data-key="e"></div>
  <div class="key white" data-note="E3" data-key="d"></div>
  <div class="key white" data-note="F3" data-key="f"></div>
  <div class="key black" data-note="F#3" data-key="t"></div>
  <div class="key white" data-note="G3" data-key="g"></div>
  <div class="key black" data-note="G#3" data-key="y"></div>
  <div class="key white" data-note="A3" data-key="h"></div>
  <div class="key black" data-note="A#3" data-key="u"></div>
  <div class="key white" data-note="B3" data-key="j"></div>
  <div class="key white" data-note="C4" data-key="k"></div>
  <div class="key black" data-note="C#4" data-key="o"></div>
  <div class="key white" data-note="D4" data-key="l"></div>
  <div class="key black" data-note="D#4" data-key="p"></div>
  <div class="key white" data-note="E4" data-key=";"></div>
  <div class="key white" data-note="F4" data-key="'"></div>
</div>

That's it for our HTML! Now let's move on to CSS.

CSS

Our CSS is fairly simple but results in a nice looking piano. We'll start by setting some globals and styling the piano:

*,
*::before,
*::after {
  box-sizing: inherit;
}

html,
body {
  box-sizing: border-box;
}

body {
  margin: 0;
  display: flex;
  justify-content: center;
  align-items: center;
  width: 100%;
  min-height: 100vh;
  background-color: #282938;
}

.piano {
  display: flex;
  position: relative;
  padding: 40px;
  padding-bottom: 0;
  background-color: #341304;
  border: 1px solid #160801;
  border-radius: 16px;
  user-select: none;
}

We want our piano keys to look like, well, piano keys! To do this, we'll give the keys a width and height, then offset the black keys' margin. Then, set their background color and change it when a key is active.

Our CSS for that will look like this:

.key {
  width: 75px;
  height: 350px;
  border: 2px outset #dddddd;
  border-radius: 0 0 6px 6px;
  background: white;
  margin-bottom: -8px;
}

.key.black {
  z-index: 1;
  height: 225px;
  margin-left: -24px;
  margin-right: -24px;
  width: 50px;
  border-color: #5f5f5f;
  background-color: #222;
}

.key.white.active {
  background-color: #ddd
}

.key.black.active {
  background-color: #000
}

.key.white + .key.white {
  margin-left: 2px;
}

Here's what it should look like:

Lookin' good. Let's move on to the JavaScript portion of our project.

JavaScript

The main.js file is where we'll put all of our code that makes our synth actually work. Let's start by initializing a Tone.js Synth and creating an array from our piano key elements that we can access later:

const synth = new Tone.Synth().toDestination();
const keys = Array.from(document.querySelectorAll('.key'));

Now let's add an event listener so our keys make a sound when we click them. We can do this by creating a 'mousedown' event on document, checking if the event target element contains the class 'key', then triggering an attack with Tone.js. We'll also want to add the 'active' class to the element so that we have a visual indicator:

document.addEventListener('mousedown', (e) => {
  if (!e.target.classList.contains('key')) {
    return;
  }
  synth.triggerAttack(e.target.dataset.note);
  e.target.classList.add('active');
});

We don't want our note to play forever, so let's create a 'mouseup' event listener, where we remove the 'active' class from all keys and trigger a release:

document.addEventListener('mouseup', () => {
  keys.forEach(key => key.classList.remove('active'));
  synth.triggerRelease();
});

That's it for our simple synth! You can test it out by opening index.html in your browser and clicking on each key. You should hear a different note being played back for each key you click on. But what if we want to be able to play our synth with our keyboard instead of just our mouse? Let's do that!

Since each key has a data attribute with its associated QWERTY key, we can create event listeners for 'keydown' then find the element containing that data attribute in the keys array. For 'keyup', we'll do the same thing we did for 'mouseup'.

document.addEventListener('keydown', (e) => {
  const key = keys.find(key => key.dataset.key === e.key);
  if (!key) {
    return;
  }
  key.classList.add('active');
  synth.triggerAttack(key.dataset.note);
});

document.addEventListener('keyup', () => {
  keys.forEach(key => key.classList.remove('active'));
  synth.triggerRelease();
});

Now you can play the notes with your keyboard!

Test It Out

To test out your new synth, open index.html in your browser and try clicking on each key or pressing the corresponding letter on your keyboard. You should hear a different note being played back for each key you click or press.

Here's a working demo on CodePen:

The GitHub repo can be found here.

Conclusion

If everything sounds good, congratulations! You've just created your very first playable synthesizer with Tone.js!

Of course, this is just scratching the surface. In the next article, we'll dive deeper into Tone.js and expand our synth to be polyphonic, as well as add controls to change the sound, adjust levels, switch octaves, and add effects!

Let me know if this was helpful in the comments or if you have any questions.

Be sure to follow me for more like this!

The discord on the topic seems to come back around every few years, so hopefully the following will help bring some clarity to the shouting match.

Understanding HTML

First, let's take a look at what HTML is and what it does.

HyperText Markup Language, abbreviated as HTML, is a markup language used for structuring web pages. HTML is made up of a series of elements, which are represented by tags.

For example, a paragraph element is denoted by the <p> tag, and a heading element is denoted by the <h1> tag.

You can also use HTML to add images, videos, and other multimedia content to your web page.

What Makes a Programming Language?

To determine whether or not HTML is a programming language, we first need to understand what qualifies as a programming language.

Generally, a programming language is a formal language that consists of a set of instructions that can be used to produce a desired output. These languages are used to create programs, which convert the instructions into machine code that can be understood by computers.

Based on this definition, we can say that a programming language must be able to create programs that produce a desired result.

So... Does It Qualify?

The answer is... wait for it... no. HTML is simply not a programming language. You can not write programs in HTML. You can not actually compute anything with HTML. It just doesn't work that way.

HTML is a markup language. That means it's used for formatting and structure, not for logic or computational power. You can use HTML to format and create a layout for a website, but you can't use it to add any functionality.

HTML is not a set of instructions, it is simply a set of tags and data that comprise a document meant to present information.

As I mentioned before, HTML is a markup language. This means that it is used for structuring web pages. Without the ability to compute, HTML does not qualify as a programming language.

"But..."

Some people might argue that HTML is just a different kind of programming language. While I understand that some consider it a declarative language, these arguments just don't hold enough weight.

If you compare HTML to SQL, Wolfram, or any other declarative language, it's pretty obvious which one is not like the others.

There isn't any logic in HTML and it is, for the most part, completely static—it's essentially a text document that can be parsed and processed by programming languages.

Just because something has a lot of features and tags doesn't make it a programming language.

Examples

Just to be clear, here are some examples of programming languages:

• C++
• Rust
• Java

There are also scripting languages, which are slightly different because they are interpreted. That said, these could also be considered programming languages:

• JavaScript
• Python
• PHP

And here are some example of a markup language:

• HTML
• XML

The primary difference here is structuring data vs computing it.

If you need more, check out this exhaustive list of programming languages.

TL;DR

HTML does not have a specific syntax for writing programs; it does not have a set of semantics for interpreting or compiling programs. Therefore, it is not a programming language.

Conclusion

Now, does that mean HTML is useless? Of course not! HTML is a great markup language. It's hard for me to take this stance on the subject because in no way do I support gatekeeping, and its status as a language doesn't make it less important. HTML is essential for creating websites. The fact that it's easy to learn and widely supported also makes it a great entry point for new developers.

The key takeaway is to know the purpose of the tools available to you and understand their capabilities.

Let me know in the comments where you stand on the matter.

Be sure to follow me for more like this!

Further Reading

1. Why HTML is Not a Programming Language
2. Difference Between Programming, Scripting, and Markup Languages
3. Of course HTML is a programming language

You're probably thinking to yourself, "my commits are just fine, thank you." But are they really? Let's take a closer look.

Why Are Good Commits Important?

Git commits are like little snapshots of your code. They let you and others see what changes were made, and when. They also let you roll back those changes when something inevitably goes wrong.

That's why it's important to make sure your git commits are as clear and concise as possible. Otherwise, you run the risk of confusing yourself and others down the road.

The Problem With Your Current Commits

There are three main problems I find with many commits:

1. They're not informative enough.
2. They're not helpful to others.
3. You're putting too many changes in one commit.

Not Enough Information

These commits are essentially worthless. You know the ones I'm talking about - they just say "updated" or "fixed bug" or something similarly unhelpful.

It doesn't have to be that way. Let's look at why these kinds of commits are a problem, and what you can do about it.

1. They don't tell us anything about what was actually changed. Was a bug fixed? Was a feature added? We have no idea.

2. It makes it harder to analyze when we're trying to find out when a particular change was introduced. If a commit just says "updated", we have no way of knowing whether it introduced the change we're looking for or not.

3. It's lazy. If you can't be bothered to write a decent commit message, then why are you making it in the first place?

So, what can you do about it? Simple: make sure your git commits are informative. Tell us what was changed, why it was changed, and how it was changed. Use subject line wisely, and include extra information in the body. Otherwise, developers (including your future self) might just end up ignoring your commits altogether.

Not Helpful to Others

Your git commits should be helpful to others who may be working on the same codebase. That means including information that will help them understand the changes you made, and why.

Here's the problem: when you make a git commit, you're only required to provide a brief message describing the change. But that's not enough information for other developers to understand what you did and why.

As a result, many git commits are cryptic and unhelpful. The classic "updated libraries" doesn't actually tell us anything about the change that was made.

This is a problem because it makes it difficult for other developers to understand the history of a project. It also makes it hard to figure out who to blame when something goes wrong.

And we need to know who's to blame.

Too Much In One Commit

Your git commits should be concise and to the point. You want them to be informative, sure, but one wants to read a novel every time they look at the commit history. I personally have a problem writing commits that are way too long, and often have more files than I should in one commit.

I know, I know, I should be making small, atomic commits that are easy to revert if something goes wrong. But sometimes, I just can't help myself. I make a change, and it's so big and complex that I just have to commit it all at once. And then I have to go through the process of squashing all those changes into a single commit.

It's a pain, and it often leads to messy, hard-to-read commit histories. But worst of all, it can make it really difficult to revert a change if something goes wrong.

So, please, for the sake of your sanity and the sanity of those who have to work with your code, try to avoid making these long commits with multiple files. Stick to the small, atomic changes that are easy to revert.

Your future self will thank you.

How To Write Better Commits

Now that we know what makes a bad Git commit, let's look at how to make your commits better.

Make them more informative.

Your git commits should be clear and concise. That means including a proper description of what changed, and—more importantly—why it changed.

Make them more helpful.

Try to put yourself in another developer's shoes and ask yourself if what you wrote would be helpful to others who may be working on the same codebase. That means including information that will help them understand the changes you made and again, why.

There's a trend here.

Write more, smaller commits.

As I mentioned before, your git commits should be direct and to the point. Be sure to remove any unnecessary information from your commit messages, and split them up where it makes sense. Longer doesn't always mean better; keep the subject line short and move other details to the body. Smaller, atomic commits are much easier to understand and can be rolled back without affecting other working code.

Examples

Here are some examples of good commit messages:

Example 1

Remove unused CSS

Get rid of unused selectors from primary stylesheet to drastically reduce load time.

Example 2

Update README

Add a new section on how to run tests to provide more information to developers.

Example 3

Fix bug in login flow

Add a new redirect which takes users to the home page if they're already logged in, preventing users from getting stuck.

Conclusion

Writing quality Git commits is a crucial part of building a successfully project and collaborating with other developers. Your messages should be clear, concise, and helpful to others. By following these tips, hopefully you can make sure your commits are all of those things.

If you want to take it a step further, you could follow the Conventional Commits specification.

Let me know in the comments if this was helpful or if you have any questions.

Be sure to follow me for more like this!

Jared Sumner, a former developer at Stripe, released Bun in July of 2022. Bun is a runtime developed using the relatively obscure Zig programming language that embraces web standards but aims for compatibility with Node.js, so developers can easily migrate existing code.

All of that is great and interesting, but what separates Bun from other runtimes, and does it really stand a chance against the big players?

What Makes It Different

One of the most distinguishing features of Bun is that it uses JavaScriptCore as its engine, unlike Node.js and Deno, which use V8. The result is a blazing fast runtime that offers several quality-of-life features for JS developers.

Bun also has first-class integration of TypeScript and JSX, while also providing many of the features of transpilers like Babel, and bundlers like Webpack, Rollup, and Vite.

Diving In

Let's get started with Bun by installing it. According to the official documentation, this requires only the following command:

curl https://bun.sh/install | bash

After it's finished just follow the confirmation prompt with directions for adding Bun to your PATH.

Writing and running our first Bun script is pretty simple. We can run Bun.serve by using the command bun run script.js and then going to localhost:3000 to see the response to our request.

It's very common to need to read and write to files when building applications, and Bun makes this dead simple. In this example we'll create a file containing the URL each time we submit a request:

let count = 1;
Bun.serve({
    fetch(request) {
        Bun.write(`test-${count}.txt`, request.url);
        count++;
        return new Response('Created Test File');
    },
});
console.log('Listening on Port 3000');

Features Baked-In

Support for SQLite by default is another nice touch. Querying your database is a breeze and you don't have to install external packages.

Using .env files with Bun is also quite easy. You can simply access them with process.env like in Node, but without needing to install dotenv.

The Node.js Killer?

As of right now Bun is still in its infancy, with many APIs and features not yet implemented. I don't see it replacing Node.js anytime soon, but with that said, its speed and features are enough to grab my attention. I'll certainly be keeping an eye on it to see how it progresses.

Are you excited about Bun, or are you content with Node.js? Let me know in the comments.

Be sure to follow me for more like this!

Web3 was touted as the next phase of the internet, focused on decentralization. The idea was that there would be no central authority controlling it, instead relying on a network of computers worldwide. Sounds great in theory, right?

The promise was that you could use the web without worrying about being tracked or censored by a central authority. Instead of relying on tech giants like Google and Facebook to store your data, Web3 would allow you to do it yourself. It was supposed to open up incredible opportunities for increased transparency, security, and creativity.

But let's be real: it hasn't quite panned out that way.

The Web3 hype train attracted a swarm of scammers, con artists, and opportunists looking to make a quick buck. Because there's no central authority, it's been a challenge to stop bad actors from doing nefarious deeds. Remember all those stories about NFT rug pulls and crypto scams? Yeah, that's the dark side of decentralization.

Another glaring issue is that Web3 is still complicated and difficult to use for the average person. Even if you're tech-savvy, figuring out how to set up a Web3 wallet or use a decentralized exchange can be a headache. This complexity, combined with a general lack of understanding among average internet users, has seriously slowed adoption.

Let's dive into some of the ways Web3 was supposed to change how we use the internet, and see how reality measures up.

Read, Write, Own... Sort of

Web 1.0 was mostly read-only. Web 2.0 allowed users to interact through comments, reactions, and shares. Web3 promised that we could not only read and write but also own our data.

In practice, though, most people are still using centralized platforms. Sure, you can technically "own" your data on a blockchain, but good luck explaining that to your grandma. The reality is that most users are still happily handing over their data to Facebook, Google, and Amazon.

The Promise of Better Transactions

Web3 promised the ability to transact money directly on the web without intermediaries. While cryptocurrencies have made some headway, they're far from replacing traditional financial systems.

Here's the reality of using Web3 for financial transactions:

1. It's fast... when it works. Network congestion can slow things to a crawl.

2. It's convenient... if you don't mind the learning curve and potential for costly mistakes.

3. It's secure... until someone hacks an exchange or you lose your private keys.

4. It's private... except when it's not. Blockchain transactions are often more traceable than cash.

A New Take On Identity

Web3 promised secure, decentralized identities. In reality, most people are still logging in with their Google or Facebook accounts because it's just easier.

While there have been some interesting developments in decentralized identity, adoption has been slow. Most users still prefer the convenience of centralized identity providers, even if it means sacrificing some privacy.

There Was An Attempt

Web3 was supposed to be the internet's rebellion against data mishandling by social networks. While concerns about data privacy are still very real, Web3 hasn't exactly led to a mass exodus from traditional platforms.

The reality is that most people are still using Facebook, Twitter, and Instagram. The promised land of secure, decentralized, and censorship-resistant social networks remains largely theoretical.

A New Era for Artists, Or Just More Hype?

Web3 was supposed to revolutionize the creative industry, allowing artists to own their work and connect directly with fans. While some artists have found success with NFTs, the reality for most has been less rosy.

The NFT craze led to a lot of hype and some eye-watering prices, but it also brought a flood of low-quality cash grabs and outright scams. Many artists found themselves spending more time marketing their NFTs than creating art. And let's not forget the environmental concerns around the energy consumption of blockchain networks.

Better Communities

Decentralized Autonomous Organizations (DAOs) were touted as a revolutionary way to organize communities. While there have been some interesting experiments, DAOs have also faced challenges with governance, legal recognition, and scalability.

The reality is that most people are still more comfortable with traditional organizational structures. DAOs remain a niche concept, largely confined to the crypto community.

We're Not Quite There, Yet... And Maybe We Never Will Be

The dream of a fully decentralized web remains just that—a dream. Ethereum, often held up as the backbone of Web3, is still largely controlled by a small group of whales and mining pools. Key infrastructure remains centralized, and most users still rely on centralized exchanges and wallets.

The push towards Web3 has also raised important questions about scalability, energy consumption, and regulatory compliance. As governments around the world start to take a closer look at cryptocurrencies and blockchain technologies, the future of Web3 remains uncertain.

Conclusion

Web3 has potential, but it's important to separate the hype from reality. While it has introduced some interesting concepts and technologies, it hasn't revolutionized the internet as many predicted. It's still a niche interest, plagued by complexity, scams, and regulatory uncertainty.

That said, some of the ideas behind Web3—like increased data ownership and privacy—are worth pursuing. The challenge lies in making these concepts accessible and useful to the average internet user. Until then, Web3 remains more of a playground for tech enthusiasts and speculators than a true next generation of the web.

There are a few things you can do to increase your chances of finding clients. In this article, we will discuss some of the best ways to find clients as a freelance programmer.

Contribute to Open Source

One of the best ways to build your portfolio is to contribute to open-source projects. Not only will this give you some great experience, but you'll also get your name out there and make some important connections.

There are a few ways to find open source projects to contribute to. One is to search for them on GitHub, and another is to look for them on popular programming forums.

Once you've found a project you'd like to contribute to, the next step is to make sure you have the skills required. If you don't, that's okay! There are plenty of projects that need documentation or other non-coding tasks completed.

Once you've found a project and made sure you have the required skills, the next step is to reach out to the project maintainers and let them know you're interested in contributing. They'll be able to give you more specific instructions on what they need and how you can help.

When you contribute to open source, make sure to include a link to your website or blog so that people can see your work. You can also list your contributions on your resume or website to show potential clients what you're capable of.

Find Your Niche

There are a lot of programmers out there, and it can be difficult to stand out from the crowd. But if you focus on a specific area or technology, you'll be more likely to find clients who are looking for someone with your skills.

There are a few ways to find your niche. One is to think about the technologies you're most interested in. Another is to look at the projects you've worked on in the past and see if there's a common thread.

Once you've identified your niche, the next step is to start marketing yourself as an expert in that area. Write blog posts, give talks at meetups, and get involved in online communities. The more you can position yourself as an expert, the more likely you are to find clients who need your help.

When you focus on a specific niche, you will be able to build a strong portfolio and become an expert in that area. This will make you more attractive to potential clients who are looking for someone with your specific skills.

Build a Strong Online Presence

In breaking news to nobody, it's important to have a strong online presence. This means having a website or blog where you can showcase your work, and being active on social media.

As a programmer, you're probably used to spending most of your time in front of a computer screen, alone in your own thoughts. But if you want to be successful in today's world, you need to be more than just a coder—you need to be a social media superstar.

That's right, in order to build a successful career as a programmer, you need to have a strong social media presence. But don't worry, it's not as difficult as it sounds. Here are a few tips to help you get started:

1. Be active

   This may seem like a no-brainer, but it's important to be active on social media if you want to build a strong presence. Post regularly, interact with other users, and make sure you're constantly putting yourself out there.

2. Share your work

   If you're proud of the work you're doing, make sure you share it on social media! Post your code snippets, share your blog posts, and let the world know what you're up to.

3. Connect with other programmers

   One of the best ways to build a strong social media presence is to connect with other programmers. Follow them on Twitter, retweet their blog posts, and engage in discussion.

4. Be yourself

   People connect with people, not robots. So make sure you're being authentic on social media. Share your interests, your thoughts, and your personality.

5. Have fun!

   Building a social media presence can be a lot of work, but it should also be fun. So make sure you're enjoying the process and having a good time.

If you want my personal opinion (why else are you reading this?) I would highly recommend TikTok if you're trying to decide what platform to use.

How to Find Clients

Now that you've built a strong online presence, it's time to start looking for clients. There are a few different ways to find clients, and the best method will vary depending on your niche.

One of the most popular ways to find clients is to use online platforms like Upwork, Toptal, or Freelancer.com. These platforms allow you to create a profile and bid on projects that clients have posted.

Another way to find clients is to reach out to them directly. This can be done by sending them an email or connecting with them on social media. If you have a personal connection with a potential client, this can be a great way to get your foot in the door.

You can also get referrals from other freelancers or businesses. If you know someone who has worked with a client that you think would be a good fit for you, reach out and ask for a referral.

Upwork

Upwork is a great place to find clients. It's a freelancing marketplace where you can create a profile and bid on projects.

To be successful on Upwork, you need to have a strong profile and portfolio. You also need to be able to market yourself well and sell your skills to potential clients.

Toptal

Toptal is a freelancing marketplace that is specifically for top talent. To be accepted onto the platform, you need to pass a rigorous screening process.

Once you're accepted, you will be able to access a wide range of high-paying clients. To be successful on Toptal, you need to have a strong portfolio and be able to market yourself well.

Fiverr

Fiverr is a freelancing marketplace where you can offer services starting at $5. While this may not seem like a lot of money, you can offer multiple services and upsells to make more money.

To be successful on Fiverr, you need to have a strong portfolio and be able to market yourself well. You also need to be able to deliver your services quickly and efficiently.

Freelancer.com

Freelancer.com is a freelancing marketplace where you can find a wide range of clients. To be successful on Freelancer.com, you need to have a strong portfolio, be able to market yourself well, and be able to deliver your services quickly and efficiently.

Keeping Your Clients

Once you've found a few clients, you need keep them happy. This can be done by delivering high-quality work on time and keeping communication channels open.

It's crucial that you keep your clients updated on your availability. If you know you're going to be unavailable for a period of time, let them know in advance so they can make alternative arrangements.

Always be professional. This means being polite, respectful, and responsive. The importance of good communication can't be stressed enough. If you're able to build strong relationships with your clients, they will be more likely to keep working with you.

Get Referrals

One of the best ways to find new clients is to get referrals from your existing clients. If you're doing a good job and they're happy with your work, they will be more likely to refer you to their friends or colleagues.

Another way to get referrals is to offer a discount to clients who refer you to someone else. This can be done by giving them a percentage off their next project or a gift card to a popular retailer.

You can also ask for testimonials from your clients which you can use to market yourself. This is a great way to show off your work and give potential clients an idea of what it's like to work with you.

Conclusion

As a freelance programmer, it's important to find ways to stand out from the crowd. By following the tips in this article, you will be able to find more clients and build strong relationships with them.

Let me know in the comments if you found this helpful or if you have any questions.

Be sure to follow me for more like this!

What is a Doubly Linked List?

A doubly linked list is a data structure that consists of a set of nodes that are linked together in a linear fashion. Each node contains two pointers: one that points to the next node in the list, and one that points to the previous node in the list. The first and last node have their previous and next pointing to null, respectively. This allows for bidirectional traversal of the list.

Creating a Doubly Linked List in C++

Creating a doubly linked list in C++ is fairly simple. First, we need to define a node class:

class Node {
public:
    int data;
    Node* next;
    Node* prev;
};

Next, we need to create a function that will add a new node to the list:

void addNode(Node* &head, int data) {
    Node* newNode = new Node();
    newNode->data = data;
    newNode->next = head;
    newNode->prev = nullptr;
    if (head != nullptr)
        head->prev = newNode;
    head = newNode;
}

Now that we have a function to add nodes, we can create a doubly linked list by calling this function multiple times:

Node* head = nullptr;
addNode(head, 1);
addNode(head, 2);
addNode(head, 3);
addNode(head, 4);
addNode(head, 5);

We can print the list by traversing it and printing each node's data:

void printList(Node* head) {
    while (head != nullptr) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

Putting everything together, we have the following program:

#include <iostream>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node* prev;
};

void addNode(Node* &head, int data) {
    Node* newNode = new Node();
    newNode->data = data;
    newNode->next = head;
    newNode->prev = nullptr;
    if (head != nullptr)
        head->prev = newNode;
    head = newNode;
}

void printList(Node* head) {
    while (head != nullptr) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

int main() {
    Node* head = nullptr;
    addNode(head, 1);
    addNode(head, 2);
    addNode(head, 3);
    addNode(head, 4);
    addNode(head, 5);
    printList(head);
    return 0;
}

Running this program produces the following output:

5 4 3 2 1

You can also print the list in reverse by traversing it from the end and printing each node's data:

void printListReverse(Node* head) {
    while (head->next != nullptr)
        head = head->next;
    while (head != nullptr) {
        cout << head->data << " ";
        head = head->prev;
    }
    cout << endl;
}

If we add this function to our program and call it, we get the following output:

1 2 3 4 5

Conclusion

Doubly linked lists are a powerful data structure that can be used to store data in a linear fashion while still allowing for quick traversal in both directions. In C++, they can be easily created and manipulated using the built-in node class.

Based on my findings, here are a few things you can try if you want a more successful project.

Piggyback off of an existing popular project

A major reason why bs5-lightbox gets the amount of attention it does is because it was created for Bootstrap, an incredibly popular front-end framework. By creating a plugin that piggybacks off of an existing project, you're immediately introducing your package to a large audience that is already interested in what you're offering.

Replace an out-of-date tool

I think another large contributing factor to the success of bs5-lightbox is that it replaces an already successful, but out of date tool called Ekko Lightbox. Many people, including myself would reach for it but then realize it was only compatible with Bootstrap 4. So, by creating a tool to fill that void, I was able to attract users who were looking for a similar solution.

Have a good name

This might seem like a no-brainer, but it's important to have a name for your project that is both accurate and memorable. In the case of bs5-lightbox, the name is accurate (it's a lightbox gallery plugin for Bootstrap 5) and it's also easy to remember.

Make it as simple as possible

This is probably the most important tip I can give. The bs5-lightbox package is extremely simple. It's just one JavaScript file. That's it. It just works. And I think that's why people like it so much. It's easy to install and it does one thing well.

Lightbox for Bootstrap 5 is also very easy to setup. It can be installed with a simple npm install bs5-lightbox or by adding a script tag with a link to the CDN. No need to fiddle with any build tools or configuration files.

Offer a live demo

People are always more likely to use something if they can see it in action first. That's why I created a live demo of bs5-lightbox that people can try out before they download it. This not only lets people see what the lightbox looks like, but it also shows them how easy it is to use.

Have good documentation

Once people have decided to use your package, it's important to have good documentation so they know how to do so. This can be in the form of a README file, a wiki, or even a blog post like this one. As long as it is clear and concise, people will be able to get up and running with your package in no time.

Keep it updated

Finally, it's important to keep your package updated with the latest versions of the dependencies it uses. In the case of bs5-lightbox, that means always using the latest version of Bootstrap. Not only does this ensure that your package works with the latest versions of the dependencies, but it also shows that you are keeping up with the latest changes.

Offer support

I try to offer support for bs5-lightbox as much as I can through its GitHub page. I think this is important because it shows that I'm actively involved in the project and care about its users. I respond to issues as soon as I can and I encourage developers who have solved problems with the package to create Pull Requests.

Be open to feedback

Finally, I was open to feedback and was always looking for ways to improve the project. I never wanted to rest on my laurels and I think that helped me keep people interested in the project.

I don't think there's a magic formula for making a successful project, but I do think the popularity Lightbox for Bootstrap 5 was a combination of these factors. I was lucky enough to create a tool that filled a void for a large and active community. But, I also put in the work to make sure people knew about it and understood how to use it. If you're thinking about creating an NPM package, I hope this was helpful. Good luck!

What are data structures?

In computer science, a data structure is a data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.

When I first started programming, I found data structures and algorithms to be incredibly confusing. Hopefully this article will help developers who are new to these concepts understand how to use some of the more common data structures.

Data structures are used to store data in a computer in an organized way so that it can be used efficiently. Different types of data structures are suited to different kinds of applications, and some are highly specialized to specific tasks. For example, trees are particularly well-suited for implementing databases, while compiler implementations usually use hash tables to look up identifiers.

Common Data Structures

There are many ways to store data, but the data structures I'll be talking about today are Arrays, Linked Lists, Hash Tables, and Trees.

Arrays

Arrays are the simplest data structure. They are just a list of items, where each item can be accessed by its index. For example, an array of numbers might look like this:

const arr = [1, 2, 3, 4, 5];

To access an item in the array, we just use its zero-index. For example, to get the third item, we would do this:

const x = arr[2]

Arrays have some drawbacks, though. They are not very flexible, and they can be slow to access items if the array is large.

Linked Lists

Linked lists are a more flexible data structure than arrays. They are made up of nodes, which are connected together like a chain. Each node contains data, and a pointer to the next node in the list. A linked list of numbers could be visualized like this:

1 -> 2 -> 3 -> 4 -> 5

To access an item in the linked list, we just follow the pointers until we reach the desired node.

To create a linked list in JavaScript, we can create a class that maintains a head pointer in the list:

class LinkedList {
  constructor() {
    this.head = null;
  }
}

We can then create nodes for our list. Each node will have a value and a pointer to the next node in the list:

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

We can now create methods on our LinkedList class to add nodes to the list:

class LinkedList {
  constructor() {
    this.head = null;
  }

  // adds a node to the end of the list
  add(value) {
    const node = new Node(value);

    // if the list is empty, set the node as the head
    if (this.head === null) {
      this.head = node;
      return;
    }

    // otherwise, traverse the list until we find the last node
    let current = this.head;
    while (current.next !== null) {
      current = current.next;
    }

    // set the last node's next pointer to the new node
    current.next = node;
  }

  // removes a node from the list with the given value
  remove(value) {
    // if the list is empty, do nothing
    if (this.head === null) return;

    // otherwise, check if the head node needs to be removed
    if (this.head.value === value) {
      this.head = this.head.next;
      return;
    }

    // otherwise, traverse the list until we find the node to remove
    let current = this.head;
    while (current.next !== null) {
      if (current.next.value === value) {
        // set the next pointer of the current node to the node after the one we're removing
        current.next = current.next.next;
        return;
      }

      current = current.next;
    }
  }

  // returns true if the list contains a node with the given value, false otherwise
  contains(value) {
    // if the list is empty, return false
    if (this.head === null) return false;

    // otherwise, traverse the list until we find the value or reach the end
    let current = this.head;
    while (current !== null) {
      if (current.value === value) return true;

      current = current.next;
    }

    return false;
  }
}

We can now create a list and add nodes to it:

const list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);

And we can remove nodes:

list.remove(2);

Finally, we can check if the list contains a certain value:

list.contains(3); // true
list.contains(4); // false

Linked lists are more flexible than arrays because we can easily insert and remove items without changing the rest of the list. They can also be slower to access items, though, because we have to follow the pointers.

Hash Tables

Hash tables are used to store key-value pairs. The key is used to look up the value, like a dictionary. A hash table of numbers can be visualized like this:

1 -> 2
3 -> 4
5 -> 6

To implement a hash table in JavaScript, we can use an object to store the key-value pairs. The keys can be used as the object's properties, and the values can be stored as the property values.

For example, we could store a user's name and age in a hash table like this:

const user = {
  name: "John",
  age: 30
};

To lookup a value in the hash table, we can use the key as the index:

const name = user.name; // "John"
const age = user.age; // 30

To add a new key-value pair to the hash table, we can simply create a new property on the object and assign it a value:

user.city = "New York";

To remove a key-value pair from the hash table, we can use the delete operator:

delete user.city;
``

You can also use `Map` to implement hash tables. Using JavaScript's `Map` class for hash tables has some advantages over using a standard object. For instance, `Map` keeps track of the order in which keys are added, which is important for some algorithms. It also provides some handy methods like `forEach()` and `values()` that make iteration more straightforward.

Here's how you might create a hash table with `Map`:

```javascript
const hashTable = new Map();

hashTable.set('foo', 'bar');
hashTable.set('baz', 'qux');

console.log(hashTable.get('foo')); // 'bar'
console.log(hashTable.get('baz')); // 'qux'

Just be careful not to accidentally use the same key twice. If you do, the second value will overwrite the first:

hashTable.set('baz', 'bar');

console.log(hashTable.get('baz')); // 'bar'

Hash tables are very fast to access items, because the key is used to directly look up the value. They are not very flexible, though, because the keys have to be unique.

Trees

Trees are a type of data structure that is used to store data in a hierarchical way. That is, each item has a parent and zero or more children. For example, a tree of numbers might look like this:

  1
 / \
2   3
   / \
  4   5

Each node has a value, and a link to another node (or null, if there is no child node).

To access an item in the tree, we just follow the path from the root to the desired node.

Here is an example of how this might be implemented in JavaScript:

class Node {
  constructor(value) {
    this.value = value;
    this.child = null;
  }
}

class Tree {
  constructor() {
    this.root = null;
  }

  // add a node to the tree
  addNode(value) {
    const node = new Node(value);

    // if the tree is empty, the node is the root node
    if (this.root === null) {
      this.root = node;
    } else {
      // find the correct place to add the node

      // start at the root node
      let current = this.root;

      // loop until we find an empty spot
      while (current.child) {
        current = current.child;
      }

      // add the node
      current.child = node;
    }
  }

  // remove a node from the tree
  removeNode(value) {
    if (this.root === null) {
      // tree is empty
      return;
    }

    // start at the root node
    let current = this.root;

    // keep track of the parent node
    let parent = null;

    // loop until we find the node to remove
    while (current.value !== value) {
      // update the parent node
      parent = current;

      // move to the child node
      current = current.child;

      // if there is no current node, the value is not in the tree
      if (current === null) {
        return;
      }
    }

    // if we get here, we've found the node to remove

    // if the node to remove is the root node, just set the root to null
    if (this.root === current) {
      this.root = null;
      return;
    }

    // if the node to remove is not the root node,
    // we need to find the parent node

    // if the node to remove is the parent's only child,
    // just set the parent's child to null
    if (parent.child === current) {
      parent.child = null;
      return;
    }

    // if the node to remove is the parent's first child,
    // we need to find the node's next sibling

    // start at the parent's first child
    let sibling = parent.child;

    // loop until we find the node's next sibling
    while (sibling.child !== current) {
      sibling = sibling.child;
    }

    // if we get here, we've found the node's next sibling

    // set the node's next sibling to the node's current child
    sibling.child = current.child;
  }

  // search for a node in the tree
  search(value) {
    if (this.root === null) {
      // tree is empty
      return null;
    }

    // start at the root node
    let current = this.root;

    // loop until we find the node or reach the end of the tree
    while (current.value !== value && current.child) {
      current = current.child;
    }

    // if we get here and current.value is not equal to value,
    // the node was not found

    return current;
  }
}

Here's how we would use the Tree class:

const tree = new Tree();

tree.addNode(1);
tree.addNode(2);
tree.addNode(3);
tree.addNode(4);

tree.search(3); // returns the node with value 3
tree.search(5); // returns null

tree.removeNode(3); // removes the node with value 3

Trees are very flexible, because we can easily add and remove items. They can be slower to access items, though, because we have to follow the path from the root.

Conclusion

Data structures are important in programming because they provide a way to store and retrieve data efficiently. Without data structures, it would be very difficult to write programs that could manipulate data in a useful way.

I hope you found this article helpful and that you now have a better understanding of how to use data structures in your own code.

Let me know in the comments if you found this article helpful or if you have any questions.

Be sure to follow me for more like this!

Proxies are a relatively new feature in JavaScript, and provides a way to create "virtual" objects that can intercept property accesses and perform custom operations.

What are Proxies?

A Proxy is like a middle-man who can sit between you and the thing you're trying to access. You can tell the Proxy what you want to do, and it can either do it for you, stop you from doing it, or do something else entirely.

In JavaScript, objects can have properties that are themselves objects. For example, you might have an object with a property named "foo" that contains another object:

var obj = {
    foo: {
        // ...
    }
};

Proxies provide a way to intercept these property accesses and perform custom operations. In the above example, we could use a proxy to intercept calls to obj.foo and do something else instead:

const proxy = new Proxy(obj, {
    get: function(target, property, receiver) {
        if (property == "foo") {
            // ... do something else
        } else {
            // return the default behavior
            return Reflect.get(target, property, receiver);
        }
    }
});

In this case, we intercept calls to get (which is used to retrieve a property value) and check if the property name is "foo". If it is, we do something else; otherwise, we return the default behavior.

Creating Proxies

Proxies are created using the new Proxy() constructor:

const proxy = new Proxy(target, handler);

The target argument is the object that the proxy will "proxy" for; that is, operations on the proxy will be forwarded to the target object. The handler argument is an object that defines which operations the proxy will intercept.

Proxy Handler Methods

The handler object can define any of the following methods:

• get(target, property, receiver): Called when a property is accessed.
• set(target, property, value, receiver): Called when a property is set.
• has(target, property): Called when using the in operator.
• deleteProperty(target, property): Called when using the delete operator.
• apply(target, thisArg, argumentsList): Called when a function is invoked.
• construct(target, argumentsList, newTarget): Called when a constructor is invoked.

These methods all have the same signature as the corresponding Reflect methods. The Reflect methods are used to perform the default behavior for an operation; if you want to customize the behavior, you can override the corresponding handler method.

Example: Validating Property Values

In these examples, the JavaScript Proxy API acts like a security guard at a nightclub. It can intercept requests and make sure they are valid before allowing them to pass through.

Let's say we have an object that represents a user's profile, and we want to make sure that the age property is always a positive number. We can do this by creating a proxy for the object, and intercepting calls to set:

const profile = {
    name: "John Doe",
    age: 42
};

const proxy = new Proxy(profile, {
    set: function(target, property, value, receiver) {
        if (property == "age") {
            if (typeof value != "number" || value < 0) {
                throw new Error("Invalid age");
            }
        }
        // return the default behavior
        return Reflect.set(target, property, value, receiver);
    }
});

Now, if we try to set the age property to an invalid value, we'll get an error:

proxy.age = "42"; // Error: Invalid age

Example: Logging Property Accesses

In this example, we'll create a proxy that logs all property accesses:

const obj = {
    foo: "bar"
};

const proxy = new Proxy(obj, {
    get: function(target, property, receiver) {
        console.log("getting property " + property);
        // return the default behavior
        return Reflect.get(target, property, receiver);
    },
    set: function(target, property, value, receiver) {
        console.log("setting property " + property + " to " + value);
        // return the default behavior
        return Reflect.set(target, property, value, receiver);
    }
});

Now, whenever we access or set a property on proxy, we'll see a message in the console:

proxy.foo; // getting property foo
proxy.foo = "baz"; // setting property foo to baz

Proxy Revocability

Proxies are revocable, which means that they can be disabled after they've been created. To do this, we use the Proxy.revocable() method:

const obj = {
    foo: "bar"
};

const revocable = Proxy.revocable(obj, {
    get: function(target, property, receiver) {
        console.log("getting property " + property);
        // return the default behavior
        return Reflect.get(target, property, receiver);
    },
});

const proxy = revocable.proxy;

Now, proxy behaves just like our previous example. We can access and set properties, and we'll see messages in the console:

proxy.foo; // getting property foo
proxy.foo = "baz"; // setting property foo to baz

When we're finished with the proxy, we can disable it by calling the revoke() method:

revocable.revoke();

Now, if we try to access or set properties on proxy, we'll get an error:

proxy.foo; // TypeError: Cannot perform 'get' on a proxy that has been revoked
proxy.foo = "baz"; // TypeError: Cannot perform 'set' on a proxy that has been revoked

Conclusion

Proxies provide a powerful way to intercept and customize property accesses in JavaScript. I hope this has helped you understand how to create proxies, and how to use them to perform operations such as validating property values and logging property accesses.

Related to Proxies is the incredibly useful Reflect API, so stay follow or signup for an article on that soon.

Let me know in the comments if you liked this or have any questions—be sure to follow me for more like this!

So what are memory leaks? How do memory leaks happen in JavaScript, and how can you prevent them?

What are memory leaks?

Memory leaks are a type of resource leak that occurs when a computer program fails to release memory after it is no longer needed. Memory leaks may not be serious or even noticeable in some programs, but can cause web browsers to slowly become unresponsive over time.

How do memory leaks happen in JavaScript?

JavaScript memory leaks happen when variables or objects are not properly released after they are no longer needed. This can happen when you forget to call the delete operator on an object, or when you hold onto a reference to an object that is no longer needed.

How can I tell if my JavaScript code has a memory leak?

One of the most frustrating things that can happen when you're working on a JavaScript project is finding a memory leak. Memory leaks can be tough to track down, and they can cause your project to run slowly and eventually crash. But don't despair! There are some tools and techniques you can use to find and fix memory leaks in your code.

The first thing you need to do is identify where the leak is happening. If you're using a web browser, you can use the built-in developer tools to take a heap snapshot. This will give you a list of all the objects that are currently in memory, and how much memory they're using. Take a look at the list of objects and see if there's anything that looks out of place.

Once you've found the general area where the leak is happening, it's time to start digging into the code. Look for any places where you're creating new objects or arrays, but not deleting them when you're finished with them. This is a common cause of memory leaks, because the objects and arrays will continue to stay in memory even after you're finished with them.

There are a few tools that can help you find memory leaks in your JavaScript code:

1. The Chrome Developer Tools are a great way to find out what's going on in your web application. Simply open the Developer Tools in your browser, go to the "Memory" tab, and take a look at the "Allocated" and "Used" memory. If the "Used" memory is constantly increasing, then you probably have a memory leak.

2. Use third party tools.

   fuite - Fuite uses Puppeteer with Chrome to automate memory leak testing.

   heapdump - This package can generate a snapshot of your application's memory usage, which can be analyzed to find out where the leaked memory is being allocated.

3. You can also use a profiler to find out what functions in your code are using the most memory. This type of profiler, called a "sampling profiler", takes periodic snapshots of your application's memory usage. By analyzing these snapshots, you can identify which functions are using the most memory and where the leaks are happening.

How can I fix a memory leak in my JavaScript code?

There are many ways to fix a memory leak in your JavaScript code. One obvious way is to identify the leaking variable or object and manually call the delete operator on it. Another way is to identify the leaking variable or object and nullify it.

Here are a few more ways to resolve memory leaks:

1. Remove unused event listeners: If you're no longer using a certain event listener, be sure to remove it using the removeEventListener() method. This will ensure that it is no longer taking up memory.

2. Use WeakMaps: WeakMaps are a type of data structure that can be used to store key-value pairs, but with the caveat that the keys must be objects. This is important because it means that the keys can be garbage collected if there are no other references to them. This can be useful for preventing memory leaks if you're using dictionaries to store data that you may not need anymore.

3. Avoid circular references: Circular references occur when two objects reference each other, creating a "loop". This can lead to memory leaks because the two objects will never be garbage collected as long as they reference each other. To avoid this, make sure that your objects only reference other objects that they absolutely need to.

If you're using a library or framework, you may also be able to find a way to configure it to automatically release memory when it's no longer needed. For example, React has a shouldComponentUpdate lifecycle hook that allows you to prevent a component from re-rendering if its props have not changed. This can help to prevent memory leaks by automatically releasing memory when it's no longer needed.

Conclusion

I hope this article has helped you to understand what memory leaks are, how they happen in JavaScript, and how you can identify and fix them.

Learn more about memory leaks by reading MDN's article on Memory Management.

If you have any questions, feel free to ask in the comments.

Be sure to follow me for more like this!

What is Deno?

Deno is a runtime for JavaScript, TypeScript, and WebAssembly that is based on the V8 JavaScript engine and the Rust programming language. It was created by Ryan Dahl, the original creator of Node.js, to remedy some the regrets he had when making Node.

Why Should I Use Deno?

Here are a few reasons why you might want to use Deno:

1. Secure by default. This means that it uses a sandbox to prevent code execution from outside the Deno process, and all network and file system operations are sandboxed by default.

2. Built-in support for TypeScript.

3. Ships with a set of standard libraries, which are written in TypeScript and are located in the Deno namespace. This means that you don't have to install third-party libraries to use Deno.

4. A plugin system that allows you to import third-party libraries as plugins. This means that you can import only the functionality that you need, and the plugin is sandboxed and can't access the Deno process.

5. A built-in test runner, which makes it easy to write and run tests for your Deno applications.

6. Open source and released under the MIT License.

Getting Started

Now that you know a little bit about Deno, let's get started!

First, you need to install Deno. The easiest way to do this is in with curl:

curl -fsSL https://deno.land/x/install/install.sh | sh

If you're on Mac, you can install Deno with a package manager like Homebrew.

brew install deno

Now that you have Deno installed, you can run Deno programs with the deno command.

deno run https://deno.land/std/examples/cat.ts

This will fetch and run the cat.ts program from the Deno Standard Library. The Deno Standard Library contains a collection of reusable Deno programs.

Now that you know how to run Deno programs, let's write our own! Create a file called hello.ts and add the following code to it:

console.log("Hello, world!");

You can run this program with the deno command:

deno run hello.ts

You should see the output Hello, world!.

That's it! You've written your first Deno program!

Writing Deno Programs

Now that you know the basics of Deno, let's dive a bit deeper. In this section, we'll learn about some of the more advanced concepts in Deno.

Scripts and Modules

In Deno, there are two ways to structure your code: scripts and modules.

Scripts are simple programs that are run with the deno command. Modules are program modules that can be imported by other programs.

Let's see an example of each.

First, let's create a script. Create a file called script.ts and add the following code to it:

console.log("This is a script.");

You can run this script with the deno command:

deno run script.ts

Next, let's create a module. Create a file called module.ts and add the following code to it:

export function hello() {
  console.log("Hello, world!");
}

This module exports a single function called hello. We can import this function into another program and call it.

Create a file called main.ts and add the following code to it:

import { hello } from "./module.ts";

hello();

This program imports the hello function from the module.ts module and calls it.

You can run this program with the deno command:

deno run main.ts

You should see the output Hello, world!.

Libraries

In Deno, libraries are collections of modules that are bundled together. Libraries can be published to Deno's Registry so that they can be easily reused by others.

Let's see an example of how to use a library. We're going to use the gravatar library to generate Gravatar URLs.

Create a file called main.ts and add the following code to it:

import { gravatar } from "https://deno.land/x/gravatar/mod.ts";

console.log(gravatar("example@example.com"));

This program imports the gravatar function from the gravatar library and calls it with the email address example@example.com.

You can run this program with the deno command:

deno run main.ts

You should see the output https://www.gravatar.com/avatar/00000000000000000000000000000000?d=mp&s=80.

Conclusion

You should now have a good understanding of Deno and be able to start writing your own programs. For more information, check out the Deno documentation.

Let me know in the comments if this was helpful or if you have any questions.

Be sure to follow me for more like this!

GraphQL is a query language for APIs that was developed by Facebook. It enables developers to request data in a more efficient way than traditional REST APIs. GraphQL is also more flexible, allowing developers to query for specific fields and data types.

GraphQL is slowly becoming the standard for API development, and more and more companies are adopting it. If you're not using GraphQL yet, now is the time to start.

What is GraphQL?

GraphQL is a query language for APIs that was developed by Facebook. It enables developers to request data in a more efficient way than traditional REST APIs. GraphQL is also more flexible, allowing developers to query for specific fields and data types.

GraphQL is slowly becoming the standard for API development, and more and more companies are adopting it. If you're not using GraphQL yet, now is the time to start.

How does GraphQL work?

GraphQL queries are made up of three parts: fields, types, and arguments.

Fields are the specific data that you're requesting. For example, if you're querying for a list of users, you might specify the fields "id", "name", and "email".

Types are the data types of the fields that you're requesting. GraphQL has a number of built-in types, such as "Int", "Float", "String", and "Boolean".

Arguments are used to filter the data that you're requesting. For example, you might use an argument to only query for users who have a certain "id" or "name".

Why should I use GraphQL?

There are a number of reasons to use GraphQL.

First, GraphQL is more efficient than traditional REST APIs. This is because you can specify exactly the data that you want, and you don't have to make multiple requests to different URLs to get the data that you need.

Second, GraphQL is more flexible. With REST APIs, you're limited to the data that's returned from the URL that you request. With GraphQL, you can specify exactly the fields and data types that you want.

Third, GraphQL is slowly becoming the standard for API development. more and more companies are adopting GraphQL, so it's a good idea to get ahead of the curve and start using it now.

Using GraphQL with Node.js

Now that we've seen what GraphQL is and how it works, let's take a look at how to use GraphQL with Node.js.

The first thing you'll need to do is install the "graphql" npm package.

npm install graphql

Next, you'll need to create a file called "schema.js" and define your GraphQL schema.

const {
  GraphQLObjectType,
  GraphQLString,
  GraphQLSchema
} = require('graphql');

const UserType = new GraphQLObjectType({
  name: 'User',
  fields: {
    id: { type: GraphQLString },
    name: { type: GraphQLString },
    email: { type: GraphQLString },
  }
});

const QueryType = new GraphQLObjectType({
  name: 'Query',
  fields: {
    user: {
      type: UserType,
      args: {
        id: { type: GraphQLString }
      },
      resolve: (root, args) => {
        return {
          id: args.id,
          name: 'User ' + args.id,
          email: args.id + '@example.com',
        };
      }
    }
  }
});

module.exports = new GraphQLSchema({
  query: QueryType
});

In this file, we've defined a GraphQL schema with a "User" type and a "Query" type. The "Query" type defines a "user" field, which accepts an "id" argument and returns a "User" type.

Next, we need to create a file called "index.js" and write some code to execute our GraphQL query.

const { graphql, buildSchema } = require('graphql');

const schema = require('./schema');

graphql(schema, '{ user(id: "1") { name, email } }').then((result) => {
  console.log(result);
});

In this file, we've imported the "graphql" and "buildSchema" functions from the "graphql" npm package. We've also imported our "schema" module.

Finally, we've used the "graphql" function to execute our GraphQL query. This function accepts our schema and a GraphQL query string. The query string defines the data that we want to fetch. In this case, we're fetching the "name" and "email" fields for the user with an "id" of "1".

If we run this file, we should see the following output:

{
  data: {
    user: {
      name: 'User 1',
      email: '1@example.com'
    }
  }
}

Conclusion

In this article, we've taken a look at what GraphQL is, how it works, and why you should be using it. We've also seen how to use GraphQL with Node.js.

If you're not using GraphQL yet, I highly encourage you to give it a try. It's a great way to make your API development more efficient and flexible.

Let me know if you found this article helpful in the comments or if you have any questions.

Be sure to follow me for more like this!

TypeScript was created to relieve some of the pain-points of JavaScript. Using TypeScript can help you avoid bugs you would otherwise encounter when writing regular JS. It is also Open Source, and has wide adoption and support.

This guide includes everything you need to get started with TypeScript, and nothing you don't.

What is TypeScript?

TypeScript is a programming language that is a typed superset of JavaScript. That means that it contains all of the functionality of JavaScript, but with additional features that make it more powerful and easier to use. TypeScript is compiled to plain JavaScript, so it can be used in any JavaScript environment.

Why Use TypeScript?

TypeScript is a great way to improve your code. It can catch errors and help you write more maintainable code.

TypeScript offers developers a number of benefits, including:

1. TypeScript provides static type checking. This can help you find bugs in your code more easily.

2. TypeScript code can be compiled to JavaScript code that runs on any browser or platform. The compiling process also allows developers to catch errors before runtime.

3. TypeScript comes with a number of tools that make it easy to work with, including an interactive shell and a compiler.

Getting Started

To get started with TypeScript, you will need to install it. The easiest way to do this is through npm.

Once you have TypeScript installed, you can compile TypeScript files using the tsc command. This will generate a corresponding JavaScript file.

tsc filename.ts

You can also use the -w flag to watch for changes and automatically recompile your files.

tsc -w filename.ts

Basic Types

TypeScript offers a number of basic types that you can use to annotate your variables.

let foo: string = "bar";
let baz: number = 42;
let qux: boolean = true;

You can also use the any type if you don't want to annotate your variables, though it's not recommended.

let foo: any = "bar";
let baz: any = 42;
let qux: any = true;

Interfaces

Interfaces are a powerful way to define contracts in your code. They can be used to define the shape of objects and functions.

interface Point {
  x: number;
  y: number;
}

let p: Point = { x: 0, y: 0 };

You can also use interfaces to define the types of function parameters and return values.

interface Point {
  x: number;
  y: number;
}

function addPoints(p1: Point, p2: Point): Point {
  return { x: p1.x + p2.x, y: p1.y + p2.y };
}

let p1: Point = { x: 0, y: 0 };
let p2: Point = { x: 1, y: 1 };

let p3: Point = addPoints(p1, p2);

Classes

Classes are a way to encapsulate data and behavior. They can be used to define types and create objects.

class Point {
  x: number;
  y: number;

  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }

  add(p: Point) {
    return new Point(this.x + p.x, this.y + p.y);
  }
}

let p1: Point = new Point(0, 0);
let p2: Point = new Point(1, 1);

let p3: Point = p1.add(p2);

Modules

Modules are a way to organize your code. They can be used to define types and encapsulate behavior.

module MyModule {
  export class Point {
    x: number;
    y: number;

    constructor(x: number, y: number) {
      this.x = x;
      this.y = y;
    }

    add(p: Point) {
      return new Point(this.x + p.x, this.y + p.y);
    }
  }
}

let p1: MyModule.Point = new MyModule.Point(0, 0);
let p2: MyModule.Point = new MyModule.Point(1, 1);

let p3: MyModule.Point = p1.add(p2);

Decorators

Decorators are a way to add metadata to your code. They can be used to annotate classes, properties, and methods.

@Component({
  selector: 'my-component',
  template: '<div>Hello, world!</div>'
})
class MyComponent {}

That's All, Folks!

That's all you need to know to get started with TypeScript. For more information, check out the TypeScript Handbook.

Let me know in the comments if this was helpful or if you have any questions.

Be sure to follow me for more like this!