Forem: Can Burak Sofyalioglu

Python Decorators: A Comprehensive Guide

Can Burak Sofyalioglu — Fri, 03 Jan 2025 07:55:37 +0000

When I started programming with Python, if I am not mistaken, the version was 3.3. Therefore, when I started programming, decorators had been available to the Python community for a long time.

Function decorators came to Python with version 2.2 and Class decorators came to Python with version 2.6.

Personally, I see Python's Decorator feature as a very powerful feature of the language.

Actually, my aim is to make a series of articles about the most difficult to understand topics in Python. I plan to cover these topics, which are a little more than ten, one by one.

In this article, I will try to touch on every part of the Decorators topic as much as I can.

1. Historical Context

Early Days (Pre-Python 2.2): Before decorators, modifying functions or classes often involved manual wrapping or monkey-patching, which was cumbersome and less readable.
Metaclasses (Python 2.2): Metaclasses provided a way to control class creation, offering some of the functionality that decorators would later provide, but they were complex for simple modifications.
PEP 318 (Python 2.4): Decorators were formally introduced in Python 2.4 through PEP 318. The proposal was inspired by annotations in Java and aimed to provide a cleaner, more declarative way to modify functions and methods.
Class Decorators (Python 2.6): Python 2.6 extended decorator support to classes, further enhancing their versatility.
Widespread Adoption: Decorators quickly became a popular feature, used extensively in frameworks like Flask and Django for routing, authentication, and more.

2. What are Decorators?

In essence, a decorator is a design pattern in Python that allows you to modify the behavior of a function or a class without changing its core structure. Decorators are a form of metaprogramming, where you're essentially writing code that manipulates other code.

You know Python resolve names using the scope given in order below:

Local
Enclosing
Global
Built-in

Decorators are sit Enclosing scope, which is closely related to the Closure concept.

Key Idea: A decorator takes a function as input, adds some functionality to it, and returns a modified function.

Analogy: Think of a decorator as a gift wrapper. You have a gift (the original function), and you wrap it with decorative paper (the decorator) to make it look nicer or add extra features (like a bow or a card). The gift inside remains the same, but its presentation or associated actions are enhanced.

A) Decorator Variations: Function-based vs. Class-based

Most decorators in Python are implemented using functions, but you can also create decorators using classes.
Function-based decorators are more common and simpler, while class-based decorators offer additional flexibility.

Function-based Basic Decorator Syntax

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Explanation:

my_decorator is the decorator function. It takes the function func to be decorated as input.
wrapper is an inner function that wraps the original function's call. It can execute code before and after the original function.
@my_decorator is the decorator syntax. It's equivalent to say_hello = my_decorator(say_hello).

Class-based Basic Decorator Syntax

These use classes instead of functions to define decorators.

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = self.func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result

@MyDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Explanation:

MyDecorator is a class that acts as a decorator.
The __init__ method stores the function to be decorated.
The __call__ method makes the class instance callable, allowing it to be used like a function.

B) Implementing a Simple Decorator

The fundamental concept of decorators is that they are functions that take another function as an argument and extend its behavior without explicitly modifying it.
Here's the simplest form:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# Using the decorator with @ syntax
@my_decorator
def say_hello():
    print("Hello!")

# When we call say_hello()
say_hello()

# This is equivalent to:
# say_hello = my_decorator(say_hello)

C) Implementing a Decorator with Arguments

Let's create a decorator that logs the execution time of a function:

def decorator_with_args(func):
    def wrapper(*args, **kwargs):    # Accept any number of arguments
        print(f"Arguments received: {args}, {kwargs}")
        return func(*args, **kwargs)  # Pass arguments to the original function
    return wrapper

@decorator_with_args
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice", greeting="Hi")  # Prints arguments then "Hi, Alice!"

D) Implementing a Parameterized Decorator

These are decorators that can accept their own parameters:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello {name}")
    return "Done"

greet("Bob")  # Prints "Hello Bob" three times

E) Implementing a Class Decorator

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self):
        print("Initializing database connection")

# Creating multiple instances actually returns the same instance
db1 = DatabaseConnection()  # Prints initialization
db2 = DatabaseConnection()  # No initialization printed
print(db1 is db2)  # True

F) Implementing Method Decorators

These are specifically designed for class methods:

def debug_method(func):
    def wrapper(self, *args, **kwargs):
        print(f"Calling method {func.__name__} of {self.__class__.__name__}")
        return func(self, *args, **kwargs)
    return wrapper

class MyClass:
    @debug_method
    def my_method(self, x, y):
        return x + y

obj = MyClass()
print(obj.my_method(5, 3))

G) Implementing Decorator Chaining

Multiple decorators can be applied to a single function:

def bold(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

def italic(func):
    def wrapper():
        return "<i>" + func() + "</i>"
    return wrapper

@bold
@italic
def greet():
    return "Hello!"

print(greet())  # Outputs: <b><i>Hello!</i></b>

Explanation:

Decorators are applied from bottom to top.
It is more like in what we do in math: f(g(x)).
italic is applied first, then bold.

H) What happens if we don't use @functools.wraps ?

The functools.wraps decorator, See docs, is a helper function that preserves the metadata of the original function (like its name, docstring, and signature) when you wrap it with a decorator. If you don't use it, you'll lose this important information.

