Full-Screen Video Backgrounds in Web Design: Pros, Cons & Tips

There’s still a debate going on in the web design community on whether video backgrounds in websites are good or bad. However, we’ve seen a rise in websites utilizing fullscreen video backgrounds in the past few months than ever before. But is it really an effective strategy? Does it help engage with an audience? Does…

How the Muffin Live Builder Will Help You Build Better Sites, Faster

How the Muffin Live Builder Helps You Build Better Sites – SitePointSkip to main contentFree JavaScript Book!Write powerful, clean and maintainable JavaScript.RRP $11.95 This sponsored article was created by our content partner, BAW Media. Thank you for supporting the partners who make SitePoint possible.

Page builders have revolutionized the way we create websites today. But with so many options available for WordPress, it can take some time to find the best one for your web design projects and workflows.

With BeTheme’s new and improved page builder, your search may be over. 

The Muffin Live Builder tool gives web designers a more intuitive and faster way of building high-quality websites for clients. See for yourself:

[embedded content]
It has all the live editing features you’ll likely recognize from other page builders. However, this live builder has a number of standout features that will transform the way you work. 

Below, we’ll look at 5 of them.

Muffin Features That’ll Change the Way You Build Websites

At first glance, the Muffin Live Builder and its features may look like other WordPress page builders you’ve tried. But here’s how they differ:

1. It’s part of a fully-loaded website builder platform

One of the more frustrating parts about finding a WordPress page builder plugin you like is that you can’t get to the good features without upgrading. And if your client is already paying for a premium theme, they might be hesitant to splurge on an additional design and editing tool. There’s also the added complexity of having a theme and separate page builder to edit with.

With Betheme, however, there’s no need to buy and install a premium page builder or other plugins. It’s all included. 

A Betheme license includes: 

600+ pre-built professional-grade websites100+ mix-and-match pre-built section templates60+ customizable elementsMuffin BuilderLive BuilderPlugins like WooCommerce, Slider Revolution, Contact Form 7, and morePremium supportBetheme is the all-in-one solution for building high-quality WordPress websites. 

2. Pre-built sections you can use on any website

Betheme’s pre-built websites do a great job handling the majority of the design and content decisions you’ll have to make. 

Website structure. Page layouts. Image and text placement. After installation, it’s all there. 

However, every client has different needs. 

So, let’s say you’re building an online surf shop for one of your clients. Out of the box, Be Surfing is exactly what your client is looking for. However, the one thing it doesn’t have is a carousel on the homepage to promote recent blog posts.

When adding a new section in the Live Builder (in this case the carousel section for recent posts), you get a choice between creating it yourself or using a pre-built section: 

Pre-designed sections aren’t new to page builders. But with the Live Builder, you don’t have to spend time searching for a section that matches your pre-built site nor do you have to waste time stripping out existing designs or content.

There are over 100 pre-built sections you can choose from and they’re easy to find too, as they’re organized under categories like “List & Menus”, “Call to action”, and “Contact”. 

Because they more closely resemble wireframes than fully designed sections, you can easily repurpose these section templates for any type of website you build.

3. Well-organized toolbars make customizing sites a breeze

Even though most page builders come with a visual editor, the editing toolbars aren’t always that intuitive. Designers often have to comb through different tabs and menus to try and find the settings they need to configure. 

With Muffin’s live builder, you won’t need to do that. After you add a new element or select the existing one you want to edit, a custom toolbar appears on the left: 

All of the available settings for that element live right there in the toolbar. There’s no need to go digging around to figure out where the typography settings are or where you can make advanced CSS edits. It’s all in one place. 

It’s not just the editing toolbar that’s well-designed and organized. The admin toolbar is always available from the left side of the screen as well as the bottom of the editing toolbar:

The most commonly used admin actions live there: Save, Undo, Revisions, Responsive Mode, Return to WordPress, and so on.

The Live Builder is so easy to get around that you won’t waste any time searching for what you need or digging through layer after layer to take the desired action.

4. Autosave and backup tools are useful for version control

The Live Builder comes with a variety of “Save” tools beyond the standard Publish and Update. 

If you go to Revisions in the admin toolbar, you’ll find four different save features: 

Autosave makes a copy of the page every five minutesUpdates is where copies of the page get stored after you hit the “Update” buttonRevision allows you to save special versions of the pageBackup stores copies of the page just before you restore an older oneThis feature makes it so easy to capture copies of a page in progress. And, if you prefer, you can let the Live Builder manage those backups automatically for you.

That said, the Live Builder also gives you the power to create a clear history of all the major updates you make to a page (under “Revision”). This way, if you or your client ever change your minds about a recent update, a one-click restore will automatically take you back to the preferred version.

5. Lightweight editor for fast editing

It’s always frustrating when you open up WordPress, go to the page you’re working on, and then have to wait a minute or two for the page builder to load. 

It might not seem like a big deal, but multiply that by the number of pages you’re designing or editing, as well as the number of revisions you do to each, and that wait time adds up. 

The Muffin Live Builder is super lightweight, so you can avoid this frustration altogether.

The GIF you see here captures how quickly the Muffin page builder loads in real-time. For your reference, the clip is just 12 seconds long: 

According to Betheme developers, the Live Builder is now 60% faster than it was before. And when compared to other popular WordPress page builder plugins, there are no issues with the page builder getting “stuck” when you try to open it. 

It’s not just the speed of your page builder that should be concerned with either. 

Core Web Vitals is a useful tool for checking your website’s loading speeds (among other ranking factors). We compared how the Be Mechanic website was built with Elementor compared to the same website built with the Muffin Builder. 

Here’s what we found on the Elementor-built site: 

The largest contentful paint took 6.116 seconds to load. 

Compare that with the Muffin Builder-built site, which only took 1.232: 

Google knows that all it takes is three seconds before visitors start leaving a site in droves. So, having a lightweight page builder that speeds up your work and creates a speedier experience for your visitors is absolutely crucial.

Will You Be Building with the New Muffin Live Builder?

Between the intuitive design, convenient features, and fast loading, the Muffin visual page builder is a web designer’s best friend. Heck, it’s something your clients will love to use once they’re inside WordPress, too. And don’t forget about everything you get with it. The Muffin Live Builder is part of a powerful WordPress toolkit. With 600+ pre-built sites, 100+ pre-built sections, 60+ elements, and bundled premium plugins, you won’t need to look much further than Betheme to build the websites of your clients’ dreams.
Related Articles10 Top WordPress Ecommerce Themes for 2021WebBy

Virtual Environments in Python Made Easy

Python Virtualenv: Virtual Environments in Python Made Easy – SitePointSkip to main contentFree JavaScript Book!Write powerful, clean and maintainable JavaScript.RRP $11.95 Most Python newcomers don’t know how to set up a development environment that follows the latest standards used by professional programmers. This tutorial will teach you how to properly create a fully working Python development environment using industry-accepted best practices.
Virtual Environments
A virtual environment helps us to solve project dependency conflicts by creating isolated environments. These “isolated environments” contain all the goodies Python programmers might need to develop their projects.
Virtual environments include a fresh duplicate of Python binaries, and a standalone copy of the entire Python standard library. That’s why it can work by itself.
Using virtual environments give us the following advantages:
we’re able to maintain our local machine packages intact
we can share dependencies with others with a requirements.txt file
we can deploy a Python app in a dedicated server (PythonAnyWhere, Heroku, and so forth)
The Need for Virtual Environments
I use many libraries for my projects. Among them are three web application development frameworks, and there are other libraries I’d like to explore in future. This serves as the main argument that serious projects in Python depend on other packages written by other developers.
If you’re a Django developer, I’m confident you use Django rest framework to create powerful rest APIs, Django Debug Toolbar for gathering various debug information about the current request/response, Celery for taking care of real-time operations, and scheduling as well, and so on.
For example, I rely heavily on the requests package for some of my projects, and a Django web application I’m currently working on depends on version 2.3.0. According to the official documentation, at the time of writing the latest version of this package is version 3.2.
Let’s suppose I go ahead and install the latest version of the library on my Ubuntu machine because I need it for another project. Everything seems to work fine until I try to make use of my older project, which worked fine with 2.3.0. Suddenly, everything is broken.
What happened? Maybe the API of the latest version of Django has changed since version 2.3.0? The reason doesn’t matter at this point, as my older project is broken and no longer works.
A conflict between two projects has been created. They make use of the same library, but they require different versions of it.
Various packages solve this problem. Let’s see some that stand out.
Before Starting
In this tutorial, we’ll be using Python 3, so let’s start by checking your Python installation.
To do this, open up a terminal — cmd/PowerShell on Windows — and type the following command:
python –version

Python 3.9.5

Note: Most macOS and Linux systems have Python installed. You can check the Python installation guide if you’re using Windows.
If you didn’t get a result of the form Python 3.x there are two options:
if this command returned a Python 2.x version, you’ll need to use python3 along with this tutorial
if you got an Unknown command error, try to run python3, and if you get another error, follow the Python installation guide
You can proof the existence of the python3 binary by checking its version:
python3 –version

Python 3.9.5

Note: if the command above worked, you’ll need to run python3 instead of python.
Now that you know which Python command runs on your machine, let’s get into virtual environments.
Built-in venv Module
Let’s use the built-in Python venv module to create your first virtual environment.
Note: to use this module you need Python 3.3 or greater installed in your system.
To create a Python virtual environment with venv, type the following command:
python -m venv virt1

Note: the -m flag means Python is running the built-in venv module as a script.
This will create a virtual environment with the name of virt1, but this is just an argument. You can create the virtual environment with any name you want.
Everything installed in the virt1 directory won’t affect the global packages or system-wide installations, thus avoiding dependency conflicts.
Activating Virtual Environments
It’s crucial to know that each time we want to use a created virtual environment, we need to activate it with the following command:
source virt1/bin/activate

This won’t work in every system, so you can check the table below to have a clear idea of which command to use:
Platform
Shell
Command to activate virtual environment
POSIX
bash/zsh
$ source (venv-name)/bin/activate

fish
$ source (venv-name)/bin/activate.fish

csh/tcsh
$ source (venv-name)/bin/activate.csh

PowerShell Core
$ (venv-name)/bin/Activate.ps1
Windows
cmd.exe
C: > (venv-name)Scriptsactivate.bat

PowerShell
PS C: > (venv-name)ScriptsActivate.ps1
Note: the $ sign on POSIX and the C: >, PS C: > signs on Windows aren’t part of the command.
As you may notice, I’m using a bash shell in a POSIX (macOS and Linux), which is why I’m running the command above.
After the environment is created
Once the virtual environment gets activated, the terminal prompt changes a bit.

The following command lets you deactivate the virtual environment:
deactivate

Note how your terminal prompt has changed again.

Now activate your virtual environment again and use the which command to check the Python binary that’s being used:
source virt1/bin/activate
which python

If everything worked well, you should get something similar to the following output:
/home/daniel/tests/python-tests/venvs/virt1/bin/python

If you deactivate and which again, you should get a different output:
deactivate
/usr/bin/python

This is because, when working inside a virtual environment, the binary copy placed inside that environment is being used. The same applies to packages.
Pip with virtual environments
Although this isn’t a pip guide it’s important to show off the workflow between pip and virtual environments.
pip — whose name stands for “Pip Installs Packages” — is a package manager used to install and manage Python packages.
It’s extremely useful when you want to distribute your project to others, as it allows other developers — and end-users — to install all the dependencies of your project at a glance.
For example, a fellow developer can activate a virtual environment and then run the following command to install the dependencies of the project:
pip install -r requirements.txt

Here, requirements.txt is the file that contains all the project dependencies — the specific versions of packages.
To generate the dependencies file of your project, you can run the command below:
pip freeze > requirements.txt

If you want to install a specific version of a package, you can run pip install followed by the package name, double equal sign (==), and its version:
pip install package==version

In other situations, we can also uninstall a package from our machine (or virtual environment):
pip uninstall some-package-name

Virtualenv
Virtualenv is an external package used to create virtual environments. In reality, the Python built-in venv is a subset of it, so virtualenv has more features than the first option we saw. You can learn more about virtualenv advantages over venv in the official documentation.
For now, let’s install virtualenv with pip (make sure you’ve deactivated the previous venv) making use of the command below:
pip install virtualenv

This tool works similar to venv, so let’s test it out by creating another virtual environment:
virtualenv virt2

Note: make sure you deactivate the other environment before running the above command.
As with venv, we must activate the virtual environment before using it:
source virt2/bin/activate

If I now install the newest version of requests, it will be installed only on the virtual environment venv2:
pip install requests

The above command produces the following output:
Collecting requests

Installing collected packages: urllib3, idna, chardet, certifi, requests
Successfully installed certifi-2021.5.30 chardet-4.0.0 idna-2.10 requests-2.25.1 urllib3-1.26.5

If I run the pip freeze command, which prints a list of all my installed packages, I’ll get this:
certifi==2021.5.30
chardet==4.0.0
idna==2.10
requests==2.25.1
urllib3==1.26.5

As you can see, the only packages I get are the latest version of requests — at the time of writing — and its dependencies.
Other Virtualenv features
We can use the -p flag while working with virtualenv to use a specific version of Python that’s globally installed on the machine.
For example, the following command can be used to create the virtual environment virt2 with Python3 in it, if you have Python3 installed on your machine:
virtualenv -p /usr/bin/python3 virt2

And to delete a virtual environment, you use the rm -r command as you do with any other directory you want to delete:
rm -r virt2

You can learn more about advanced usage of the virtualenv CLI interface in the official documentation.
Virtualenvwrapper
Virtualenvwrapper provides very useful commands that make working with virtual environments even easier, by organizing all of them in a simple place.
As with virtualenv, It can be installed easily with pip.
pip install virtualenvwrapper

This will create a shell file virtualenvwrapper.sh located at your ~/.local/bin/ directory. This folder is used to store package binaries which let you to use Python packages directly from your terminal.
Before using virtualenvwrapper, you’ll need to edit your shell configuration file. Since I’m using a bash shell, I’ll append the following content to the .bashrc file, located in my home directory:
cat ~/.bashrc

export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python
export VIRTUALENVWRAPPER_VIRTUALENV=~/.local/bin/virtualenv
export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/Documents
source ~/.local/bin/virtualenvwrapper.sh
EOT

This will append — write at the end of the file — the above content to the .bashrc file. If the command above didn’t work, open the file and modify it manually.
The VIRTUALENVWRAPPER_PYTHON is pointing to the Python binary of your machine. You can check it with the following command (without any virtual environment activated):
which python

/usr/bin/python

Make sure to modify the .bashrc file according to your Python binary path.
Note: if you’re using Windows, you can use virtualenvwrapper-win.
Then, we reload the bash shell with the changes we made to the .bashrc file by running the following command:
source ~/.bashrc

Now, the mkvirtualenv command can be used to easily make new environments placed by default inside this folder:
mkvirtualenv sitepoint

You can see the sitepoint virtual environment folder by entering to the WORKON_HOME path, which we defined above as $HOME/.virtualenvs:
ls ~/.virtualenvs

sitepoint

To get a list of all the virtual environments created by virtualenvwrapper, you can run the workon command without arguments:
workon

sitepoint

We can easily activate the virtual environment with the help of the workon command:
workon sitepoint

The command to deactivate the virtual environment is the same as the one we used before:
deactivate

It’s very easy to switch between different virtual environments. For example, to workon another virtual environment:
workon another_virtualenv

To delete a virtual environment, the command rmvirtualenv should be used:
rmvirtualenv sitepoint

Conclusion
In this tutorial, you’ve learned about the essential workflow that every Python developer should master. Virtual environments are a crucial part of any collaborative Python project, and you can instantly improve your productivity by using them.
The tools are out there. Now it’s time to incorporate them into challenging personal projects. Do you use any other interesting approaches in your Python development workflow? Let us know in the Python forum!
Related ArticlesUsing Python to Parse Spreadsheet DataProgrammingBy

Color Tools And Resources

Today, we’re shining the spotlight on color tools and resources for all kinds of projects, from all types of color palettes and generators to getting contrast and gradients just right for your projects. This collection is by no means complete, but rather a selection of things that the team at Smashing found useful and hope…

Learn Markdown: Structure, Syntax, and Conventions

Learn Markdown: Structure, Syntax, and Conventions – SitePointSkip to main contentFree JavaScript Book!Write powerful, clean and maintainable JavaScript.RRP $11.95 Content on the Web needs to be presented in HTML format. Many web publishing tools (such as blogging software and CMSs) convert your content (text, images and so on) into HTML for you. But there are many situations where you want to write HTML content yourself … and marking up content with HTML tags manually is laborious and not really viable. Enter Markdown.
Markdown is an easy, frictionless way of writing content for the Web and the perfect way for developers to create documentation. It lets you structure and format documents easily using simple, text-based markup, which then gets converted into HTML for you — all from within your favorite text editor.
If you’re not already using Markdown, now might be the time to begin. You can learn the basics in minutes, and with ongoing use, the syntax will become second nature. In this article, we’ll encourage you to start simply and show you how to use Markdown for a range of common tasks when creating content.
Let’s dive in!
What Is Markdown?
Markdown is a lightweight markup language created by John Gruber in 2004. It’s easy to write, easy to read, and can be easily turned into HTML. It was primarily designed for writing for the Web.
It has rapidly grown in popularity and is now used in contexts never envisaged by its creator. But it’s not perfect. It has limits, especially as it leaves out formatting for a lot of HTML elements you might need to use (such as tables). It can also be a little ambiguous.
As a result, a range of variants has been created to deal with these problems:
CommonMark attempts to standardize Markdown and make it less ambiguous, contradicting some of the original syntaxes in the process.
GitHub Flavored Markdown (GFM) extends CommonMark and is used when creating documentation on GitHub.
MultiMarkdown added new syntax for tables, footnotes, citations, and more.
Pandoc extends Markdown for multiple output formats (not just HTML) and supports document metadata, footnotes, tables, superscript, subscript, and more.
Some web services and Markdown editors support the syntax of some of these variants or even use their own version of Markdown. Fortunately, they all support the original Markdown syntax, and that’s what we’ll focus on in this article.
Learning Markdown
The best way to learn Markdown is simply to start. Pick a use case and begin, whether that’s creating a blog post, working on documentation, or just adding some basic formatting to your notes. Pick up the syntax piece by piece as you need it.
You can use your favorite text editor, or choose one of the many apps designed to work with Markdown. Markdown editors can ease the learning process because they allow you to preview your formatting inline or in a separate pane. That means you can see at a glance whether or not you’re using the correct syntax.
Personally, I use Marked 2 to preview Markdown files on my Mac. It’s a commercial product, but of course you can find lots of free plugins for your editor of choice. You can also edit and preview Markdown files online using Markdown Live Preview and StackEdit.
For help choosing the right Markdown editor, refer to these roundup articles:
Structuring Documents
Markdown lets you add structural elements to your document, such as headings (h1, h2, h3 etc.). There are a few ways to add headings in Markdown . My favorite is to prefix a heading with hashes #, one for each level of heading:
# Heading 1

## Heading 2

### Heading 3

etc.

And this is body text.

The hashes move lower-level headings further to the right, so they appear indented. You can optionally use the same number of hashes at the end of the line to close the headers:
### Heading 3 ###

There’s a second way, though I don’t see it used as often. You can create two levels of headings by underlining the H1 headings with equals = symbols and H2 headings with hyphens -:
Heading 1 or Title
==================

Heading 2
———

Sections of a document can be separated using horizontal rules (), or lines. You create these in Markdown using three (or more) hyphens -, asterisks *, underscores _ or equals = signs. Place them alone on a line, with blank lines on either side:
Brief introduction.

===

# Chapter 1

Lots of text.

# Chapter 2

Some more text

Lists are another important structural element. Unordered lists () are created by beginning the line with an asterisk *, plus + symbol, or hyphen -, followed by a space or tab, then the text:
* this
* is
* an
* unordered
* list

+ this
+ is
+ too

– and
– so
– is
– this

Choose whichever symbol suits you. You can switch between these symbols and the end result will be the same. I tend to use asterisks or hyphens.
Ordered lists () are numbers followed by periods. The numbers don’t necessarily have to be in order. Either of these will work:
1. this
2. is
3. an
4. ordered
5. list

1. and
1. so
1. is
1. this

The Markdown editors I use automatically continue a list when pressing return.
If you want to start a line with a number and a period without starting a list, you need to escape the period with a backslash :
2020. A year we’ll never forget.

Finally, paragraphs of normal text are separated by one or more blank lines:
This will be formatted as an HTML paragraph.

And so will this.

Basic Text Formatting
Basic text formatting includes bold and italics. Underline doesn’t tend to be used on the Web, since it’s how hyperlinks are formatted, so it isn’t supported by Markdown. If you really want to use it, just use HTML tags. (This is worth noting more generally. Where Markdown doesn’t support a particular type of HTML element, you can just use the HTML markup instead. There’s just one caveat: any Markdown syntax inside HTML tags won’t get parsed.)
Words in italics are delimited by a single asterisk (*) or underscore (_):
this is *italics*
and so is _this_

Words in bold are delimited by a double asterisk (**) or underscore (__):
this is **bold**
and so is __this__

Some people prefer to choose either underscore or italics. For example, I normally use asterisks for both **bold** and *italics*.
Others prefer to differentiate bold and italics by using different symbols, like this: **bold** and _italics_:
_You **can** also combine them_

Blockquotes and Code Blocks
Blockquotes can be created by beginning a line with a greater than ( >) symbol, just like older email clients quoted previous messages:
> This is a blockquote. Single paragraphs
> can be continued like this on a second line.
>
> Multiple paragraphs can be quoted by using a
> line with a single greater than symbol.

My preferred way is a little simpler and only uses the greater than symbol at the beginning of each quoted paragraph. This works whether you use an editor that hard-wraps or soft-wraps paragraphs:
> You can also blockquote a paragraph
by placing a single greater than symbol at
the beginning of each paragraph.

> Nested blockquotes are also possible
> > Like this.

Code blocks are created by indenting every line by at least four spaces or one tab:
This is a normal paragraph:

This is a code block.

But other flavors of Markdown prefer to use backticks. For example, Ulysses uses two backticks at the beginning of a line for a code block:
“This is a code block.

GitHub flavored Markdown uses three backticks to begin and end the code block. Obsidian, Bear, and some other Markdown editors follow the same convention:
“`
This is a code block.
“`

To embed that code block in a code block, I wrapped it in quadruple backticks. On GitHub, you can optionally include the language if you want syntax highlighting:
“`ruby
This is Ruby code with syntax highlighting.
“`

Code can be displayed within a paragraph by using single backtick delimiters:
This code “ will be displayed, not interpreted.

Links and Images
Links and images use a combination of square brackets [] and parentheses (). For links, you surround the anchor text with square brackets, followed immediately by the URL in parentheses:
This is a [link to a web page](https://url.com).

If you like, you can add a title to a link. It will appear as a tooltip when you hover over the link. Enclose the title in quotes after the URL and inside the parentheses:
This is a [link to a web page](https://url.com “This title will appear as a tooltip”).

Another method for marking up links is known as reference linking. These look like footnotes in the Markdown document but will be converted to standard links when exported to HTML. The goal here is to make the Markdown document more readable.
Instead of linking directly to the URL, you use a label in square brackets. Then elsewhere in the document (typically at the bottom), you associate that label with a URL:
This is a [link to a web page][mylabel].

Then at the end of the document …

[mylabel]: https://url.com “Optional title”
or
[mylabel]: (Optional title)

Labels are not case sensitive and can consist of letters, numbers, spaces, and punctuation.
Images use a similar syntax but start with an exclamation mark (!):
![Alt text](https://imageurl.com)

If you like, you can add a title enclosed by quotes inside the parentheses.
![Alt text](https://imageurl.com “This is a title”)

You can also use reference links for images:
![Alt text][mylabel]

[mylabel]: https://imageurl.com “This is a title”

GitHub Flavored Markdown is used by many developers, and it provides additional syntax to make it more capable. Here are some examples.
Strikethrough is an additional text formatting option that’s achieved with double tildes (~~):
This is how you do ~~strikethrough~~.

Task lists can be created using – [ ] for unchecked items, and – [x] for checked items:
– [ ] This item is unchecked
– [x] This item is checked

You can create a table by using pipes and hyphens to draw the lines. Three or more hyphens — create the headers, and pipes | create columns:
| Heading 1 | Heading 2 | Heading 3 |
| ——— | ——— | ——— |
| some text | more here | and this |
| some more | this too | and this |

This looks better when the columns align, but it’s not necessary. Either way, the table will be created correctly when exporting to HTML:
| Heading 1 | Heading 2 | Heading 3 |
| ——— | ——— | ——— |
| some text | more here | and this |
| some more | this too | and this |

Creating a table like this gets quite tedious, especially if you need to edit the contents of the cells. Fortunately, there are online table generators that simplify the process.
Final Words
Markdown isn’t for everyone, but there’s a lot to like. Personally, I appreciate that it’s open, easy to learn, and doesn’t lock you into using a particular program.
If you’ve made it to the end of this article, it might be the right tool for you, too. Dive in and start using it. Learn the syntax piece by piece as you need it, and before you know it, it will become second nature.
Make sure you download our free printable Markdown cheat sheet. It covers core Markdown syntax, some extended syntax, tools for processing Markdown and other resources.
Related Articles10 Top WordPress Ecommerce Themes for 2021WebBy