Example:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        """Wrapper docstring"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """My function docstring"""
    pass

print(my_function.__name__)
print(my_function.__doc__)

Output:

wrapper
Wrapper docstring

Problem:

The original function's name (my_function) and docstring ("My function docstring") are lost.
This can make debugging and introspection difficult.

Solution: Use functools.wraps):

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        """Wrapper docstring"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """My function docstring"""
    pass

print(my_function.__name__)
print(my_function.__doc__)

Output:

my_function
My function docstring

Benefits of `functools.wraps`:

Preserves function metadata.
Improves code readability and maintainability.
Makes debugging easier.
Helps with introspection tools and documentation generators.

I) Decorators with State

Decorators can also maintain state between function calls. This is particularly useful for scenarios like caching or counting function calls.

python
def count_calls(func):
    def wrapper(*args, **kwargs):
        wrapper.calls += 1
        print(f"Call {wrapper.calls} of {func.__name__}")
        return func(*args, **kwargs)
    wrapper.calls = 0
    return wrapper

@count_calls
def say_hello():
    print("Hello!")

say_hello()  # Call 1 of say_hello
say_hello()  # Call 2 of say_hello

Output:

Call 1 of say_hello
Hello!
Call 2 of say_hello
Hello!

Explanation:

The wrapper function maintains a counter (calls) that increments each time the decorated function is called.
This is a simple example of how decorators can be used to maintain state.

J) Best Practices for Python Decorators

Use functools.wraps: Always use @functools.wraps in your decorators to preserve the original function's metadata.
Keep Decorators Simple: Decorators should ideally do one specific thing and do it well. This makes them more reusable and easier to understand.
Document Your Decorators: Explain what your decorator does, what arguments it takes, and what it returns.
Test Your Decorators: Write unit tests to ensure your decorators work as expected in various scenarios.
Consider the Order of Chaining: Be mindful of the order when chaining multiple decorators, as it affects the execution flow.

K) Bad Implementations (Anti-Patterns)

Overly Complex Decorators: Avoid creating decorators that are too complex or try to do too many things. This makes them hard to understand, maintain, and debug.
Ignoring functools.wraps: Forgetting to use @functools.wraps leads to loss of function metadata, which can cause issues with introspection and debugging.
Side Effects: Decorators should ideally not have unintended side effects outside of modifying the decorated function.
Hardcoding Values: Avoid hardcoding values within decorators. Instead, use decorator factories to make them configurable.
Not Handling Arguments Properly: Ensure your wrapper function can handle any number of positional and keyword arguments using *args and **kwargs if the decorator is meant to be used with a variety of functions.

L) 10. Real-World Use Cases

Logging: Recording function calls, arguments, and return values for debugging or auditing.
Timing: Measuring the execution time of functions for performance analysis.
Caching: Storing the results of expensive function calls to avoid redundant computations (memoization).
Authentication and Authorization: Verifying user credentials or permissions before executing a function.
Input Validation: Checking if the arguments passed to a function meet certain criteria.
Rate Limiting: Controlling the number of times a function can be called within a specific time period.
Retry Logic: Automatically retrying a function call if it fails due to a temporary error.
Framework-Specific Tasks: Frameworks like Flask and Django use decorators for routing (mapping URLs to functions), registering plugins, and more.

M) Curated Lists of Python Decorators

You can find a curated lists of Python decorators below:

N) 11. Conclusion

Decorators are a powerful and elegant feature in Python that allows you to enhance functions and classes in a clean and declarative way.
By understanding the principles, best practices, and potential pitfalls, you can effectively leverage decorators to write more modular, maintainable, and expressive code.
They are a valuable tool in any Python programmer's arsenal, especially when working with frameworks or building reusable components.

A Beginner's Guide to Structure SEO-friendly URLs

Can Burak Sofyalioglu — Thu, 28 Dec 2023 13:05:38 +0000

A Beginner's Guide to Structure Blog Post URLs

Before sharing your first blog post, one of the things you should definitely pay attention to is how your blog posts and their URLs should be organized. I will talk about how you should structure your blog posts URLs, best practices and the things you should avoid.

Please do not skip this article if your intent is ranking on search engines. I have learned these lessons in a hard way. I wasted a great deal of time to fix my mistakes.

Therefore, I definitely recommend reading this article before writing your first blog post.

A Beginner’s Guide for an SEO-Friendly URL Structure

Let's get started with the essential questions that clarify the importance of having a proper URL structure.

What happens when you don't have a proper URL structure?

If you don't follow the practices here, it may be possible for Google to index a page differently than you thought. (We’ll discuss that later)

You link to another article in one of your posts. Later, you realize the link targets a URL other than Google has indexed.

If rankings on search engines are your concern, you should either change the link’s address to the address of what Google indexed or manually remove that page from Google search results. If you are dealing with many pages, such as an e-commerce website, it would take you many hours to fix that.

You can watch the official answer of Google that mentions the potential adverse effects when you change your URL structure later on.

An Analogy to Understand a URL and a Domain Name

Maybe an analogy explains better what a URL and a domain name are.

URL is the abbreviation of Uniform Resource Locator (URL), colloquially known as a web page’s unique address.

A URL has different parts, such as protocol, domain, TLD, subdirectory, slug, and URL parameters.

The part after the TLD (Top Level Domain) is customizable by you (if you are the registrant of that domain) and the main topic of this article is how you should customize that.

Almost all of us have mobile phones. A mobile phone has a unique phone number similar to a website’s URL. It is difficult to remember phone numbers; thus, we save a phone number with a proper name, such as whose it belongs. After, when we try to call a friend in the contact list, the mobile device calls the number of that friend.

This is similar to a website such as the one you are reading. A website's actual address consists of several numbers that we call IP numbers. IP numbers are also difficult to remember, like mobile phone numbers.

Wouldn’t it be nice if we could save those IP numbers with a proper name?

Yes, and we are doing that. Browsers do that for us in the background.

The main difference between those two situations is to whom those records are available and accessible.

A contact with a name and a phone number exists only on the registered device.

On the other hand, when you buy (!) a domain name, you actually rent it for a limited time. More specifically, you become the domain holder and have the right to which IP address that domain name should point out.

Moreover, the record that holds the domain name and the IP number it points out is globally available.

How browsers know the IP number of any domain is the topic of public DNS (Domain Name System) resolver and it is out of the scope of this article.

Part I: Make A Blog URL structure as SEO-friendly

The first thing to understand is the ideal pattern for a blog post URL.

Which URL structure is Better: Flat or Hierarchical?

At a higher level, you have two options to structure your blog post URLs:

Flat URL structure
Hierarchical URL structure (Top-down or Pyramid)

According to an official answer from Google, using a hierarchical URL rather than a flat one seems more beneficial.

What are the Benefits of Using a Hierarchical URL structure

It helps you to keep semantically related content together. By doing that, you signal a message to the crawlers. This helps search engines understand the context of the post better.

Moreover, separating blog posts according to their categories allows you to create different content silos for different topics. Even free blogging platforms support that feature.

But what that means? Let me explain.

What is a Content Silo?

A content silo is a method of grouping related content together on your website to establish the site's keyword-based topical areas or themes. Think of it as organizing your website into different sections or "silos," each dedicated to a specific topic.

This structure helps search engines understand the themes of your site, and it also enhances user experience by making navigation easier.

In other words, content silos may play a role in being an authority on different topics.

Another question is coming.

What does being an authority on a topic means?

One of the four pillars of search engine optimization (E-E-A-T) is being an authority (A) on the topic you want to rank for. It means more than just knowledge. People with authority on a specific topic are trusted and influential people on that topic. They consistently provide value to others through their expertise.

This concept is also known as topical authority.

What does topical authority mean?

The term refers to the level of expertise or credibility a website or content creator has on a specific subject matter. It's like being the go-to source for information on that particular topic. The concept is rooted in the idea that search engines, like Google, favor sites that provide comprehensive and reliable information on specific topics.

By consistently grouping related content under specific category slugs, you're showing search engines that you have multiple pieces of content revolving around this topic. This can help to establish your site as an authoritative source on that subject.

If you need a deeper knowledge about that, I can suggest you to read these two articles:

Considering the benefits I mentioned above, I can say that using a hierarchical URL structure is better.

This means you should categorize your blog posts and insert the category’s slug between a post slug and the domain, separated by a slash.

Preventing Duplicate Content

However, if you are using the URL structure that follows /category/post-slug, it is possible that you will have duplicate content issues. Let me clarify.

It is not a rare scenario for a post with multiple categories.

This causes content duplication.

To prevent this, you must use the canonical address method.

For a given post with multiple categories, you choose one of them as the canonical address and use that one in all versions of that post. By doing that, you tell Google to index only the canonical address and ignore others.

Now, we can proceed to the next part.

Part II: Making Blog Post URLs as SEO-friendly

Keyword research is the first step in search engine optimization. However, it is not the scope of this article.

For the sake of the continuity of this article, I’ll assume that you did keyword research and decided to rank one of those keywords from the research.

So, we have a keyword that we want to rank for.

Before proceeding, I must mention one very important term: slug.

What is a slug?

Slug is a part of the URL and makes a page distinct from another. The human-readable and URL-normalized version of the given text can be a category name or a post title. The blogging platform you choose generally automates this text process but can be changed manually.

For instance, in www.example.com/books/fiction, the slug, 'books/fiction', is composed of the slugified version of category and the product names.

This is the most important part of structuring your blog post URLs, and it must be applied to both the category and the post part of a URL.

We have already decided which keyword we want to rank for.

One of the best practices for search engine optimization is using the keyword in the URL. But why?

Does using keywords in URLs Affect Rankings?

Yes, using keywords in URLs is a ranking factor. On the other hand, according to Google Search Advocate John Mueller, it has a very lightweight effect.

This means we will mention the keyword in the slug.

In general, the post slug is auto-generated by your blogging platform. If it is auto-generated, you’ll see that the slug of the post is based on the title of the post. It is a common practice also.

The more important part is how you customize that slug, either based on the title or not.

The Best Practices for Structuring Blog Post URLs

When structuring the URLs of your blog posts for optimal performance in search engine optimization (SEO), it is important to follow a set of best practices that make your URLs more readable and relevant to both users and search engines.

To apply these practices, your blogging platform must support a category and tag system. Otherwise, you can check the blogging platforms that support the category system.

Here are some guidelines to structure your blog post URLs effectively:

Use Descriptive Keywords: Incorporate the primary keyword related to your blog post into the URL to explain what the post is about. This helps with SEO and gives users an idea of what to expect before they click the link.
Keep it Simple and Specific: Aim to keep your URL structure simple, short, and precise. Although the URL length does not affect rankings, it would be nice to avoid long and complex URLs. By following this practice, you can focus on the most important keywords that capture the essence of your blog post.
Use Hyphens to Separate Words: Even though it doesn't affect rankings which one do you prefer, to enhance readability, use hyphens rather than underscores to separate words within your URL. You
Avoid Unnecessary Words: Trim stop words like "and," "or," "but," "the," etc., as they add unnecessary length and don't contribute much to search engine understanding.
Utilize Lowercase Letters: URLs are case-sensitive by definition. Although it is possible to use all upper case, all lowercase, or maybe mixed case, it's a standard practice to use all lowercase letters in URLs to avoid confusion. Google says its crawler can handle those variations, but it needs to be figured out first. Therefore, please follow all lowercase practice.
Omit Special Characters: Special characters and symbols can make URLs look cluttered and can cause issues with some browsers and servers. Use letters without the diacritical version. Stick to letters and numbers only if that number makes sense where possible.
Exclude Dates and Numbers: Unless they're integral to the content, avoid including dates and excessive numbers, which can make your URL unnecessarily long and less evergreen.
Avoid Keyword Repetition: Don't overuse keywords in the URL as this can look spammy and may not be beneficial for SEO.

The image above shows an example slug of a post with a title "What types of Kyber Crystals Exists?" located under "Star Wars" category.

You can also read the official guideline: URL structure best practices for Google

By adhering to these practices, your blog post URLs will be well-optimized for search engines, contributing to a better user experience and potentially improving the visibility and ranking of your content in search results.

How to Generate Income from Your Blog

Can Burak Sofyalioglu — Mon, 01 May 2023 22:10:37 +0000

In this article, I shared my findings and personal experiences about generating income with your blog from a general perspective. I mentioned different monetization strategies and different useful tools that make your blogging journey easier.

Suppose you have no idea how to generate revenue from your blog. In that case, this article gives you a general understanding of monetization methods which are also independent of the type of blog.

If you have decided which platforms to use for your publishing, it is time to create remarkable content and generate revenue.

If you didn't decide on the blogging platform, I suggest you check these options: Best Blog Building Sites

Part 1: Quality Content Creation

The value you realize from your published content depends on several variables, the most important of which is blog traffic. The more traffic your blog receives, the more value you realize. Consider it like having a billboard on a busy street.

It can be said that it will be a billboard in the desert when you publish your first post. Therefore, it is vital to promote your content through Twitter, Facebook groups, Reddit, Medium etc.

But… Even though promoting your content through social media is a necessary condition, it is not a sufficient one.

The most critical factor that determines your income is providing good value to your audiences. In the year 2023, content is still king.

In the long run, quality always beats quantity, and blogging is a long-run process.

But…

What does quality content mean?

Valuable, or quality content, is content that provides significant benefits to readers by addressing their needs, solving their problems, answering their questions, or entertaining them in a meaningful way.

Creating valuable content should be a priority for bloggers and content creators, as it helps build trust, credibility, and loyalty among readers, leading to increased engagement, social shares, and return visits.

It is a fact that all of these returns will eventually comprise your income.

To provide valuable content to your readers, consider the following tips:

Understand your audience

Research and identify your target audience's needs, preferences, and pain points

Create reader personas to help you better understand and address their needs through your content.

Contrary to average practice, Prioritize creating high-quality, well-researched, and in-depth content rather than churning out a large volume of superficial articles.

Although this strategy consumes more time, it will put you in front of thousands of bloggers in the long-run. This may grow the size of your loyal readers.

One of the best ways to understand your audience is by creating user personas.

What is a user persona?

A persona is a fictional representation of your ideal customers. They give a clue about how they look, what they need, and what they want.
A user persona is a combination of all the characteristics your audiences would possess.

For instance, you can clone this Notion template to see a very basic representation of a simple user persona.

In different words, It helps you to create empathy for the real people and help you to put yourself in the shoes of your readers.

You can use Answer The Public to know which questions your audience asks.

Be informative and educational and create easily consumable content

Sharing your knowledge and expertise in your niche topic is not an easy task. It can be improved with lots of practice.

Moreover, providing insights, tips, and actionable advice that helps your readers solve problems or improve their lives is the key point of a successful blog.

Use short paragraphs and concise sentences to make your content more readable and scannable. Include visuals such as images, infographics, and videos to break up text and enhance your content's appeal.

Offer step-by-step guides, tutorials, or case studies to illustrate your points.

Google Trends and Exploding Topics are useful for trendy topics. Analyze the competition of your keywords and their monthly search volume.

Research Rabbit is another useful tool for research papers if your niche is an academic topic.

You may also find useful browser extensions to create step-by-step guides like Tango

Be original, authentic and create novel content

Create unique content that showcases your voice, perspective, and experiences. Avoiding grammatical errors is also critical for your users. Avoid rehashing or duplicating content found elsewhere.

Share personal stories and anecdotes to connect with your readers and make your content relatable.

If you are not a native English writer, using tools like LanguageTool could help a lot.

Promote your content through social media and optimize it for search engines

Hyperlinks are great. It navigates your audiences to where you want. Share a tweet and navigate your users to your money page.

Implementing search engine optimization best practices is crucial for successful bloggers. Organic search traffic is the most significant source of traffic for most blogs.

It brings users without marketing such as keyword research, proper use of title tags and meta descriptions, and internal and external linking, to make your content more discoverable and accessible to potential readers.

Google Ads has a very useful tool called Keywords Planner. Extensively use it for your keyword research.
Buffer like tools allow you to publish your work to multiple channels.

If you are interested, you may check the list of content creation tools

Part 2: Generating Revenue

What are the ways of earning from your blog?

Ads
Affiliations
Subscriptions

Income from Ads

Ad revenue depends on site traffic, and site traffic depends on making the blog visible. Numerous platforms are eager to show ads on your blog site if your site has a considerable amount of traffic. In other words, at the very beginning of your blogging days, it is difficult to be accepted as a publisher on those ad platforms.

Even though you get income for impressions, the real income comes with user interactions for ads you show. In other words, you mostly earn by the number of clicks your ads get.

The income by click depends on many factors such as purchasing power, a product that appears in ads etc… It is reasonable to get more when you show an ad to a U.S. citizen rather than a citizen of a country where its citizens have much lower income.

Here, the most popular ad platforms you can apply with your blog:

Affiliate Income

What is affiliate marketing?

One of the most used ways to get income from your content is affiliations. Basically, you review some products and link to those products.

The links have special fragments which detect new coming users that are acquired from your platform.

In this way, honest reviews will be rewarded as growing audiences. Growing audiences increase your visibility and so your income.

YouTube video reviews and other product reviews are examples of affiliation type of income. Those video links generally include Amazon affiliate links.

In this type of income, in other words, partnership, the affiliate (you) earns a commission for generating sales, leads, or other desired actions for the merchant through their unique referral link.

Let me draw a sample process for an affiliate marketing process.

How does affiliate marketing work?

Affiliates sign up for an affiliate program: Affiliates join an affiliate network or an individual company's affiliate program that offers products or services relevant to their niche.
Affiliates receive unique referral links: Once they've joined the program, affiliates receive unique referral links, which they can use to promote the merchant's products or services on their websites, blogs, social media platforms, or email campaigns.
Affiliates promote the products or services: Affiliates create content, such as blog posts, reviews, tutorials, or social media posts, to promote the merchant's products or services using their referral links.
Customers click on the referral links: When potential customers click on an affiliate's referral link and make a purchase or complete another desired action (e.g., signing up for a newsletter), the transaction is tracked and attributed to the affiliate.
Affiliates earn a commission: Based on the agreed-upon commission structure, affiliates earn a percentage of the sale or a fixed amount for each lead or action generated through their referral links.

Affiliate marketing benefits both the merchant and the affiliate. Merchants gain access to a wider audience and only pay for results, while affiliates can generate passive income by promoting products or services they believe in.

The most popular affiliate marketing program, affiliation platform, and curated lists are as follows:

Income from Subscriptions

We are living in a micro-creators era. If you believe that you have novel things to share, then subscription-based income would be a suitable option.

When you specialize in your niche, you'll have a laser-targeted audience. This not only allows you to earn by subscriptions, but also with targeted ads.

Furthermore, if you are writing on a profitable niche, then it means you'll have predictable income streams which is a must for full-time blogging.

Putting your content behind a paywall is getting more popular in these days.

Moreover, there are platforms to provide you with all the things you need, and they just cut a small portion of your monthly subscription income.

If you are planning to earn by this way, the content you create would generally be blog posts or email newsletters.

The most popular platforms to earn income by paywall are:

When you charge your audience with a relatively low price, it would be important to treat them well and provide them with unique and valuable content.

As a bonus, here is another tool to add a membership feature to your blog.

As I said before, generating revenue is a long-run process. It is better to improve it iteratively.

Typically, it is unclear that which action causes what due to the nature of abundance of factors. Thus, the iterative process makes you aware of your decisions.

Exploring SolidJS - The Reactive Primitives (1)

Can Burak Sofyalioglu — Wed, 06 Oct 2021 15:14:37 +0000

SolidJS is a true reactive library that allows you to use JSX for your frontend projects. In this blog post, I'll share my first impressions on the SolidJS UI library and its reactive primitives. The original article can be found here: "Introduction to SolidJS"

I like the concept of reactivity when building frontend projects. Despite its name, React is not a truly reactive library. I also like the Svelte because of its reactivity. I previously wrote a tutorial about Django and Svelte. However, I realized that writing projects with Svelte are not so scalable like React projects because React and JSX provide great modularity.

However, SolidJS offers the best of both worlds.

Shameless promotion

I'm currently not planning to do a real project with SolidJS until I become fluent in it. Currently, I'm building an e-commerce store, İzmir Güvenlik Kamerası (Security Camera Systems) and Fine Art Print Store, and I would work with SolidJS for small projects. You can also check the list of blogging sites

Introduction

OK, let's dive into the topic. Before reviewing SolidJS, it is better to get familiar with the concepts. I'll shortly talk about What are reactive systems? and what are those reactive primitives?.

What are reactive systems?

According to The Reactive Manifesto, reactive systems are responsive, resilient, elastic, and message-driven. We call these Reactive Systems.

Systems built as Reactive Systems are more flexible, loosely coupled, and scalable. This makes them easier to develop and amenable to change.

They are significantly more tolerant of failure, and when failure does occur they meet it with elegance rather than a disaster.

What Reactive Systems do

There are numerous reactive libraries in many programming languages like SolidJS in JS.

Reactive systems must react to data changes. Generally, these changes occur when new data is received or the old one is updated.

Characteristics of Reactive Programming

The reactive manifesto defines the key characteristics of it, like that:

Responsive: Those systems respond on time. Here, of course, timely will differ depending upon the application and domain.
Resilient. Reactive systems stay responsive in the face of failure.
Elastic. As the workload grows, the system should continue to be responsive.
Message Driven. Information is exchanged between elements of a reactive system using messages. This ensures loose coupling, isolation, and location transparency between these components.

What are the reactive primitives of SolidJS?

In SolidJS, the author of the library Ryan Carniato defines them as much like network primitives rather than JavaScript's primitives. As you will see later, Signals are basically observables.

Installation of SolidJS Template

You can easily install a starter SolidJS template with degit. You can also check other official templates from here: SolidJS Official Templates. I prefer a JS template rather than a TypeScript.

# Javascript template
npx degit solidjs/templates/js solid
cd solid

# install the dependencies
yarn install

The template uses Vite as a development tool. Also, this is the first time I have used Vite. Vite is so super fast that I had to check twice that if it reloaded the rendered page. When the installation is done, the project directory looks like that:

It is very similar to React in many cases. I will check some component rendering processes'.

In this post, I am going to explore SolidJS in an introductory manner. I'll also create a Counter component first and check its re-render process.

A Reactive JavaScript Library: SolidJS

A) Reactive primitives: createSignal

SolidJS has some basic reactive primitives, and Signals are one of them. It looks like it is a "useState" alternative of React Hooks. One difference to the "useState" hook is that a Signal returns two functions: a getter and a setter. Here is the official example of creating a signal:

createSignal function takes an initial value and returns an array with an access and update function.
You should execute the getter function (access) in order to get the value.
You can pass function to update function (set function). In this function, you can access the previous state also.

const [getValue, setValue] = createSignal(initialValue);

// read value
getValue();

// set value
setValue(nextValue);

// set value with a function setter
setValue((prev) => prev + next);

import { createSignal } from "solid-js";

function Counter({ initial }) {
    const [count, setCount] = createSignal(initial || 0);

    return (
        <div>
        {/* Notice the usage of count! It is a function*/}
            <h2>Count: {count()}</h2>
        </div>
    );
}

1) Component State Access and Update

SolidJS call the state elements as signals. However, I prefer to use state rather than signal. Let's make a Counter component within the App component. Fill the App.jsx file as follows:

import logo from "./logo.svg";
import styles from "./App.module.css";
import { createSignal } from "solid-js";

function App() {
    /**
     * CHECKPOINT
     * if the App component renders
     * it will print to console
     */
    //
    console.log("App component rendered.");

    return (
        <div class={styles.App}>
            <header class={styles.header}>
                <img src={logo} class={styles.logo} alt="logo" />
                <p>
                    Edit <code>src/App.jsx</code> and save to reload.
                </p>
                <a
                    class={styles.link}
                    href="https://github.com/solidjs/solid"
                    target="_blank"
                    rel="noopener noreferrer"
                >
                    Learn Solid
                </a>
                <Counter />
            </header>
        </div>
    );
}

function Counter({ initial }) {
    const [count, setCount] = createSignal(initial || 0);

    /**
     * CHECKPOINT
     * if the Counter component renders. it will print to console.
     * Also, I put another print statement for the count function.
     */
    //
    console.log("Counter component rendered.");
    console.log("Counter component count value: ", count());

    return (
        <div style={{ width: "100%", height: "auto" }}>
            {/* Notice the usage of count! It is a function*/}
            <h2>Count: {count()}</h2>
            <button onClick={() => setCount((c) => c + 1)}>Increase</button>
            <button onClick={() => setCount((c) => c - 1)}>Decrease</button>
        </div>
    );
}

export default App;

Let's check the browser and the first render of SolidJS. As you see, there is no extra component render. If it were React, we should have seen many times "Counter component rendered" text on the console.

2) Parent Component State Access and Update

Let's make it further and pass the signal setter to the child component and use it from there. Change both App and Counter components like that:

function App() {
    /**
     * CHECKPOINT
     * if the App component renders
     * it will print to console
     */
    //
    const [appCount, setAppCount] = createSignal(0);
    console.log("App: count: ", appCount());
    console.log("App component rendered.");

    return (
        <div class={styles.App}>
            <header class={styles.header}>
                <img src={logo} class={styles.logo} alt="logo" />
                <p>
                    Edit <code>src/App.jsx</code> and save to reload.
                </p>
                <a
                    class={styles.link}
                    href="https://github.com/solidjs/solid"
                    target="_blank"
                    rel="noopener noreferrer"
                >
                    Learn Solid
                </a>

                {/* NEW */}
                <h2>App Count: {appCount()}</h2>

                <Counter
                    initial={appCount()}
                    setAppCount={setAppCount} // NEW
                />
            </header>
        </div>
    );
}
function Counter({ initial, setAppCount }) {
    const [count, setCount] = createSignal(initial || 0);

    /**
     * CHECKPOINT
     * if the Counter component renders. it will print to console.
     * Also, I put another print statement for the count function.
     */
    //
    console.log("Counter component rendered.");
    console.log("Counter component count value: ", count());

    return (
        <div style={{ width: "100%", height: "auto" }}>

            {/* Notice the usage of count! It is a function*/}
            <h2>Count: {count()}</h2>
            <button onClick={() => setCount((c) => c + 1)}>Increase</button>
            <button onClick={() => setCount((c) => c - 1)}>Decrease</button>
            <hr />

            {/* Buttons changes the signal value of its parent component */}
            <button onClick={() => setAppCount((c) => c + 1)}>
                AppCount Increase
            </button>
            <button onClick={() => setAppCount((c) => c - 1)}>
                AppCount Decrease
            </button>
        </div>
    );
}

As you can see, there is not any component re-rendering. It's awesome.🥳

B) Reactive primitives: createEffect

As you might expect, createEffect is the equivalent of the useEffect hook in React. The official explanation and example are as follows:

Creates a new computation that automatically tracks dependencies and runs after each render where a dependency has changed. Ideal for using refs and managing other side effects.

const [a, setA] = createSignal(initialValue);

// effect that depends on signal `a`
createEffect(() => doSideEffect(a()));

It's time to play with this function. The official example returns a function (doSideEffect) that takes state value as its argument. Even if the returning function doesn't take the state value as its argument but as an inner value, the createEffect function successfully makes a side-effect.

Let's add those to the App component.

    // The function creates side-effect
    const changeTitle = (val) => (window.document.title = `#App: ${val}`);

    // effect that depends on signal `a`
    createEffect(() => changeTitle(appCount()));

We created a function (changeTitle) responsible for the side-effect. It takes a value and changes the document title according to that. It also takes the state value of the App component which is appCount. Your app component should look like this.

function App() {
    const [appCount, setAppCount] = createSignal(0);
    console.log("App: count: ", appCount());
    console.log("App component rendered.");

    // The function creates side-effect
    const changeTitle = (val) => (window.document.title = `#App: ${val}`);

    // effect that depends on signal `a`
    createEffect(() => changeTitle(appCount()));

    return (
        <div class={styles.App}>
            <header class={styles.header}>
                <img src={logo} class={styles.logo} alt="logo" />
                <p>
                    Edit <code>src/App.jsx</code> and save to reload.
                </p>
                <a
                    class={styles.link}
                    href="https://github.com/solidjs/solid"
                    target="_blank"
                    rel="noopener noreferrer"
                >
                    Learn Solid
                </a>

                {/* NEW */}
                <h2>App Count: {appCount()}</h2>

                <Counter
                    initial={appCount()}
                    setAppCount={setAppCount} // NEW
                />
            </header>
        </div>
    );
}

You'll easily differentiate that when the app renders the first time, the document title was App: 0

After, when I clicked and increased the appCount value, the document title also changed to the corresponding value. You'll also notice that there will be no component re-render.

C) Reactive primitives: createMemo

This reactive primitive returns a function that returns a read-only derived signal. Its value is recalculated whenever dependencies are updated. createMemo primitive is the equivalent of useMemo hook.

Edt the App component according to those:

    // Add those to the App component
    // It recalculate the value whenever the dependencies are updates.
    const makeDouble = (val) => val * 2
    const doubleCount = createMemo(() => makeDouble(appCount()))
    console.log("doubleCount ", doubleCount());

Also, update the content of the App component. By doing this, we can see the doubleCount signal in work. You can also check the code location from the image below.

<h2>Double Count: {doubleCount()}</h2>

D) Reactive primitives: createResource

This function creates a signal that is responsible for async requests. The official explanation and example are here:

Creates a signal that can manage async requests. The fetcher is an async function that accepts the return value of the source if provided, and returns a Promise whose resolved value is set in the resource. The fetcher is not reactive, so use the optional first argument if you want it to run more than once. If the source resolves to false, null, or undefined will not fetch. Also, loading and error are reactive getters and can be tracked.

const [data, { mutate, refetch }] = createResource(getQuery, fetchData);

// read value
data();

// check if loading
data.loading;

// check if errored
data.error;

// directly set value without creating promise
mutate(optimisticValue);

// refetch last request just because
refetch();

My first impressions of SolidJS are amazing. Up to this point, there is no overhead that you always face with React. I will be watching the development of SolidJS with interest.

Awesome Content Creation Tools

Can Burak Sofyalioglu — Sun, 19 Sep 2021 19:00:13 +0000

(Note: This post was updated on 15 December 2021)

Creating quality content is a demanding and complex process. It is better to have a wide range of applications in your toolbox. Even though there is no one solution to fix it all, one can increase your productivity and save you time. Considering this, I will share my favorite content creation tools. These are both written content and visual content.

You can also check the original post for updated resources: Content creation tools

Great Content Creation Tools

Using the appropriate tools can make content creation so much easier and more successful. After the introduction, it is time to share the useful content marketers tools. I hope those tools will make you more productive during your content creation process. Here are the super-useful content development tools. You may also want to check the ultimate list of blogging sites which includes more than 50 publishing sites.

Content Research Tools

Research plays a huge role in what your readers think of your business, products, services, and website. Content creation can be as easy as digging up information or digging around on the internet.

In this section, I’ll take you through some of the most useful tools out there so that you can get started on creating great content for your blog or website.

Content research tools are essential when creating content because the internet is vast, and there’s hardly any limit to what you can find out about a subject matter.

Carrot: The short demo you watched above is from Carrot. It organizes your search results into topics. It clusters, categorizes and show them in different formats.
Occamm: Occam is another SERP organizer. It refines your search result and allows you to select based on the tags.
Entity Explorer: Entity explorer finds related entities in a graph map. It makes easier to see connections between entities.
Research Rabbit: This is one of my favorite research tools. A research and relationship visualization tool.
Semantic Scholar: A free, AI-powered research tool for scientific literature.
Paper Panda and
Unpaywall: They both allow you to access millions of academic papers and researches for free.
Google Trends: You probably know this tool. Google Trends shows the popularity of a term among Google Searchers.
Answer The Public: Another useful tool to research people’s questions.
Miro: Miro is actually a whiteboard app. It allows collaboratively working on your content ideas. There are plenty of project management frameworks that make your ideation process easier.

Content Management Tools

You need comprehensive document and knowledge management tools to get the most out of your content research. You can clip, capture, and annotate the content with these creation tools. There are a bunch of apps that you can use for this purpose. Most of those tools have browser extensions.

Annotating is an excellent way to get your creative juices flowing. It allows you to take notes on what you’re reading or thinking, making it easy to revise later.

I love using various notes apps or knowledge-saving tools and would recommend them to anyone looking to improve their writing skills.

These content creation tools allow anyone to collect ideas, quotes, share knowledge and other content in an easy and intuitive way. These content saving/management tools save you time looking for relevant information while creating your blog posts and videos.

Free Blogging Platforms: An article that mentions the best free blogging platforms.
Polar: You can manage and save your content from PDFs, EPUBs, and web pages in one place. It allows tagging, shows reading progress, and shows detailed document information.
Weava: You can highlight, annotate, and organize the content in one place.
Memex: It is a bookmark manager. It is an open-source tool that allows you to annotate, organize and share.
JustClip: A tool for collecting content that is suitable for individuals and teams. You can capture information and annotate content. You can easily build your knowledge connections and stay organized.
Wakelet: Wakelet is a tool for collecting and curating content. It is particularly used by the education industry.It is one of my favorite tools. You can create a Wakelet profile and a collection and publish your curated lists in various formats.
Liner: Liner is another productivity tool that helps you find and learn reliable information faster. You can highlight web pages and PDF files. It suggests trusted content from other Liner users.
Obsidian MD: It is also my favorite tool that I dumped every piece of note into it. It is offline-first meaning that your notes stay on your PC. It is a markdown editor and has a wiki-style backlink feature with built-in graph view options. There are other popular options for an alternative to Obsidian are Notion, Nimbus Note, and Roam Research and Notesnook.
Raindrop: Raindrop is one of the best bookmark manager in the market. It has cross-platform apps/extensions, intuitive user-interface and a generous plan.

Readability Score Tools

Readability is the ease with which a reader can understand a written text.

It is an essential parameter for the user as well as for SEO.

It is also known that artificial intelligence, and thus the Google crawler, is better at distinguishing short sentences than long ones.

As a result, short sentences are easier to understand for both the reader and the Googlebot. Of course, you have to consider your readers.

There will be no problem for them in writing complex articles on relatively tricky subjects if your readers are experts on your case.

The content creation software in this section are applications that measure at least which age group can understand your articles. It is called the readability score.

There are some popular formulas and metrics calculating the readability score of your text.

However, creating short and concise content can be hard to create. With the tools below, you can make your copy more readable and quickly shorten sentences. Run your written copy through the web app and you’ll see the opportunities to make it better for your readers in seconds.

It should also be noted that most of them are either free or freemium with a generous plan.

Hemingway Editor: It is one of the most well-known content readability improvers. This popular readability tool judges the “grade level” of your text using the Automated Readability Index.
Typewipe: This helpful content creation program offers both readability analysis and helps you improve your content according to your keyword.
Twinword Writer: Twinword Writer is a tool that analyzes the tone of your content. It highlights the words that have negative and positive impacts on the tone of your text.

Grammar and Punctuation Checker Tools

The content creation tools in this section are handy for creating content in English. Those can be classified as grammar correction and punctuation checker tools. Using these tools will help you write better content about topics that matter to you.
The tools in this section are awesome grammar and punctuation checker tools. Those will help you finish your sentences, spot typos, and get the words right no matter how much time you have.
The most popular grammar tool on this list is Grammarly. It offers a good user experience along with rich suggestions.

However, it should also be noted that Grammarly doesn’t improve its tool and features. There are various alternatives to that provide different writing features that Grammarly doesn’t provide.

You can also read The Best Grammar Tools article, which reviews different tools for this purpose.

Here are the best grammar and punctuation checker tools.

Grammarly: It is one of the most well-known grammar tools. Grammarly is the best tool for this task. It has a really intuitive interface and a lot of fun features. It has a desktop and mobile application. Those apps exist both for macOS and Windows.
Linguix: Another Grammarly alternative, this English content creation assistant also stands out with its paraphrase feature.
ProWritingAid: Although this content creation software does not offer as good a user experience as Grammarly and Linguix, it has much more advanced features.
Atomic Editor: It is an AI-assisted editor that boosts your writing productivity.
SlickWrite: A tool that shows grammatical corrections and useful statistics.
Ludwig: A search engine for sentences. You can find your sentence in the best contexts, get definitions, synonyms, and examples. Also, you can paraphrase your sentence.
Ginger: Another Grammarly alternative tool that helps you correct grammar and punctuation.
Writer: I just discovered the app. First, it has a great design. Moreover, Writer provides many useful features comparing its competitors like a more customizable style guide and a bunch of many other things. It also has a free plan. You can use its web app, browser extension, or outlook app.

Search Engine Optimized Content Creation Tools

It is not easy to find both budget-friendly and skilled tools. Of course, I’m speaking particularly about marketing tools. Anyway, I’ll share my relatively budget-friendly and search-engine-optimized content creation tools.

SEO Content Analyzer: It has a bunch of tools for copywriting.
Frase: This is one of my favorite tools. An AI-based content creation tool. Moreover, advanced paraphrasing and question-based features.
CanIRank: My other favorite SEO content tool that optimizes your content for search engines. When the first analysis is complete, it shows pretty useful keyword opportunities.
Ink: Another SEO web content writing editing tool that you can download.

Visual Content Creation Tools

I don’t remember who said it but it is true: “If content is king, then design is queen”. Whether you are creating visual content or written content, visually appealing content is preferable to the other. You can easily find the visual content creation tools you need such as:

Image Creation Tools/ Social Media Tools
Video Creation Tools
Infographic Creation Tools
Presentation Creation Tools

If you are more interested in visual design resources, you can check my other curated list:

Free design resources.

Let’s start our list of digital content creation with some tools focused on creating and editing visual content elements.

Image creation/editing tools

There are a lot of free image editing tools out there. Some offer advanced editing features and others are more casual apps. But if you’re looking for a basic set of image editing tools that can help you get your job done, then here are some of our favorites.

Figma: Oh great Figma. It is one of the greatest apps of the decade.
Canva: Canva is the most popular and the most used image creation tool. It has both free and premium plans. If you need quick visual content for your social media marketing operations, Canva is one of the best design tools.

There are also many image tools similar to Canva. Those are- Crello,- Artify,- Projector,- Taler,- Design AI, etc.

Photopea is one of my favorite tools. It is a minified version of photoshop and it is working on a browser.
Remove.bg and- Erase.bg: A well-known background remover. You can extract people from an image.

Presentation tools

Presentations are the core engine of any persuasive speaker. They establish credibility, inspire others, and move audiences emotionally. That’s why the first step in any persuasive presentation is to select the right tools.

Presentations are a fundamental tool for any professional, whether they want to build a reputation or just sell products.

Pitch: This presentation creation tool allows you to collaboratively create your design asset.
Ludus: It is a collaborative presentation tool for creative teams
Premast Plus: You can use its professional templates to design better presentations and with a faster way. Even if you don’t have any design experience.

Infographic tools

A well-designed infographic can go a long way towards convincing people to click through from a website or social media channel. Infographics are powerful, flexible, and can be used to achieve a wide range of results.

They’re an effective tool for getting immediate attention – without creating an overwhelming feeling. If it is done correctly, infographics can be a backlink magnet.

Visme: Visme is an online tool that allows you to easily create infographics. Those are very useful for visual explanations and building backlinks.
Infogram: Infogram is a visual creation tool that allows you to create infographics and visual stories with data.
Piktochart: Piktochart is another super functional tool for the visual content creation process. It helps you to make gorgeous infographics, presentations, and reports.
Venngage: An infographic design solution.
Graficto: Graficto is an infographic maker tool that is recently launched

Video creation tools

Video content is consumed super-fast compared to written one. Therefore, it is widely popular among the mass. Having a useful instrument will definitely make your life easier.

Animoto: Animoto is a video creation tool with a drag-and-drop interface. It has templates that allows you start with pre-made graphics.
Biteable: One of the favorite video creation tools of content marketers. Express any concept. Personalize colors to match your brand.
RenderForest: Another tools for creating video content.
Runway ML: This tool is literally amazing. However, it has a steep learning curve because Runway has many features that use machine learning.
Powtoon: A suit of video creation tools. You can crop, rotate your videos. Powtoon also has a unique feature that removes watermarks from videos.

Miscellaneous Tools

Buyer Persona: You should know who you are speaking if you have an intention to make your reader comfortable. This tool allows you to create a buyer persona.
Otter: A tool for generating notes from audio records.
Giphy: Who doesn’t love GIFs. You can search and use millions of GIFs.

As I said before, this post is a growing list of content creation tools. I’m trying to add great content development and content creation tools to here. Therefore, it is better to bookmark and come back later.

Exploring the Nx Framework: Next JS Development

Can Burak Sofyalioglu — Mon, 30 Aug 2021 05:22:11 +0000

NX Workspace Introduction

In this blog post series, I am going to explore the features that NX workspace that provides. The original post can be found on NextJS Tutorial with Nx Framework .

In this blog post series, I am going to explore the features that NX workspace provides. I'm going to build a simple Next JS web app with Tailwind CSS styling within the Nx workspace.

Shameless promototion

This post was written during the research process of Alarm systems guide (Alarm sistemleri in Turkish). You can also check the list of blogging sites

NX is an advanced set of extensible dev tools for mono repositories, with a strong emphasis on modern full-stack web technologies.

1) Setup NextJS App on Nx Workspace

npm install -g nx

# Install and create workspace
npx create-nx-workspace nx-tutorial

# Choose project types
✔ Workspace name (e.g., org name)     · nx-tutorial
? What to create in the new workspace … 
❯ empty             [an empty workspace with a layout that works best for building apps]
  react             [a workspace with a single React application]
  angular           [a workspace with a single Angular application]
  next.js           [a workspace with a single Next.js application]
  gatsby            [a workspace with a single Gatsby application]
  nest              [a workspace with a single Nest application]
  express           [a workspace with a single Express application]
  web components    [a workspace with a single app built using web components]
  react-express     [a workspace with a full stack application (React + Express)]
  angular-nest      [a workspace with a full stack application (Angular + Nest)]
  oss               [an empty workspace with a layout that works best for open-source projects]

# Choose whether you'll use Nx Cloud or not
✔ Use Nx Cloud? (It's free and doesn't require registration.) · Yes
>  NX  Nx is creating your workspace.

# get into the workspace
cd nx-tutorial

Nx Workspace directory structure

1.1) See the available plugins

You can see all of the available plugins with nx list command

# See the available plugins
nx list

>  NX  Installed plugins:

  @nrwl/jest (builders,generators)
  @nrwl/linter (builders)
  @nrwl/workspace (builders,generators)

>  NX  Also available:

  @nrwl/angular (generators)
  @nrwl/cypress (executors,generators)
  @nrwl/express (executors,generators)
  @nrwl/nest (executors,generators)
  @nrwl/next (executors,generators)
  @nrwl/node (executors,generators)
  @nrwl/nx-plugin (executors,generators)
  @nrwl/react (executors,generators)
  @nrwl/storybook (executors,generators)
  @nrwl/web (executors,generators)

>  NX  Community plugins:

1.2) Installation of the Next plugin

Now, install the Next plugin and see the options of it.

# Install the plugin
yarn add @nrwl/next

1.3) See the plugin options

Let's see what we can do with the plugin. You'll see the available options for the plugin you choose. I am going to generate an application but first I need to see all options. We have options four options to generate and 3 to execute.

# See the options for the plugin
# nx list [plugin]
nx list @nrwl/next

>  NX  Capabilities in @nrwl/next:

  GENERATORS

  init : Initialize the @nrwl/next plugin
  application : Create a Next.js application
  page : Create a Next.js page component
  component : Create a React component

  EXECUTORS/BUILDERS

  build : Build a Next.js app
  server : Serve a Next.js app
  export : Export a Next.js app. The exported application is located at dist/$outputPath/exported.

1.4) See the options for generating a Next application

Before generating the Next application, It will be better to see initial configuration options for generating an app. To do this, I must append help flag to the end of the command.

# See the options for generating a Next application
nx generate @nrwl/next:application --help

nx generate @nrwl/next:application [name] [options,...]

Options:
  --name                  The name of the application.
  --directory             The directory of the new application.
  --style                 The file extension to be used for style files. (default: css)
  --server                The server script path to be used with next.
  --linter                The tool to use for running lint checks. (default: eslint)
  --skipFormat            Skip formatting files
  --skipWorkspaceJson     Skip updating workspace.json with default options based on values provided to this app (e.g. babel, style)
  --unitTestRunner        Test runner to use for unit tests (default: jest)
  --e2eTestRunner         Test runner to use for end to end (e2e) tests (default: cypress)
  --tags                  Add tags to the application (used for linting)
  --js                    Generate JavaScript files rather than TypeScript files.
  --setParserOptionsProjecWhether or not to configure the ESLint "parserOptions.project" option. We do not do this by default for lint performance reasons.
  --standaloneConfig      Split the project configuration into <projectRoot>/project.json rather than including it inside workspace.json
  --dryRun                Runs through and reports activity without writing to disk.
  --skip-nx-cache         Skip the use of Nx cache.
  --help                  Show available options for project target.

1.5) Generating a Next JS application

It is better to use —dryRun flag on generating an application. Also, I need to give a name to my app. When I execute the command, some configuration options will be available to me. I'll stick with CSS styling option

# I'll also choose the name of the app as "store"
nx generate @nrwl/next:application store

? Which stylesheet format would you like to use? … 
❯ CSS
  SASS(.scss)       [ http://sass-lang.com          ]
  Stylus(.styl)     [ http://stylus-lang.com        ]
  LESS              [ http://lesscss.org            ]
  styled-components [ https://styled-components.com ]
  emotion           [ https://emotion.sh            ]
  styled-jsx        [ https://www.npmjs.com/package/styled-jsx ]

1.6) Start Next JS Application

After setting up the Next application, let's open workspace.json file. In the file, you will see the target list under the store application. Those are the actions that I can do with the Next JS application.

{
  "version": 2,
  "projects": {
    "store": {
      "root": "apps/store",
            --- --- --- --- --- ---
      "targets": {
        "build": {
                    --- --- --- --- --- ---
        },
        "serve": {
                    --- --- --- --- --- ---
        },
        "export": {
                    --- --- --- --- --- ---
        },
        "lint": {
                    --- --- --- --- --- ---
        }
      }
    },
    --- --- --- --- --- ---
    --- --- --- --- --- ---

Now, I can start serving the app by the run command.

# Serving the app
# nx run [project]:[target]
nx run store:serve

Now, open your browser and navigate to http://localhost:4200/

2) Installing Dependencies

2.1) TailwindCSS Setup

I am going to style the web app with Tailwind CSS. Let's add the dependencies of it.

# Tailwind CSS dependencies
yarn add -D tailwindcss@latest postcss@latest autoprefixer@latest

# Other styling libs
yarn add @heroicons/react @headlessui/react

# Put tailwind config file in the app dir
cd apps/store
npx tailwindcss init -p

// apps/store/postcss.config.js
module.exports = {
  plugins: {
    tailwindcss: { config: './apps/store/tailwind.config.js' },
    autoprefixer: {},
  },
};

According to the docs, Nx utility function should be used for purge property. This eliminates additional manual maintenance as your workspace progresses. Also, it should be noted that Nx only purges on production build.

// apps/site/tailwind.config.js
const { join } = require('path');

// available since Nx v 12.5
const { createGlobPatternsForDependencies } = require('@nrwl/next/tailwind');

module.exports = {
  mode: 'jit',
  purge: [
    join(__dirname, 'pages/**/*.{js,ts,jsx,tsx}'),
    ...createGlobPatternsForDependencies(__dirname),
  ],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {
    extend: {},
  },
  plugins: [],
};

2.2) Import TailwindCSS Styles

When I'm in the root folder, I'll create separate style file for tailwind.

# create tailwind.css file on pages dir
touch apps/store/pages/tailwind.css

/* apps/store/pages/tailwind.css */
@tailwind components;
@tailwind base;
@tailwind utilities;

/* apps/store/pages/styles.css */
@import "./tailwind.css";

/* The rest of styles.css file */
/* ----------------------------*/

3) Create a library

Nx framework allows you to structure your project with apps and libs. In other words, we don't need to create app libraries specifically in the app directory. We can also create separate and publishable libraries.

There are different types of libraries you can create:

Nx Library types

You can easily move the libraries using the @nrwl/workspace:move generator command

We have two options for building libraries either —buildable or —publishable. Those are valid for Angular, React, NestJS and Node. Therefore, I am going to use React libraries as a separate standalone publishable library.

You will also find useful options flag that you can pass to the CLI command. You can find the full list of the react:library options.

@nrwl/react:library flags

# Create a library wiht @nrwl/react package
# See which files will be written to the disk 
# (output is not produced)
nx g @nrwl/react:lib tailwind-ui --dry-run 

# Now create the library as publishable
# publishable flag requires importPath=npmusername/libraryname 
nx g @nrwl/react:lib tailwind-ui  --publishable --importPath=@canburaks/tailwind-ui --globalCss=true --component=false

# Also you can remove the library as like this
# nx g remove tailwind-ui

# You'll see the ouput like that
✔ Which stylesheet format would you like to use? · css
UPDATE workspace.json
UPDATE nx.json
CREATE libs/tailwind-ui/.eslintrc.json
CREATE libs/tailwind-ui/.babelrc
CREATE libs/tailwind-ui/README.md
CREATE libs/tailwind-ui/package.json
CREATE libs/tailwind-ui/src/index.ts
CREATE libs/tailwind-ui/tsconfig.json
CREATE libs/tailwind-ui/tsconfig.lib.json
UPDATE tsconfig.base.json
CREATE libs/tailwind-ui/jest.config.js
CREATE libs/tailwind-ui/tsconfig.spec.json

4) Create a components

Now, I generated a publishable user interface component library. I'm planning to populate this library with tailwind components.

Additionally, style=none flag is added because components styling will be done by tailwind classes and there is no need to create extra style file.

Also, the library will not include tailwindcss library, meaning that the library has a peer dependency of tailwindcss.

@nrwl/react:components flags

4.1) Generate components for the library

# Navbar component
nx g @nrwl/next:component Navbar --project=tailwind-ui --style=none --export=true  

# Footer component
nx g @nrwl/next:component Footer --project=tailwind-ui --style=none --export=true

4.2) Generate components for the app

I generated the required files for the library components. It is a good practice to create Layou component for the NextJS apps. Let's create it.

nx g @nrwl/next:component Layout --project=store --style=none

Now, fill those files likes these:

// apps/store/components/layout/layout.tsx

import Navbar from './navbar'
import Footer from './footer'

export default function Layout({ children }) {
  return (
    <>
      <Navbar />
      <main>{children}</main>
      <Footer />
    </>
  )
}

// libs/tailwind-ui/src/lib/navbar/navbar.tsx
export function Navbar() {
  return (
    <section className="w-full px-8 text-gray-700 bg-white ">
      <div className="container flex flex-col flex-wrap items-center justify-between py-5 mx-auto md:flex-row max-w-7xl">
        <div className="relative flex flex-col md:flex-row">
          <a
            href="/"
            className="flex items-center mb-5 font-medium text-gray-900 lg:w-auto lg:items-center lg:justify-center md:mb-0"
          >
            <span className="mx-auto text-xl font-black leading-none text-gray-900 select-none">
              cbsofyalioglu<span className="text-indigo-600">.</span>
            </span>
          </a>
          <nav className="flex flex-wrap items-center mb-5 text-base md:mb-0 md:pl-8 md:ml-8 md:border-l md:border-gray-200">
            <a
              className="mr-5 font-medium leading-6 text-gray-600 hover:text-gray-900"
              href="/contact"
            >
              Contact
            </a>
          </nav>
        </div>

        <div className="inline-flex items-center ml-5 space-x-6 lg:justify-end">
          <a
            href="/login"
            className="text-teal-600 px-8 py-2 border-teal-600  font-medium leading-6 border-2 rounded-lg transition ease-out duration-300 hover:text-blueGray-100 hover:bg-teal-600"
          >
            Login
          </a>
        </div>
      </div>
    </section>
  );
}

// libs/tailwind-ui/src/lib/footer/footer.tsx
export function Footer() {
  return (
    <section className="text-gray-700 bg-white body-font border-t-4 border-teal-800">
      <div className="container flex flex-col items-center px-8 py-8 mx-auto max-w-7xl sm:flex-row">
        <a
          href="https://www.filizguvenlik.com.tr"
          className="text-xl font-black leading-none text-gray-900 select-none logo"
        >
          cbsofyalioglu<span className="text-indigo-600">.</span>
        </a>
        <p className="mt-4 text-sm text-gray-500 sm:ml-4 sm:pl-4 sm:border-l sm:border-gray-200 sm:mt-0">
          © 2021 -{' '}
          <a href="https://webmeister.org" target="_blank" className="text-xs" rel="noreferrer">
            Webmeister
          </a>
        </p>
      </div>
    </section>
  );
}

// libs/tailwind-ui/src/index.tsx
export * from "./lib/navbar/navbar"
export * from './lib/footer/footer';

Now, I must build the library. By doing this, I'll be able to import the components to the app.

# build library
nx run tailwind-ui:build

// apps/store/pages/_app.tsx
import { AppProps } from 'next/app';
import Head from 'next/head';
import './styles.css';
import Layout from '../components/layout/layout';

function MyApp({ Component, pageProps }) {
  return (
    <Layout>
      <Component {...pageProps} />
    </Layout>
  );
}

export default MyApp;

// // apps/store/pages/index.ts
export default function Index() {
  return (
    <div className="min-h-screen">

    </div>
  );
}

Now, restart the server.

4) Generate pages

// Generate a contact page
nx generate page Contact

// apps/store/pages/contact.tsx
/* eslint-disable react/no-unescaped-entities */
/* eslint-disable @next/next/no-img-element */

export default function Contact(props) {
  return (
    <div className="container mx-auto mt-8 md:mt-0 md:space-x-10 md:grid grid-cols-3 justify-center md:py-40">
      <div className="grid justify-center items-center order-1 col-span-1">
        <img
          className="lg:h-80 md:h-64 h-40 rounded-full"
          src="https://cbsofyalioglu.fra1.cdn.digitaloceanspaces.com/cbs/cbsofyalioglu-black.png"
          alt=""
        />
      </div>
      <div className="mt-8 md:mt-0 lg:justify-end col-span-2">
        <h1 className="text-4xl text-gray-800 text-center md:text-left font-bold mb-6">
          Hi, I am Can Burak Sofyalioglu.
        </h1>
        <p className="text-xl text-gray-800 text-center md:text-left">
          I'm an engineer.
        </p>
      </div>
    </div>
  );
}

Free Design Tools - Generators, Graphics Templates, Prototyping ...

Can Burak Sofyalioglu — Tue, 09 Feb 2021 07:52:27 +0000

These resources will be updated frequently. Therefore, bookmarking is suggested. You can check the original and updated page by visiting: Free Design Resources
Another shameless plug of mine is the article that reviews Best Free Platforms for Blogging

Free Design Resources and Graphic Design Tools

The collections of free design resources and graphic design tools. I listed many graphic design resources that make it possible to generate and create useful graphics.

If you are also interested in not only design resources but also content creation tools, you can check my other curated list:

Free Design Resources Part I – Generator Apps

These tools generate design resources for you. They are simple tools but generate effective patterns and code. Those are free design resources that you can tweak and use them.

Magic Pattern

Magic Pattern consists of a bunch of freemium tools. The link to the SVG wave generator is below; also check out other tools.
Magic Pattern SVG Wave Generator

Get Waves

A free SVG wave generator to make unique SVG waves for your next web design. Choose a curve, adjust complexity, randomize!
Get Waves

SVG Waves

Another generator that produces wave patterns in SVG or PNG formats. SVG Wave is a minimal gradient svg wave generator with a lot of customization. It lets you the ability to generate and export pngs and svgs of beautiful waves. SVG wave also lets you layer multiple waves. Create SVGs for your website designs.
Svg Wave

Faux Code Generator

This app requires a link of any GitHub gist. When you provide the source code, the web app transforms it to faux code graphics.
Faux Code Generator

Neumorphism CSS Generator

This web app allows you to create neumorphism CSS code that you tweak visually.
Neumorphism CSS Generator

Soft UI

Another free design resource that makes it possible to build neumorphic style code.
Explore the most advanced CSS box shadow generator for your UI. Create colors, gradients, elements in the neuromorphic design: fast, free, no ads.

Soft UI

Glitch Art

The glitch art generator produces glitch patterns.
Glitch Art

Fancy Border Generator

This online design resources allows you to make custom shape borders.
Fancy Border Generator

Components.ai

This design resource actually a suit. It consists of many design generator that is produced by machine learning algorithms. Gradients, color scales, voronoi, and bootstrap color palette generator.
Components AI

Material Shadow

It allows you to add shadows to your icons. You can also select predefined material icons.
Material Shadow

Technology Bullshit Generator

If you need flashy words, then this app makes it for you. It creates a flashy but bullshit word generator.
Tech Bullshit Generator

Squircley

Squircley generate a shape neither square nor circle. You can tweak it as you want.
Squircley

Shape Divider

It divides the shape You realized that some kind of divided shapes are well suited on landing pages. You can do those kind of shapes with this design resource.
Shape Divider App

Blobs

Decorative blob generator tool.
Blobs

Omatsuri Suite

Omatsuri is not a single graphic design tool. It is actually a free design resources suit. You can find many useful graphic design resources such as triangle generator, wave generator, color shades and color palette generators.
Progressive Web Application with 12 open source frontend focused tools
Omatsuri Suite

Blog Cover Generator

Easy blog post cover generator.
Blog Cover Generator

Patternico

A pattern generator.
Patternico

Doodad

Yet another pattern generator
Doodad

Tabbied

Doodle with generated patterns.
Tabbied

BG Jar

Very useful background pattern generator which can export your design in various formats such as CSS, SVG or PNG.
BG Jar

Free Design Resources Part II – Visual Content Creator Tools

Canva

Canva is the most popular and the most used graphic content creations site. It has both free and premium plans. If you need a quick visual content Canva is one of the best design resource.
Canva

Easil

Easil is another Canva alternative that has limited features for free plan.
Easil

Visme

Visme is an online tool that allows you to easily create info-graphics. Those are very useful for visual explanations and building back-links.
Visme

Glorify

Glorify is a Canva-like tool that specifically create graphics for different platforms such as Product Hunt, Shopify, Fiver etc…
Glorify

Polotno Studio

Polotno Studio allows you to edit your graphics.
Polotno Studio

Projector

Projector is also another free graphic template design tool.
Projector

Taler

Taler is relatively new tool comparing with other free design resources. It is also powered by e-commerce platform Shopify.
Taler

Crello

It is very limited graphic design tool. Only 5 design downloads are permitted.
Crello

Artify

I personally like the illustration of Artify. Once in a while, It does not respond. However, It is now working. I should also mention that attribution is required.
Artify

Free Design Resources Part III – Prototyping and Graphic Editing Tools

Figma

Figma is awesome. It is a sketch alternative. Moreover, It is boosted by Web-Assembly technology that makes possible to do these stuff on your browser. It is great for teams and freelancers. It also allows you to graphically edit React components. In this way, Framer is a unique design tool.
Figma

Penpot

Penpot is an open-source free prototyping and design tool that is currently at alpha stage.
Penpot

Framer

Framer stands out with its mobile and interaction prototype development. It has web version as long as MacOS versions. React developers may know Framer Motion library which is the product of Framer.
Framer

Lunacy

Lunacy is a desktop software created by Icons8. Because of the creator company, it has built-in assets. Currently only available for Windows.
Lunacy

Spline

One of the best tools of 2020. Spline allows you to create 3D geometry. Moreover, It has Linux support.

Spline

Free Design Resources IV – Design System Tools

Toolabs Design System

Toolabs is a very intuitive tools that allows you to create your design system and export it with various formats such as CSS, JSON etc.. Also, It creates a web page for your design system that you can access and share it easily.
Toolabs DSM

Frontify

Frontify actually is more than a design system tool. It is a complete brand design suite. It has a free plan for freelancers. You can create your design guideline and design system. Frontify also allows you to create a web page in order to access and share your guideline. Moreover, you can develop and design a user-interface component and share the code easily. A sample guideline page can be seen below:

Frontify

Diez

Tokens are great when the case is design. Diez is a tool that is specialized in creating design tokens.
Diez

ZeroHeight

You can create your design guidelines with Zeroheight and make it single source of truth. Because it includes both design and code assets, communication with designers and developers becomes less problematic.

ZeroHeight

Free Design Resources V – Miscellaneous

Design Lobby

It is nice looking asset manager. You can deploy your design assets such as typefaces, icons, images and colors. Currently in a beta phase.
Design Lobby

Squoosh

Squoosh is a one page web app that is the easiest way to compress images. As we know, Google stated that fast opening is an important factor when ranking websites. Therefore, image compression is a must for websites that is aiming to rank higher. Considering the situation, Squoosh is an important free design resource.
Squoosh

Currently the original post includes more than 70 Free Design Resources and Graphic Design Tools

Hosted Confluence Installation with Custom Domain

Can Burak Sofyalioglu — Sun, 15 Nov 2020 19:12:51 +0000

One of our customers from Istanbul Private Airport Transfer and Private Transfer in İstanbul ask the possibility of using Atlassian Confluence as a self-hosted wiki program. We look for solutions for a while. Later on, we discovered Cloudron app. In this article, We'll install Confluence with a custom domain on our servers.
If your intentions using that as a blog platform, you may want to check Best Blogging Platforms for Developers

What is Confluence?

Confluence is a team collaboration and wiki software developed by Australian software company Atlassian.
It is a web-based application and written in Java programming language.It was released in 2004 (Voav) as an enterprise knowledge management software.

==You can use it as a team collaboration app, wiki, knowledgebase, blog, intranet etc==.

If you read my articles written in Turkish, you realized that talented editor is a must for me in any platform I wrote. The editor of Confluence is one of the best editor in the universe. It has really advanced permission level. You can create many workspaces.

However, Atlassian Cloud doesn’t allow us to use our custom domains and managed Confluence solutions is a bit complicated.

Fortunately, Cloudron made it easier for us to use it on our own servers. By doing this, we can use our own custom domains with Atlassian Confluence app.

How much does it cost to use Self-Hosted Confluence?

Confluence requires at least 4 GB RAM. Thus, the most expensive cost will the cloud instance.Cloudron is free for personal usage up to 2 apps which is completely sufficient for us.
Therefore, the cost of using Confluence with a custom domain will be:

$20/month Cloud Cost on Digital Ocean + one-time license fee of $10.

I'll share a referral links below that gives you some amount of free credits. Thus, It is free to follow this guideline.

What are the requirements?

Digital Ocean Account: This is the platform that hosts our Confluence server. You can get free $100 credit which is available 60 days if you register with this referral link.
Cloudron Account: Cloudron provides software solutions for hosting different applications on our servers. You can also get __ $30 free credit__ if you register with this referral link
Domain Name: You'll need a custom domain.

Step 1 - Create Droplet with Cloudron

Our Confluence app will be hosted on the droplet which we will create now. A Droplet is basically a virtual server in Digital Ocean.

I'm assuming that you have created an DA account and created a project. Now, we'll create a droplet with Cloudron app installed.

On the left side, you'll find Marketplace link under the Discover section.

Click the marketplace link. Search and select Cloudron.
Click Create Couldron Droplet button.
Now, you'll see the droplet settings page. As I told you before, Confluence requires minimum 4 GB RAM. Therefore, we should minimum select Basic plan which costs $20/month. Also, we'll choose the closest datacenter to us and create a password as an authentication method.

At the bottom of the page, we'll click the Create Droplet button. It will start the installation of cloud instance and Cloudron application.

Step - 2) Initial Configurations

We are going to make some domain adjustments. There are two cases for your domain name provider.

The nameservers of your domain name are on Digital Ocean.
Your nameservers are on another provider.

In either case, I'll follow the manual method that fits every case.

DNS Settings

First, visit the project page on Digital Ocean. If any IP number assigned to your instance, note it down. Otherwise, wait till the assignment. For example mine is 46.101.148.85.

To make illustration, Let say we have a domain livicomturkiye.com. We also decided to use a subdomain for the Confluence app, let's say notes.livicomturkiye.com.

Second, Whether your DNS provider is DA or not, visit your domain name provider's website. Go to DNS management page of your domain name.
Add these two 'A records' that target the IP number we saved above.

Host	Target
notes	46.101.148.85
my.notes	46.101.148.85

First one is the subdomain name you use with Confluence. Second one is the cloudron panel with a prefix of my.
Save the records.

You can control whether your domain is pointing to correct IP by visiting dnschecker.org. If the A record points to the correct IP, you can proceed. DNS propagation can take some time. Therefore, this process can took time.

Cloudron settings

Open your browser and paste the IP number of your instance on a new page.

(Note: We have not any secure certificate now.Therefore, your browser will warn you about the privacy. This means your connection is not encrypted end-to-end. Open the advanced settings and proceed with unsafe method.)

You'll see Cloudron setup page.

Write down your domain/subdomain that will be used for Confluence app.
Select Manual as DNS Provider.

Click Next. Now, Cloudron will start to make proper internal configurations. Whet it finishes, you'll fill the admin form.

Confluence Installation

If we did everyhting right, we see an empt Cloudron page.
On the upper right menu, click App Store. Before this, you fill the login form of Cloudron.

Write your credentials and login.
Search Confluence and install it.

Step - 3) Confluence Settings

I assume that all the settings properly configured. Now, click Confluence app on Cloudron page.

A setup page welcomes us. Follow the steps below:

Select Product Installation. If you need Concluence Questions or Confluence Team Calendars, please also select them. Click Next.
Press Get an evaluation license link and get the license for Confluence Server. Click Next.
If you have a database choose My own database. Otherwise, you can use built-in database as a temporary solution. Click Next.
Wait until the database settings are done. Then, create an empty site.
Fill the System Administrator Account.
Give your space a name. For example: "Personal Wiki".

Now, you can use Atlassian Confluence on your domain. You can create a redirection to your space or make your space public. Just configure them on General Configuration.

Django and Modern JS Libraries - Svelte (3)

Can Burak Sofyalioglu — Mon, 22 Jun 2020 12:51:00 +0000

Django and Modern JS Libraries - Svelte

(Note:This article is originally published on cbsofyalioglu.com while building the websites of Istanbul private transfer, Istanbul Cruise Port Transfer and Izmir alarm sistemleri)

Another shameless plug of mine is the article that reviews Best Blogging Platforms for Developers

In the previous part, we built a Django backend and GraphQL API. In this part, we will integrate the Django project with Svelte.

Thus, it's necessary to follow first part of the tutorial .

What is Svelte and How it differs from React?

I told that I like Python and its ecosystem. I also like Just-In-Time compilers and language supersets like Cython, which really boosts Python performance. When I learned that JavaScript is an interpreted language, I tried to look Cython equivalent of it. Because of different browser compilers, I couldn’t find what I want and it made a disappointment. Maybe it is the reason I feel excitement when I give Svelte a chance.

If you didn't try Svelte before, you may give it a chance. Svelte's interactive API and tutorials are also worth to praise. Being familiar with Svelte API and Tutorials is definitely recommended.

When I'm talking about Svelte, I'm strictly speaking about Svelte 3. It is another JavaScript library written by Rich Harris. What makes Svelte special is:

It is truly a reactive library and it doesn't use virtual DOM like React. Therefore, there is no VDOM diff calculations.
It has a compiler and when you build your application it produces optimized JavaScript code. In the end, Svelte code almost disappear and you have vanilla JavaScript.
You can write HTML, CSS and JavaScript in single file component and there will be no global CSS pollution.

Yes, React was revolutionary. However, how many times we have to deal with virtual DOM synchronization problems or the extra burden for even very small operations are the other side of the medallion.

Svelte Configuration with Webpack from Scratch

Step - 1: Configuring development environment

(Note: if you already installed the node, you can skip this part)

We will use Node backend for the development environment. Therefore, we need to install Node and Node package manager npm. To prevent potential dependency problems, we will create a clean node environment. I will use NVM which is Node version manager, and it allows us to create isolated Node environments. In your terminal, run the code below.

Setup Node Environment with NVM

In your terminal, run the code below.

# install node version manager 
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

# check installation
command -v nvm

# should prints nvm, if it doesn't, restart your terminal

# install node
# node" is an alias for the latest version

# use the installed version
nvm use node
nvm install node

Now we can create frontend directory in Django project. Go to the root directory of the project. 'backend/'

In your terminal copy and paste the code.

# create frontend directory
mkdir FRONTEND
cd FRONTEND

# now your terminal directory should be
# backend/FRONTEND 
# create a node project
npm init
# you may fill the rest

Now we can install front-end and development libraries .

# install svelte and other libs 
npm install --save-dev svelte serve cross-env  graphql-svelte

# install webpack and related libs
npm install --save-dev webpack webpack-cli webpack-dev-server

# install webpack loaders and plugins 
npm install --save-dev style-loader css-loader svelte-loader mini-css-extract-plugin

npm install --save node-fetch svelte-routing

Update package.json scripts part as below. Your file should look like this and ignore the versions.

{
  "name": "django-svelte-template",
  "description": "Django Svelte template. ",
  "main": "index.js",
  "scripts": {
    "build": "cross-env NODE_ENV=production webpack",
    "dev": "webpack-dev-server --content-base ../templates"
  },
  "devDependencies": {
    "cross-env": "^7.0.2",
    "css-loader": "^3.5.3",
    "graphql-svelte": "^1.1.9",
    "mini-css-extract-plugin": "^0.9.0",
    "serve": "^11.3.1",
    "style-loader": "^1.2.1",
    "svelte": "^3.22.3",
    "svelte-loader": "^2.13.6",
    "webpack": "^4.43.0",
    "webpack-cli": "^3.3.11",
    "webpack-dev-server": "^3.11.0"
  },
  "dependencies": {
    "node-fetch": "^2.6.0",
    "svelte-routing": "^1.4.2"
  }
}

Let's create application necessary files and folders for Svelte. In the root directory of the project 'backend/' , open your terminal.

# create HTML file of the project
cd templates
touch index.html

# change directory to backend/FRONTEND
cd ../FRONTEND
mkdir src
touch index.js
touch webpack.config.js

# change directory to backend/FRONTEND/src
cd src
touch App.svelte
touch MovieList.svelte
touch MoviePage.svelte
touch api.js

Step 2 - Webpack configuration

What is webpack ?

Webpack is a module bundler and a task runner. We will bundle all our JavaScript application including CSS styling into two JavaScript files, if you prefer you can output only one file. Because of the rich plugins, you can also do many things with Webpack like compressing with different algorithms, eliminate unused CSS code, extracting your CSS to different files, uploading your bundle to cloud provider like S3 etc…

I made two different Webpack settings in one file. One is for development environment, and the other one is for production environment. Also note that we do not optimize these configurations.

Copy/Paste the following code into *****webpack.config.js***** file.

const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const path = require('path');

const mode = process.env.NODE_ENV || 'development';
const isEnvProduction = mode === 'production';

const productionSettings = {
    mode,
    entry: {
        bundle: ['./index.js']
    },
    resolve: {
        alias: {
            svelte: path.resolve('node_modules', 'svelte')
        },
        extensions: ['.mjs', '.js', '.svelte'],
        mainFields: ['svelte', 'browser', 'module', 'main']
    },
    output: {
        path: path.resolve(__dirname, '../static'),
        filename: 'js/[name].js',
        chunkFilename: 'js/[name].[id].js'
    },
    optimization: {
        minimize: true,
        runtimeChunk: false,
      },
    module: {
        rules: [
            {
                test: /\.svelte$/,
                use: {
                    loader: 'svelte-loader',
                    options: {
                        emitCss: true,
                        hotReload: true
                    }
                }
            },
            {
                test: /\.css$/,
                use: [
                    /**
                     * MiniCssExtractPlugin doesn't support HMR.
                     * For developing, use 'style-loader' instead.
                     * */
                    MiniCssExtractPlugin.loader,
                    'css-loader'
                ]
            }
        ]
    },
    devtool: false,
    plugins: [
        new MiniCssExtractPlugin({filename: '[name].css'})
    ],
};

const devSettings = {
    mode,
    entry: {
        bundle: ['./index.js']
    },
    resolve: {
        alias: {
            svelte: path.resolve('node_modules', 'svelte')
        },
        extensions: ['.mjs', '.js', '.svelte'],
        mainFields: ['svelte', 'browser', 'module', 'main']
    },
    output: {
        publicPath: "/",
        filename: 'static/js/bundle.js',
        chunkFilename: 'static/js/[name].chunk.js',
    },
    devtool: 'source-map',
    devServer: {
        historyApiFallback: true,
        stats: 'minimal',
      },
    module: {
        rules: [
            {
                test: /\.svelte$/,
                use: {
                    loader: 'svelte-loader',
                    options: {
                        emitCss: true,
                        hotReload: true
                    }
                }
            },
            {
                test: /\.css$/,
                use: [
                    /**
                     * MiniCssExtractPlugin doesn't support HMR.
                     * For developing, use 'style-loader' instead.
                     * */
                    'style-loader',
                    'css-loader'
                ]
            }
        ]
    },
    mode,
    plugins: [
    ],
}


module.exports = isEnvProduction ? productionSettings : devSettings;

Step 3 - Create a Single-Page-App witth Svelte

First, fill the 'backend/FRONTEND/index.js'.

import App from './src/App.svelte';

const app = new App({
    target: document.body,
});

window.app = app;

export default app;

Next, fill the 'App.svelte' file with proper logic.

<!-- App.svelte -->
<script>
  import { Router, Link, Route } from "svelte-routing";
  import MovieList from "./MovieList.svelte";
  import MoviePage from "./MoviePage.svelte";

  export let url = "";
</script>

<Router url="{url}">
  <nav class="navbar">
    <Link to="/">Home</Link>
  </nav>
  <div class="main-container">
    <Route path="movie/:slug" component="{MoviePage}" />
    <Route path="/"><MovieList /></Route>
  </div>
</Router>

<style>
    .navbar {
        background-color:rgba(0,0,0,0.6);
        display: flex;
        padding: 16px 64px;
        font-weight: bold;
        color:white;
    }
    .main-container {
        margin-top:32px;
        display:flex;
        justify-content: center;
        align-items: center;
        background-color: rgba(0,0,0, 0.15);
    }

</style>

Before routing pages, I will first write the client-side queries. Please open api.js and copy/paste the code below.

import { GraphQLProvider, reportCacheErrors } from "graphql-svelte";

const client = GraphQLProvider({
    url: 'http://127.0.0.1:8000/graphql',
    headers: () => ({
        "content-type": "application/json",
        Accept: 'application/json'
    })
})


client.graphql.on('cache', reportCacheErrors)





// our first query will requests all movies
// with only given fields
// note the usage of string literals (`)
export const MOVIE_LIST_QUERY = `
    query movieList{
        movieList{
            name, posterUrl, slug
        }
    }
`

// Note the usage of argument.
// the exclamation mark makes the slug argument as required
// without it , argument will be optional
export const MOVIE_QUERY = `
    query movie($slug:String!){
        movie(slug:$slug){
            id, name, year, summary, posterUrl, slug
        }
    }
`

// This is generic query function
// We will use this with one of the above queries and
// variables if needed
export async function get(query, variables = null) {
    const response =  await client.get({ query , variables })
    console.log("response", response);
    return response
}

Now, route pages: MovieList.svelte will be shown on homepage as we defined in the above. If user clicks any movie card, then MoviePage.svelte file will be rendered.

Fill the MovieList.svelte.

<script>
    import { Router, Link, Route } from "svelte-routing";
    import { get, MOVIE_QUERY, MOVIE_LIST_QUERY } from "./api.js";

    var movielist = get(MOVIE_LIST_QUERY);

</script>

<div class="wrapper">

    <!-- promise is pending -->
    {#await movielist}
        loading

    <!-- promise was fulfilled -->
    {:then response}
        {#if response.data.movieList.length > 0}
            {#each response.data.movieList as movie}
                <div class="card">
                    <Link to={`/movie/${movie.slug}`}>
                        <img class="poster" alt={movie.name} src={movie.posterUrl} />
                        <p class="movie-title">{movie.name}</p>
                    </Link>
                </div>
            {/each}
        {/if}

    <!-- promise was rejected -->
    {:catch error}
        <p>Something went wrong: {error.message}</p>
    {/await}
</div>
<style>
    .wrapper {
        width:100%;
        height: auto;
        display:flex;
        flex-direction: row;
        flex-wrap: wrap;
    }
    .card {
        box-sizing: border-box;
        position: relative;
        width:200px;
        height:auto;
        margin:16px;
        border-radius: 8px;
        overflow: hidden;
        box-shadow: 0 4px 4px rgba(0,0,0,0.25);
    }
    .poster {
        width:100%;
        height:auto;
        cursor: pointer;
    }
    .movie-title {
        padding:4px 8px;
        font-weight: bold;
        text-decoration: none;
        cursor: pointer;
    }
</style>

Also fill MoviePage.svelte according to this.

<script>
    import { Router, Link, Route } from "svelte-routing";
    import { get, MOVIE_QUERY } from "./api.js";

    // acquired from dynamic route part => /movie/:slug
    export let slug;

    const moviedata = get(MOVIE_QUERY, {slug})

</script>

<div class="wrapper">

    <!-- promise is pending -->
    {#await moviedata}
        <p>Movie {slug} is loading</p>

    <!-- promise was fulfilled -->
    {:then moviedata}
        {#if moviedata.data}
            <div class="movie-container">
                <img 
                    src={moviedata.data.movie.posterUrl} 
                    alt={`${moviedata.data.movie.name} poster`} 
                    class="movie-poster"
                />
                <div class="text-box">
                    <h1 class="movie-title">{moviedata.data.movie.name}</h1>
                    <p class="movie-description">{moviedata.data.movie.summary}</p>
                </div>
            </div>
        {/if}

    <!-- promise was rejected -->
    {:catch error}
        <p>Something went wrong: {error.message}</p>
    {/await}
</div>
<style>
    .wrapper {
        width:100%;
        height: auto;
        display:flex;
        flex-direction: column;
        justify-content: center;
        align-items: center;
    }
    .movie-container {
        display: flex;
        flex-wrap: wrap;
        max-width:500px;
    }
    .movie-poster {
        width:250px;
        height:auto;
    }
    .text-box {
        display: flex;
        flex-direction: column;
    }
</style>

Start Svelte App in Development Environment

In the development environment we will run two different servers. When our Svelte app is running, it requests data from Django server. After the response come, Webpack Development server render the page with proper data. This is only for development stage.

When we finish the front-end development, we will build and bundle client-side app. After then we will start Django server, and it will be the only server we will use in production environment, as I promise before.

Go to the root folder of the Django project. '*backend/'*

Execute the below command and make the Django server ready for front-end requests.

# execute it on the root folder of Django 'backend/'
python manage.py runserver

Open another terminal and change the directory to the 'backend/FRONTEND'

# On another terminal
npm run start

When Svelte app successfully compiled, open your browser 'localhost:8080/'.

You should see similar screen like the image below.

MovieList.svelte will render the screen

MoviePage.svelte screen will render this if the user clicks any movie card

What will be happened at the moment?

At this moment, “/“ root page will be rendered. Because of our routing configurations, MovieList.svelte file will be rendered first. If the user clicks any film card, then the MoviePage.svelte file will be rendered regarding its slug value.

We succesfully integrated Django and Svelte. Now make the production build.

Django and Svelte Integration in Production Environment

Now you can stop webpack server while keeping the Django server alive.

In the backend/FRONTEND/ directory, execute the command below.

npm run build

This will build and bundle all your Svelte app in bundle.js file. When bundling process is over, go to the URL of Django server in your browser. --> "127.0.0.1:8000/"

You should see the same screens above. Also note the static folder which has new files coming from webpack bundling.

FINISHED

This is the code repo of all three parts.

(Note:This article is originally published on cbsofyalioglu.com while building the websites of Istanbul Airport Transfer, Istanbul Cruise Port Transfer and Istanbul Travel Guide)

Django and Modern JS Libraries - React (2)

Can Burak Sofyalioglu — Mon, 22 Jun 2020 12:50:20 +0000

Django and Modern JS Libraries - React

In the previous part, we built a Django backend and GraphQL API that is responsible for communication of Django project and React app. In this part of the tutorial, we will create a single page application with React from scratch. We will bundle our application with webpack and we will not use create-react-app boilerplate. Also, if you like reactive programming, you may be interested in SolidJS and Reactive Primitives.

Create React App from Scratch

Step - 1: Configuring development environment

(Note: if you already installed the node, you can skip this part)

# install node version manager wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

# check installation
command -v nvm  

# should prints nvm, if it doesn"t
# you can restart your terminal

# install node
# node" is an alias for the latest version
nvm install node 

# use the installed version
nvm use node

# prints Now using node v..

Now we can create frontend directory in Django project.Go to the root directory of the project. 'backend/'In your terminal copy and paste the code.

# create frontend directory
mkdir FRONTEND
cd FRONTEND

#in backend/FRONTEND create a Node project 
npm init
# you may fill the rest

Now we can install Javascript dependecies such as React and API related other libraries.

# add core react library
npm install react react-dom react-router-dom

# add graphql client-side framework of Apollo and parser 
npm install apollo-boost @apollo/react-hooks graphql graphql-tag


# -- DEVELOPMENT PACKAGES---
# add babel transpiler
npm install --save-dev @babel/core @babel/preset-env @babel/preset-react

# add webpack bundler
npm install --save-dev webpack webpack-cli webpack-dev-server

# add webpack loaders and plugins
npm install --save-dev babel-loader css-loader style-loader html-webpack-plugin  mini-css-extract-plugin postcss-loader postcss-preset-env

If everything goes well, we can create necessary files.

# create source folder for client side code
mkdir src
# our react app's root file
touch index.js

#create webpack config file
touch webpack.config.js

# get into src folder
cd src

# create HTML entrypoint for React development
touch index.html


# our app file and styling
touch App.js

// Screens
touch MovieList.js
touch MoviePage.js

# for styling
touch App.css

All npm packages contain a file which holds metadata about the app. This file is package.json file. You should update *package.json* file.

Edit scripts section, and add Babel presets and postcss configurations.

{

  "scripts": {
  "start": "webpack-dev-server --open --hot --mode development",
  "build": "webpack --mode production"
  },
  "babel": {
    "presets": [
      "@babel/preset-env",
      "@babel/preset-react"
      ]
   },
  "postcss": {
    "plugins": { "postcss-preset-env": {} }
   },



}

Step 2 - Webpack configuration and index.html file

What is webpack ?

Webpack is a module bundler and a task runner. We will bundle all our JavaScript application including CSS styling into two JavaScript files, if you prefer you can output only one file. Because of the rich plugins, you can also do many things with Webpack like compressing with different algorithms, eliminate unused CSS code, extracting your CSS to different files, uploading your bundle to cloud provider like S3 etc…

I made two different Webpack settings in one file. One is for development environment, and the other one is for production environment. Also note that we do not optimize these configurations.

Copy/Paste the following code into *webpack.config.js* file.

const path = require("path");
const HtmlWebPackPlugin = require("html-webpack-plugin");

// checks if it is production bundling or development bundling 
const isEnvProduction = process.argv.includes("production")

// our JS root file
const entrypoint = './index.js'

const productionSettings = {
    mode: "production",
    entry: entrypoint,
    output: {
        // output directory will be the root directory of django
        path: path.resolve(__dirname, '../'),
        // this is the bundled code we wrote
        filename: 'static/js/[name].js',
        // this is the bundled library code
        chunkFilename: 'static/js/[name].chunk.js'
    },
    optimization: {
        minimize: true,
        splitChunks: {
          chunks: 'all',
          name: true,
        },
        runtimeChunk: false,
      },
    devServer: {
        historyApiFallback: true,
        stats: 'normal',
      },

    module: {
        rules: [
            {
                loader: 'babel-loader',
                test: /\.js$|jsx/,
                exclude: /node_modules/
            },
            {
                test: /\\.css$/i,
                use: [
                  // IMPORTANT => don't forget `injectType`  option  
                  // in some cases some styles can be missing due to 
                  // inline styling. 
                  { loader: 'style-loader', options: { injectType: 'styleTag' } },
                  "css-loader"
                ],
            },
        ]
    },
    plugins: [
        new HtmlWebPackPlugin({

            // ENTRYPOINT - this is where webpack read our app for bundling
            template: "./src/index.html",

            // OUTPUT FILE
            // this is emitted bundle html file
            // ----------------------------------
            // django will use this as template after bundling
            // -----------------------------------
      filename:"./templates/index.html"
        }),
    ]
};

const devSettings = {
    mode: "development",
    entry: entrypoint,
    output: {
        path: path.resolve(__dirname, './build'),
        publicPath: "/",
        filename: 'static/js/bundle.js',
        chunkFilename: 'static/js/[name].chunk.js',
    },
    devtool: 'inline',
    devServer: {
        historyApiFallback: true,
        contentBase: './dist',
        stats: 'minimal',
      },
    module: {
        rules: [
            {
                loader: 'babel-loader',
                test: /\.js$|jsx/,
                exclude: /node_modules/
            },
            {
                test: /\.css$/i,
                use: [
                    //{loader: MiniCssExtractPlugin.loader, options: {
                    //    //your styles extracted in a file for production builds.
                    //    //hmr: isEnvDevelopment,
                    //  },
                    //  },
                  // IMPORTANT => don't forget `injectType`  option  
                  { loader: 'style-loader', options: { injectType: 'styleTag' } },
                  "postcss-loader"
                  //"css-loader"
                  //{ loader: 'sass-loader' },
                ],
            },
        ]
    },
    plugins: [
        new HtmlWebPackPlugin({
            template: "./src/index.html",
        })
    ]
};

module.exports = isEnvProduction ? productionSettings : devSettings;

When we are developing frontend, our React app render all our JavaScript code to this HTML file in the src folder. Also, when we build our code for production (bundling), Webpack will use this HTML as a template.

It is important to say that Django will not use this HTML file. This is the HTML entry point of_ W_ebpack. *Django will use the output of webpack bundle*.

Update your index.html file.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="theme-color" content="#000000" />
    <meta name="description" content="Django-React Integration Tutorial"/>
    <title>Django React Integration</title>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>

Step - 3 Create the React app

The index file is the root file of our app, meaning that all our codes will be connected to this root file. The other tutorials or eact boilerplates use this file for only render function of ReactDOM and leave it tiny and clear. Writing this index file as it is is a totally a choice.

What we will do is as follows:

We will create an Init component that will initialize the API framework (Apollo) and routing library (react-router-dom).

We will wrap our App.js file with API framework so that all our components will be in the context of API.

The Apollo Provider expects an Apollo client. The Apollo client has the information of the requested address, which is the address of our Django server.

After then we will wrap our App file again with the router component, namely Browser Router. This makes our app a single-page-application. Thus, we make routing without rendering all the page when the URL of the address bar changes.

At the end of the file, you will see the render function of ReactDOM which accepts our root component, which is Init component in our case, and the DOM element that our app will be rendered in there.

Update your *index.js* file as follows.

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';

import { BrowserRouter } from "react-router-dom"

import ApolloClient from 'apollo-boost';
import { ApolloProvider } from '@apollo/react-hooks';



/*
    our frontend api client will make request to 
    the adress we define in the first part.
*/
const apiclient = new ApolloClient({
    uri: 'http://127.0.0.1:8000/graphql',
  });


const Init = () => (
    <ApolloProvider client={apiclient}>
        <BrowserRouter>
            <App />
        </BrowserRouter>
    </ApolloProvider>
)

ReactDOM.render( <Init />, document.getElementById('root'))

Now, we are ready to create our simple movie app.

Our app has two different screens:

The main page which lists all movies in the database with less information
The movie page will show specific movie with more information.

Now update your *App.js* file.

import React from "react";
import { Route, Switch, Link } from "react-router-dom"

// UI Screens we will define later
import MoviePage from "./MoviePage.js" //New
import MoviePage from "./MoviePage.js" //New

import "./App.css"

const App = () => {
    return (
        <div className="App">
            <Switch>
                <Route exact path="/" component={MainPage} />

                {// colon before slug means it is a dynamic value
                // that makes slug parameter anything
                // like: /movie/the-lighthouse-2019   or /movie/anything
                // as long as slug matches with database.
                }
                <Route exact path="/movie/:slug" component={MoviePage} />
            </Switch>
        </div>
    )
}
export default App

*Let me explain what those code means*

When a user first opens our page, switch component from react-router-dom will look the URL. Then try to match the path of route components with this URL, if any, then the matched component in the route will be rendered.

Step - 4 Create page components and styling

MovieList component will be shown on landing page. Copy/Paste to "MovieList.js" file

import React from "react";
import gql from "graphql-tag";



// our first query will requests all movies
// with only given fields
// note the usage of gql with 'jsvascript string literal'
export const MOVIE_LIST_QUERY = gql`
    query movieList{
        movieList{
            name, posterUrl, slug
        }
    }
`

const MovieList = (props) => {
    const { loading, error, data } = useQuery(MOVIE_LIST_QUERY);

    // when query starts, loading will be true until the response come.
    // At this time this will be rendered on screen
    if (loading) return <div>Loading</div>

    // if response fail, this will be rendered
    if (error) return <div>Unexpected Error: {error.message}</div>

    //if query succeed, data will be available and render the data
    return(
        <div className="main-page">
            {data && data.movieList &&
                data.movieList.map(movie => (
                    <div className="movie-card" key={movie.slug}>
                        <img 
                            className="movie-card-image"
                            src={movie.posterUrl} 
                            alt={movie.name + " poster"} 
                            title={movie.name + " poster"} 
                        />
                        <p className="movie-card-name">{movie.name}</p>
                        <Link to={`/movie/${movie.slug}`} className="movie-card-link" />
                    </div>
                ))
            }
        </div>
    )
}

export default MovieList

MoviePage component will show more details than the list view but only information of a specific movie.

Copy and paste the code MoviePage.js file.

import React from "react";
import gql from "graphql-tag";


// Note the usage of argument.
// the exclamation mark makes the slug argument as required
// without it , argument will be optional
export const MOVIE_QUERY = gql`
    query movie($slug:String!){
        movie(slug:$slug){
            id, name, year, summary, posterUrl, slug
        }
    }
`


const MoviePage = (props) => {
    // uncomment to see which props are passed from router
    //console.log(props)

    // due to we make slug parameter dynamic in route component,
    // urlParameters will look like this { slug: 'slug-of-the-selected-movie' }
    const urlParameters = props.match.params

    const { loading, error, data } = useQuery(MOVIE_QUERY, { 
        variables:{slug:urlParameters.slug}
    });

    if (loading) return <div>Loading</div>
    if (error) return <div>Unexpected Error: {error.message}</div>

    return (
        <div className="movie-page">
        <Link to="/" className="back-button" >Main Page</Link>
            {data && data.movie && 
                <div className="movie-page-box">
                    <img 
                        className="movie-page-image"
                        src={data.movie.posterUrl} 
                        alt={data.movie.name + " poster"} 
                        title={data.movie.name + " poster"} 
                    />
                    <div className="movie-page-info">
                        <h1>{data.movie.name}</h1>
                        <p>Year: {data.movie.year}</p>
                        <br />
                        <p>{data.movie.summary}</p>
                    </div>
                </div>
            }
        </div>
    )
}

export default MoviePage

Add some styling: update *App.css.*

html, body {
    width:100vw;
    overflow-x: hidden;
    height:auto;
    min-height: 100vh;
    margin:0;
}

.App {
    position: absolute;
    left:0;
    right:0;
    display: flex;
    min-width: 100%;
    min-height: 100vh;
    flex-direction: column;
    background-color: #181818;
    /*font-family: "Open Sans", sans-serif;*/
    font-size: 16px;
    font-family: sans-serif;
}

/* MAIN PAGE */
.main-page {
    position: relative;
    display: flex;
    flex-wrap: wrap;
    min-height: 40vh;
    background-color: #3f3e3e;
    margin:10vh 5vw;
    border-radius: 6px;
}

/* MOVIE CARD */
.movie-card {
    position: relative;
    width:168px;
    height:auto;
    background: #f1f1f1;
    border-radius: 6px;
    margin:16px;
    box-shadow: 0 12px 12px -4px rgba(0,0,0, 0.4);
}
.movie-card:hover {
    box-shadow: 0 12px 18px 4px rgba(0,0,0, 0.8);

}
.movie-card-image {
    width:168px;
    height:264px;
    border-top-left-radius: 6px;
    border-top-right-radius: 6px;
}
.movie-card-name {
    text-align: center;
    margin: 0;
    padding: 8px;
    font-weight: bold;
}
.movie-card-link {
    position: absolute;
    top:0;
    left:0;
    right: 0;
    bottom: 0;
}

/* MOVIE PAGE */
.back-button {
    position: absolute;
    left:10px;
    top:10px;
    width:120px;
    padding: 8px 16px;
    text-align: center;
    background: #f1f1f1;
    color:black;
    font-weight: bold;
    cursor:pointer;
}

.movie-page {
    position: relative;
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    flex-wrap: wrap;
    min-height: 80vh;
    margin:10vh 10vw;
    border-radius: 6px;
}

.movie-page-box {
    position: relative;
    display: flex;
    height:352px;
    background-color: #f1f1f1;
}
.movie-page-image {
    width:280px;
    height:352px;
}
.movie-page-info {
    position: relative;
    display: flex;
    flex-direction: column;
    height:352px;
    width: auto;
    max-width: 400px;
    padding: 16px 32px;
}

Finally, Start Django-React App

Development Environment

In development environment we will run two different servers. One is Django server for backend, and the other one is Webpack server for frontend development. In production environment, We will only run one Django server as I promise.

Go to the root folder of the Django project. '***backend/'.*

Execute the below command and make Django server ready for frontend requests.

python manage.py runserver

Open another terminal and go to FRONTEND directory. 'backend/FRONTEND'

npm run start

You will see those screens.

Django and React Successfully Integrated . We created a simple single-page-application. Now, the last part of this tutorial will be made this app works seamlessly with our Django project.

Now you can stop the webpack server with the corresponding terminal screen.

The Final Part - Production Build of Django and React

Now, We can build our app for the production environment. Go to the FRONTEND directory and execute the build command.

npm run build

When the build process done, there will be two Javascript file in *backend/static* folder:

main.js
vendors~main.chunk.js

Also check *backend/templates* folder and you will see other *index.html* file.

*This is the HTML file that Django will use.*

I made this graphic in order to show webpack bundling process and how our app will use output files.

FINISHED

canburaks / django-and-modern-js-libraries

Tutorial series of Django and modern JS libraries.

Django and Modern JS Libraries - Backend (1)

Can Burak Sofyalioglu — Mon, 22 Jun 2020 12:47:53 +0000

What is this tutorial about?

Django and Modern JS Frameworks will be a tutorial series that integrates Django and contemporary frontend solutions such as React and Svelte. Other framework/library integrations are also planning in the future.

The Project Description

We will setup one Django server and make two simple single page applications. Each of them will use different Javascript libraries and both of them will communicate with Django server.
React application will be written from scratch with webpack in the second part. Also note that create-react-app will not be used.
The latest and third part of this tutorial will be the Svelte integration.

There are 2 projects and 3 articles in this series:

Django server and GraphQL API setup
React application setup with webpack and integrating it with our back-end.
Svelte application setup with webpack and integrating it with our back-end.

What are the requirements to follow?

Basic level of knowledge about Python and Django framework
Basic level of Javascript and React is a must.

Motivation and Preliminary Information

Python is my first programming language. When we were making a movie recommendation engine, we must integrate it with Facebook’s React library because we want it to be a single page application. My level of knowledge about Javascript was at introduction level. Proficient in an unfamiliar programming language takes some time. Also, I like Python ecosystem because of the excellent data science libraries and giving up from Python was never a choice. To sum up, it really took some time to integrate Django and React. When I recently published my development blog and Istanbul travel guide, I edited and update all my old articles. During this time, another front-end library was released, and it excited me a lot: Svelte. I also added an integration article with Svelte and Django. I hope that this article series will help newcomers a bit to to solve their problems.

There will be only one server on each project which is running in a production environment.

INTRODUCTION

What is a Single Page Application?

In classic web pages, all HTML, CSS and JS code are arranged and transferred by the server in a render-ready form. When a browser receives the code, it immediately render elements on a screen. If a user clicks a link, then the browser makes another request to the server. The server will make all the logical operations and respond with another render-ready code.

In modern client-side apps, some logical operations are handled by Javascript code which is executed in the browser of users. Because of this, servers send all the website code in the first request. Thus, browsers need extra time for the first contentful painting.

Except the first loading, client side apps works faster and feels more native because some actions are done immediately on browser and I/O operations can be done via asynchronous behavior of Javascript. Therefore, users still see your app rather than blank white page.

Browsers are amazing and capable of many impressive things. Because of this capability, handling resource heavy operations in the user’s browser can be a suitable alternative. Otherwise, those operations make our server busy and can increase the bill.

Anyone who slaps a ‘this page is best viewed with Browser X’ label on a Web page appears to be yearning for the bad old days, before the Web, when you had very little chance of reading a document written on another computer, another word processor, or another network. ~ Tim Berners-Lee

Create The Backend with Django

Step-1: Create a Django project from scratch

Let's create a virtual environment for clean setup.

This virtual environment will be an active environment for all three articles.

python3 -m venv tutorial-env

# activate
source ./tutorial-env/bin/activate

Install Django and dependencies

# install our dependencies
pip install ipython django django_extensions django-cors-headers "graphene-django>=2.0"

#create a django project
django-admin startproject djangoproject

# change directory
cd djangoproject

# create templates directory
mkdir templates

# create static folder
mkdir static

# create utils folder for initial data
mkdir utils

2- Configuring and running

Update your ***'djangoproject/djangoproject/settings.py'*** file. Extra settings are labeled as *'New ...'.*

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    "django_extensions",# New! (useful extension)
    'graphene_django',  # New! (for graphql communication)
    'corsheaders',      # New! (for cors request in dev env)
]

# New (for improved interactive shell)
SHELL_PLUS = "ipython"

# New (it allows webpack development server to make cross origin request)
CORS_ORIGIN_WHITELIST = (
    'http://localhost:8080',
)


MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'corsheaders.middleware.CorsMiddleware', # New Add this
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': (os.path.join(BASE_DIR, 'templates'),), # New
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

#New 
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static'),
)

Before starting our project, we should first make database migration. After, we will run our server and will see that is working.

# create migration for django-orm
python manage.py migrate

Now, if everything goes well, Django server will start. You can open your browser and check the address 127.0.0.1:8000 You will see a screen like that:

Step-3: Creating a movie app

We will create a movie model with basic fields that a movie should have.

Before that, we should give some information about the field choices.

*Why there is URL field for poster rather than image field?*

Because serving static files in production is not recommended, we use only the URL field. Fetching the image from remote and then saving it to our production storage is a topic of another post. Because of this, we will save only the poster’s URL, not the poster’s itself as an image file. Also, sending static files like images is not a good approach. We will send the exact URL of an image to the user. Then, the *user’s browser fetches the image* from this.

*What is a slug and why it should be unique?*

Let me explain with an example: I published the original article on cbsofyalioglu[com]/post/django-and-modern-js-libraries-backend

The last part of the URL , django-and-modern-js-libraries-backend, is the slug of the post and also it is an identifier which makes the URL distinctive from other post pages.

In the GraphQL part of the tutorial, you will see that we will use this slug as a query parameter meaning that we will do database queries according to slug. Therefore, it should be unique.

We can also choose another identifier as the as URL identifier, but it’s clear that the URL will not be human-readable address.

Search engine indexing and ranking is a vital part of any website targeting new users. Readable URL address’ are good for users themselves and also suggested by search engine guides. Also, Google webmaster guidelines recommends using clean and concise URL structures.

Let’s make our model and define its properties and methods. In the next step, we will populate our database with initial records. Therefore, I added a class method responsible for database population.

Let's create a Django app. This app will includes our model. The database tables will be done according to this. Also API requests will be based on this.

# create new Django app
python manage.py startapp items

Update settings .py


INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    "django_extensions",
    'graphene_django', 
    'corsheaders',
    "items"             # New! (make our app will active)
]

Open ***'djangoproject/items/models.py'*** file and copy the below code.


# items.models

from django.db import models

class  Movie(models.Model):

    id  = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=100)
    year = models.IntegerField(null=True)
    summary = models.TextField(max_length=5000,null=True)
    poster_url = models.URLField(blank=True, null=True)
    slug = models.SlugField(max_length=50, null=True,blank  =True, unique=True)
    # order items in descending order
    class  Meta:
        ordering = ["-year"]

    # the method which defines string output of class
    def  __str__(self):
        return  self.name

    # the method which loads initial data
    @classmethod
    def  import_records(cls, record_list):
        for record in record_list:
            # create record if id is not exist
            if  not  cls.objects.filter(id=record.get("id")).exists():
                new_movie =  cls.objects.create(**record)
            else:
                print(f"Id:{record.get('id')} is already exist.")
        print("Import operation done successfully")

# make database migrations
python manage.py makemigrations
python manage.py migrate

Step-4: Populating database with initial data

There is no movie record currently in our database. We will provide a small initial data to create some movie records. All the data is provided by the community built The Movie Database (TMDb). We will use those records in our app.

First, create a *"initial_data.py"* file in ***"djangoproject/utils"*** folder. After, you can copy and paste below data to this new file.

initial_data = [{
    'id': 503919,
    'name': 'The Lighthouse',
    'year': 2019,
    'summary': 'The hypnotic and hallucinatory tale of two lighthouse keepers on a remote and mysterious New England island in the 1890s.',
    'slug': 'the-lighthouse-2019',
    'poster_url': 'https://image.tmdb.org/t/p/w185/3nk9UoepYmv1G9oP18q6JJCeYwN.jpg'
    },{
    'id': 475557,
    'name': 'Joker',
    'year': 2019,
    'summary': 'During the 1980s, a failed stand-up comedian is driven insane and turns to a life of crime and chaos in Gotham City while becoming an infamous psychopathic crime figure.',
    'slug': 'joker-2019',
    'poster_url': 'https://image.tmdb.org/t/p/w185/udDclJoHjfjb8Ekgsd4FDteOkCU.jpg'
    },{
    'id': 530385,
    'name': 'Midsommar',
    'year': 2019,
    'summary': "A couple travels to Sweden to visit a rural hometown's fabled mid-summer festival. What begins as an idyllic retreat quickly devolves into an increasingly violent and bizarre competition at the hands of a pagan cult.",
    'slug': 'midsommar-2019',
    'poster_url': 'https://image.tmdb.org/t/p/w185/rXsh4MI6uyVgZBSSzXCfitJnVPy.jpg'
  },{
    'id': 531428,
    'name': 'Portrait of a Lady on Fire',
    'year': 2019,
    'summary': 'On an isolated island in Bretagne at the end of the eighteenth century, a female painter is obliged to paint a wedding portrait of a young woman.',
    'slug': 'portrait-of-a-lady-on-fire-2019',
    'poster_url': 'https://image.tmdb.org/t/p/w185/3NTEMlG5mQdIAlKDl3AJG0rX29Z.jpg'
  }]

Now, we will import and create new records at database level. Normally we should have open Django shell. However, *shell_plus* command which is provided by *django_extensions* is more functional, so we will use this. It automatically imports all apps we created.

# open interactive shell
python manage.py shell_plus

# let's check database and verify it's empty
Movie.objects.all()
# prints: <QuerySet []>

# import the records which we took it from github repo
from utils.initial_data import initial_data

# create records in the database
Movie.import_records(initial_data)

# prints 'Import operation done successfully'

# query database and verify it is not empty
Movie.objects.all()

Our model and database are ready. You can close the shell with *quit* command.

The next section will be creating a GraphQL API.

GraphQL API

In this section we will make our app’s API part with Graphene which is a GraphQL framework implementation of Python.

What we do in this section is:

Creating another Django app: We will put all API configurations in there.
Creating an API Schema that has three parts: API-model, Resolvers and Queries.
Creating a URL endpoint:The client-side application will requests all information to this URL address.

Step 1 - Creating another Django app for API configurations

Actually, there is not any obligation to make another app because this app will not create or update any database table. However, to put all API-related configurations in one place, I chose this way.

Let’s create the second backend app. The name of the app should not have to be *‘gql’* , but if you set another name, you should also change the name of the schema in *settings .py* later.

Open your terminal at the root level of your project.

# create app with the name gql
python manage.py startapp gql

# change directory
cd gql


# create schema.py file
touch schema.py

Step 2 - Creating an API Schema: API-model, Queries and Resolvers

API-schema will have three parts considering the scope of the article.

Those are as follows:

*API-Model-Type:* A class which is a mapped version of movie model. You can send responses based on this, if the response is not a primitive type.
*Queries:* The client-side app will use these queries for distinct requests.
*Resolvers:* Those are response functions of fields. When the client side request matched with a query, the resolvers come into play and make all the logical parts, then send information back to the client.

*A )* *API-Model-Type and Resolvers*

A class which is a mapped version of an existing Django model. It is the intermediary layer between Django model (or database) and API response. The fields of ModelType will be the same fields of the corresponding model. We can also create custom fields that are not belong to the corresponding model.

You can check other scalar types from the Graphene Python documentations..

We will step by step write the schema .py file. You can copy and paste it.

import graphene
from items.models import Movie
from graphene_django.types import DjangoObjectType

# api-movie-model
class MovieType(DjangoObjectType):
    id = graphene.Int()
    name = graphene.String()
    year = graphene.Int()
    summary = graphene.String()
    poster_url = graphene.String()
    slug = graphene.String()

    # define which model will be the base
    class Meta:
        model = Movie

    # 'self' corresponds to the item of Django model 
    # like The Lighthouse or Joker
    def resolve_id(self, info):
        return self.id

    def resolve_name(self, info):
        return self.name

    def resolve_year(self, info):
        return self.year

    def resolve_summary(self, info):
        return self.summary

    def resolve_poster_url(self, info):
        return self.poster_url

    def resolve_slug(self, info):
        return self.slug

Let me explain the above code.

The 'MovieType’ class is a mapped version of Movie model. You may notice that all the fields are the same. We defined the base model in class Meta, so the movie model will be the base model.

It is important to say that resolver names are written in snake case like ‘resolve_poster_url’. However, when we write client-side queries, those will be pascalCase such as ‘posterUrl’. You see that later.

*B ) Queries and Resolvers*

The client-side app will use these queries for distinct requests. We will also write client-side queries in its part. A client side query should match with server-side query. Therefore, this part also defines the allowable requests of the frontend part.

For the sake of simplicity, we will define only two queries.

The movie_list query (*resolve_movie_list*) returns to all the movies in the database
The movie query (*resolve_movie) returns only specific movie if the parameter (slug*) is matched.

Let add this code below MovieType class.


class Query(graphene.ObjectType):
    movie_list = graphene.List(MovieType)
    movie = graphene.Field(MovieType, slug=graphene.String())

    def resolve_movie_list(self, info, *_):
        # for large lists only query what you need
        return Movie.objects.all().only("name", "poster_url", "slug")

    def resolve_movie(self, info, slug):
        movie_queryset = Movie.objects.filter(slug=slug)
        if movie_queryset.exists():
            return movie_queryset.first()

schema = graphene.Schema(query=Query)

In the last row, you will see a schema object. This is the root node of the API. We should tell the Django server to use this as our API schema. To do so, update the *settings. py*.

# djangoproject/djangoproject/settings.py

# New - Add this part
GRAPHENE= {'SCHEMA': 'gql.schema.schema'}

# MIDDLEWARE = [..]

Step 3 - Create URL endpoints

In REST API, we define different URL Endpoints for different requests. The one of the good part of GraphQL is that we will only define one endpoint. All the requests will be done through that.

Copy the below code and paste it to djangoproject/djangoproject/urls .py**** file.

from django.contrib import admin
from django.urls import path
from graphene_django.views import GraphQLView
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import TemplateView

urlpatterns = [
    path('admin/', admin.site.urls),

    # apiclient on client-side will request this adress later
    path("graphql", csrf_exempt(GraphQLView.as_view(graphiql=True))),


    # index.html file will be our root template. When a user opens our webste,
    # this file will be sent by server at first. After then, api requests
    # will directed above address.

    # (it points to ~/Blog/djr/templates/index.html)
    # (currently there is no file, webpack production bundle will come here )
    path("", TemplateView.as_view(template_name="index.html")),
    ]

You noticed that we set *graphiql=True.* This is GraphQL interactive panel. We can make a query like a client app through this panel. You will also see the details of all queries.

Now, please run the server in the root folder : 'djangoproject/'


python manage.py runserver

Open *127.0.0.1:8000/graphql* address from your browser. We will query the movie with specific identifier (slug). On the left panel, paste this and press the *Execute Query* button.

Please note that, we request fields with pascalCase. (*posterUrl*)


query {

movie(slug:"the-lighthouse-2019"){

id, name, posterUrl

}

}

and the response will be in JSON format like this.


{

"data": {

"movie": {

"id": 503919,

"name": "The Lighthouse",

"posterUrl": "https://image.tmdb.org/t/p/w185/3nk9UoepYmv1G9oP18q6JJCeYwN.jpg"

}

}

}

Our API are ready to response the requests. This part of the tutorial is finished.

Now, we will make two different client-side apps. Please choose one of them to continue.

Forem: Can Burak Sofyalioglu

Python Decorators: A Comprehensive Guide

1. Historical Context

2. What are Decorators?

A) Decorator Variations: Function-based vs. Class-based

Function-based Basic Decorator Syntax

Class-based Basic Decorator Syntax

B) Implementing a Simple Decorator

C) Implementing a Decorator with Arguments

D) Implementing a Parameterized Decorator

E) Implementing a Class Decorator

F) Implementing Method Decorators

G) Implementing Decorator Chaining

H) What happens if we don't use @functools.wraps ?

Benefits of functools.wraps:

I) Decorators with State

J) Best Practices for Python Decorators

K) Bad Implementations (Anti-Patterns)

L) 10. Real-World Use Cases

M) Curated Lists of Python Decorators

N) 11. Conclusion

A Beginner's Guide to Structure SEO-friendly URLs

A Beginner's Guide to Structure Blog Post URLs

A Beginner’s Guide for an SEO-Friendly URL Structure

What happens when you don't have a proper URL structure?

An Analogy to Understand a URL and a Domain Name

Part I: Make A Blog URL structure as SEO-friendly

Which URL structure is Better: Flat or Hierarchical?

What are the Benefits of Using a Hierarchical URL structure

What is a Content Silo?

What does being an authority on a topic means?

What does topical authority mean?

Preventing Duplicate Content

Part II: Making Blog Post URLs as SEO-friendly

What is a slug?

Does using keywords in URLs Affect Rankings?

The Best Practices for Structuring Blog Post URLs

How to Generate Income from Your Blog

Part 1: Quality Content Creation

What does quality content mean?

Understand your audience

Research and identify your target audience's needs, preferences, and pain points

What is a user persona?

Be informative and educational and create easily consumable content

Be original, authentic and create novel content

Promote your content through social media and optimize it for search engines

Part 2: Generating Revenue

What are the ways of earning from your blog?

Income from Ads

Affiliate Income

What is affiliate marketing?

How does affiliate marketing work?

Income from Subscriptions

Exploring SolidJS - The Reactive Primitives (1)

Shameless promotion

Introduction

What are reactive systems?

What Reactive Systems do

Characteristics of Reactive Programming

What are the reactive primitives of SolidJS?

Installation of SolidJS Template

A Reactive JavaScript Library: SolidJS

A) Reactive primitives: createSignal

1) Component State Access and Update

2) Parent Component State Access and Update

B) Reactive primitives: createEffect

C) Reactive primitives: createMemo

D) Reactive primitives: createResource

Awesome Content Creation Tools

Great Content Creation Tools

Content Research Tools

Content Management Tools

Readability Score Tools

Grammar and Punctuation Checker Tools

Search Engine Optimized Content Creation Tools

Visual Content Creation Tools

Image creation/editing tools

Presentation tools

Infographic tools

Video creation tools

Benefits of `functools.wraps`: