SmartServ is on a mission to build a powerful AI-powered assistant enabling service business' to focus and increase their sales metrics by scoring on lead opportunities which are ideally lost in the field

SmartServ

Unity Realtime Multiplayer, Part 2: TCP, UDP, WebSocket Protocols

ইউনিটি রিয়েলটাইম মাল্টিপ্লেয়ার, পার্ট 2: টিসিপি, ইউডিপি, ওয়েবসকেট প্রোটোকল

Unity Realtime Multiplayer, Teil 2: TCP-, UDP- und WebSocket-Protokolle

Multijugador en tiempo real de Unity, Parte 2: Protocolos TCP, UDP y WebSocket

Unity Realtime Multiplayer, partie 2 : TCP, UDP, protocoles WebSocket

यूनिटी रीयलटाइम मल्टीप्लेयर, भाग 2: टीसीपी, यूडीपी, वेबसॉकेट प्रोटोकॉल

Unity リアルタイム マルチプレイヤー、パート 2: TCP、UDP、WebSocket プロトコル

Unity 실시간 멀티플레이어, 2부: TCP, UDP, WebSocket 프로토콜

Unity Realtime Multiplayer, Parte 2: Protocolos TCP, UDP, WebSocket

Unity Gerçek Zamanlı Çok Oyunculu, Bölüm 2: TCP, UDP, WebSocket Protokolleri

Unity Realtime Multiplayer, Phần 2: Giao thức TCP, UDP, WebSocket

Unity 实时多人游戏，第 2 部分：TCP、UDP、WebSocket 协议

GraphQL is an API query language that allows clients to get the data they need more efficiently and flexibly than traditional REST APIs. In recent years, GraphQL has gained a lot of popularity and has become one of the most popular technologies for API creation. At the same time, Next.js is a highly efficient and scalable web application development framework that has become very popular with web developers. This tutorial will explore how to create a GraphQL server and client with Next.js to provide a more efficient and flexible development experience for our users. this tutorial assumes you have basic knowledge of GraphQL and Nextjs (pages directory). Before starting: We will use to make requests and retrieve fake JSON data, in particular, we will use dummyJSON https://dummyjson.com/docs/users Setting Up We create a new Next.js project with the following command and follow the steps indicated. This time we will use , you can use the package manager of your choice. pnpm pnpm create-next-app We install the dependencies that we will need in the project: pnpm install @apollo/server graphql @as-integrations/next apollo-server-core @apollo/client graphql-tag @nextui-org/react is the main library for Apollo Server itself. @apollo/server: An Apollo Server integration for use with Next.js. @as-integrations/next: to create and consume API’s in Graphql language. graphql: to create and manage GraphQL servers simply and flexibly. apollo-server-core: to handle GraphQL requests and statuses on clients. @apollo/client: to build and manipulate GraphQL queries in JavaScript. graphql-tag: library of user interface components. I will use this library only to quickly style the application, feel free to use the one you want. @nextui-org/react After that, we will create the following structure for the project: ...
├── src/
│   ├── graphql/
│   │   ├── queries/
│   │   │   ├── getUseres.gql
│   │   │   └── searchUser.gql
│   │   ├── apollo-client.js
│   │   ├── resolvers.js
│   │   └── schemas.js
│   ├── pages/
│   │   ├── api/
│   │   │   └── graphql.js
│   │   ├── _app.js
│   │   ├── _document.js
│   │   └── index.js
│   │   ...
│   ├── utils/
│   │   └── cors.js
├── .env.local
... Now we will create the file and create the environment variables that we are going to use: .env.local /* we add the prefix NEXT_PUBLIC_ to the variable that will havethe graphql server url defined, this way we will be able toaccess to it client side */

NEXT_PUBLIC_URL_SERVER_GRAPHQL=http://localhost:3000/api/graphqlURL_API=https://dummyjson.com/users Graphql server We will create the GraphQL server inside the directory since it’s where the server created by Nextjs lives. 1— /api : graphql.js import { ApolloServer } from "@apollo/server"
import { startServerAndCreateNextHandler } from '@as-integrations/next'
import { ApolloServerPluginLandingPageGraphQLPlayground } from "apollo-server-core"

import typeDefs from "@/graphql/schemas"
import resolvers from "@/graphql/resolvers"
import allowCors from "@/utils/cors"

const apolloServer = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [ApolloServerPluginLandingPageGraphQLPlayground()]
})

const handler = startServerAndCreateNextHandler(apolloServer, {
  context: async (req, res) => ({ req, res }),
})

export default allowCors(handler) The GraphQL server has two main parts: schemas (typeDefs) and resolvers. The schemas define the structure of the data and the queries that can be made to the server, while the resolvers define how the data is obtained and processed. We also add to the initial configuration of the server the definition of . This plugin provides a GraphQL playground page that allows us to test queries in a more user-friendly way. ApolloServerPluginLandingPageGraphQLPlayground Finally, is used to enable Cross-Origin Resource Sharing (CORS) support on the server. This function adds the necessary CORS headers to the response. allowCors : utils/cors.js const allowCors = (fn) => async (req, res) => {
  res.setHeader('Access-Control-Allow-Credentials', true)
  res.setHeader('origin', 'https://nextjs-graphql-server-client.vercel.app')
  res.setHeader('Access-Control-Allow-Origin', req.headers.origin || '*')
  // another common pattern
  res.setHeader('Access-Control-Allow-Methods', 'GET,OPTIONS,PATCH,DELETE,POST,PUT')
  res.setHeader(
    'Access-Control-Allow-Headers',
    'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version',
  )
  if (req.method === 'OPTIONS') {
    res.status(200).end()
    return
  }
  await fn(req, res)
}

export default allowCors In this file, we have defined the basic headers that the app needs to be able to make requests to the Graphql server. This middleware is fully customizable to the requirements of your application, you can remove or add more headers, either known headers or custom headers that only your app uses. You need to add the necessary headers so you can make requests to the server either using this middleware or directly in your requests. Schema creation 2— : schemas.js import { gql } from 'graphql-tag'

const typeDefs = gql`
  type Query {
    users: [User]
    searchUser(value:String):[User]
  }

  type User {
    id: ID
    firstName: String
    lastName: String
    email: String
    username: String
    image: String
  }
`
export default typeDefs We define a GraphQL schema using . The function is used to convert a string into a valid GraphQL schema document. gql gql In the Schema, we define a query type called , which has a property called , which is a list of objects of type . Query users User We also have the query called which receives a string value with which we will filter the users that match the value. For this tutorial, we will create the type with only some of the API returned properties. searchUser User Resolvers creation 3— : resolvers.js const resolvers = {
  Query: {
    users: async () => {
      try {
        const response = await fetch(process.env.URL_API)
        const data = await response.json()

        return data.users.map(u => {
          return {
            id: u.id,
            firstName: u.firstName,
            lastName: u.lastName,
            email: u.email,
            username: u.username,
            image: u.image
          }
        })
      } catch (error) {
        throw new Error("Something went wrong")
      }
    },
    searchUser: async (_, { value }) => {
      try {
        const response = await fetch(`${process.env.URL_API}/search?q=${value}`)
        const data = await response.json()

        return data.users.map(u => {
          return {
            id: u.id,
            firstName: u.firstName,
            lastName: u.lastName,
            email: u.email,
            username: u.username,
            image: u.image
          }
        })
      } catch (error) {
        throw new Error("Something went wrong")
      }
    }
  }
}

export default resolvers We define the resolvers that correspond to each query. The resolvers request the external API, which returns a JSON with a list of users. We do a mapping of the data received from the API to return only the data that we will use in the application. In case something goes wrong during the request or the data processing, an exception is thrown with the message “Something went wrong”. Now let’s run the application, go to the path and execute the queries created: /api/graphql GraphQL client Creation of an instance of an Apollo client. 1— import { ApolloClient, InMemoryCache } from "@apollo/client" import { ApolloClient, InMemoryCache } from "@apollo/client"

const client = new ApolloClient({
  uri: process.env.NEXT_PUBLIC_URL_SERVER_GRAPHQL,
  cache: new InMemoryCache(),
})

export default client The client is created with two main properties: and . The uri property is the GraphQL API address to which the client will connect. In this case, we will use the environment variable created earlier that stores the API address. uri cache NETX_PUBLIC_URI_SERVER_GRAPHQL The property is used to store the data that is downloaded from the API in cache. This way, the client can access the data without making a new API query. cache This component provides functionality, which allows an instance of an Apollo client to access all components rendered within it. 2— ApolloPrivider import { ApolloProvider } from '@apollo/client'

import client from "@/graphql/apollo-client"

export default function App({ Component, pageProps }) {
  return (
    <ApolloProvider client={client}>
        <Component {...pageProps} />
    </ApolloProvider>
  )
} Creation of queries in files. 3— .gql : getUser.gql query getUsers {
 users {
  id
  firstName
  lastName
  email
  username
  image
 }
} : searchUser.gql query getSearchUsers($value: String) {
 searchUser(value: $value) {
  id
  firstName
  lastName
  email
  username
  image
 }
} : next.config.js const nextConfig = {
 ...
  webpack: (config, options) => {
    config.module.rules.push({
      test: /\.(graphql|gql)/,
      exclude: /node_modules/,
      loader: "graphql-tag/loader"
    })

    return config
  }
  ...
} In order to use or files in Next.js, it’s necessary to add a webpack configuration in the Nextjs configuration. .graphql .gql Here you can read more about it. Making server-side and client-side requests. 4— : index.js import { useEffect, useRef, useState } from 'react'
import { useLazyQuery, useQuery } from '@apollo/client'

import Head from 'next/head'
import { Button, Container, Grid, Input, Spacer, User, Row, Loading } from "@nextui-org/react"

import GET_USERS from '@/graphql/queries/getUsers.gql'
import SEARCH_USERS from '@/graphql/queries/searchUsers.gql'

export default function Home() {
  const [users, setUsers] = useState([])
  const [searchValue, setSearchValue] = useState('')

  const usersRef = useRef(null)

  const { data, loading, error } = useQuery(GET_USERS)

  const [getSearchedUsers] = useLazyQuery(SEARCH_USERS, {
    fetchPolicy: 'network-only',
    onCompleted(data) {
      setUsers(data.searchUser)
    }
  })

  useEffect(() => {
    if (data) {
      setUsers(data.users)
      usersRef.current = data.users
    }
  }, [data])


  const searchUser = () => {
    getSearchedUsers({
      variables: {
        value: searchValue
      }
    })
  }

  if (error) {
    console.error(error)
    return null
  }

  return (
    <>
      <Head>
        <title>Nextjs and Graphql Setup</title>
        <meta name="description" content="Generated by create next app" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <main >

        <Container css={{ display: 'flex', justifyContent: 'center' }}>
          <Spacer y={2.5} />
          <Row justify="center" align="center">

            <Input
              clearable
              labelPlaceholder="User"
              onClearClick={() => setUsers(usersRef.current)}
              initialValue={searchValue}
              onChange={(e) => setSearchValue(e.target.value)}
            />
            <Button color="gradient" auto onClick={() => searchUser()}>
              Search user
            </Button>
          </Row>

          <Spacer y={2.5} />
          <Row justify="center" align="center">

            {loading
              ?
              <Loading />
              :
              <Grid.Container gap={2} justify="center">
                {users.map(u => (
                  <Grid xs={3}
                    key={u.id}
                  >
                    <User
                      src={u.image}
                      name={`${u.firstName}${u.lastName}`}
                      description={u.email}
                      size="lg"
                      bordered
                      color="gradient"
                    />
                  </Grid>

                ))
                }
              </Grid.Container>
            }

          </Row>
        </Container>
      </main>
    </>
  )
} In the above code, we will use the hook to get the users with the query and then save it in the state. useQuery GET_USERS We also use Apollo’s hook to perform a search on the users when the user clicks on the “Search user” button. When the query is finished we save the results in the state. useLazyQuery That’s it! now we can use graphql server-side and client-side. You can add as many queries and resolvers as you need. The app looks as follows: See the demo here Repo here Conclusion In summary, using GraphQL in a Next.js project can significantly improve the application’s efficiency, flexibility, documentation, security, and scalability. Hopefully, this will serve as a guideline for your future projects. Want to connect with the author? Love connecting with friends all around the world on . Twitter Read more: How to Create a Modern Skeleton Loader in React to Improve User Experience How to Simulate a Backend REST API with json-server for CRUD Development in React Also published . here

Setting up a GraphQL Server and Client in Next.js

Who is this guide for? Self-hosting web content is relevant to small to medium companies, business owners, non-profit organizations and individuals. There is no real limit to who may self-host, but will benefit directly and see immediate results. Small to medium companies will get a fully functioning system that adheres to all current encryption and security protocols, especially the PCI specification. privacy conscious groups Why self-hosting? There are tons of reasons why self-hosting is beneficial, here are some of them: Privacy Enhanced security Customization Lower costs Email hosting This article is about web server hosting, if you are interested about email hosting then please read the article  on . Self-Hosting Your Own Email Server Prerequisites A new server, dedicated or virtual, with internet access A RHEL-based Linux distribution: Alma, Rocky, Oracle or Fedora Server Root access Server hostname Please make sure your server has a fully qualified domain name (FQDN) and the file has the IP of the server point to the FQDN and not the short name. This is a requirement for some tools like OpenDKIM, which will fail to work without an FQDN. /etc/hosts To test if your FQDN is properly setup, run: # hostname -f
server.example.tld If you only see the server name and not the FQDN then use the systemd command to set your FQDN: hostnamectl # hostnamectl set-hostname server.example.tld Step 1 - Required packages The first step is to install some basic packages, use your package manager: dnf for newer versions of EL8/EL9: # dnf install php php-cli php-pdo php-mbstring epel-release unzip wget yum for EL7: # yum install php php-cli php-pdo php-mbstring epel-release unzip wget for Fedora the packages are slightly different: # dnf install php php-cli php-pdo php-mbstring unzip wget Step 2 - Install Aetolos In the second step we’ll install the Aetolos virtual hosting control panel, which only generates configuration files and does not make any other modifications to the system: # wget -O /root/master.zip 'https://gitlab.com/noumenia/aetolos/-/archive/master/aetolos-master.zip'
# unzip /root/master.zip -d /root/
# mv /root/aetolos-master /root/aetolos
# rm -rf /root/master.zip The latest development code can be downloaded from the git repository: git clone 'https://gitlab.com/noumenia/aetolos.git' Step 3 - Enable services Now it is time to choose what services the server will provide. Run Aetolos with the status parameter to get an idea of all the available services: # ~/aetolos/aetolos --status
+---------+--------------+---------+------------+--------------+
| Enabled | Module       | SystemD | Repository | Dependencies |
+---------+--------------+---------+------------+--------------+
| [ ]     | apache       |         |            |              |
| [ ]     | clamav       |         | epel       | postfix      |
| [ ]     | dehydrated   |         |            |              |
| [ ]     | dovecot      |         |            |              |
| [ ]     | haproxy      |         |            |              |
| [ ]     | mariadb      |         |            |              |
| [ ]     | mtasts       |         |            | apache       |
| [ ]     | nsd          |         | epel       |              |
| [ ]     | opendkim     |         | epel       | postfix      |
| [ ]     | opendmarc    |         | epel       | postfix      |
| [✓]     | php          |         |            |              |
| [ ]     | postfix      |         |            |              |
| [ ]     | postgrey     |         | epel       | postfix      |
| [ ]     | spamassassin |         |            | postfix      |
| [✓]     | virtualhost  |         |            |              |
+---------+--------------+---------+------------+--------------+ As this is going to be a self-hosted web server, we are going to enable the services that give us a complete set of features for web hosting: Apache, a web server for responding on ACME requests Dehydrated, a bash script for Let’s Encrypt certificates MariaDB, the database If you have a separate server for email with DKIM signatures, you should also enable OpenDKIM in this server as well. Then share the key among servers for proper signing. Let’s enable these services with Aetolos: # ~/aetolos/aetolos --enable=apache
# ~/aetolos/aetolos --enable=dehydrated
# ~/aetolos/aetolos --enable=mariadb Now we may re-run Aetolos with the status parameter to see the following table: +---------+--------------+---------+------------+--------------+
| Enabled | Module       | SystemD | Repository | Dependencies |
+---------+--------------+---------+------------+--------------+
| [✓]     | apache       | dead    |            |              |
| [ ]     | clamav       |         | epel       | postfix      |
| [✓]     | dehydrated   |         |            |              |
| [ ]     | dovecot      |         |            |              |
| [ ]     | haproxy      |         |            |              |
| [✓]     | mariadb      | dead    |            |              |
| [ ]     | mtasts       |         |            | apache       |
| [ ]     | nsd          |         | epel       |              |
| [ ]     | opendkim     |         | epel       | postfix      |
| [ ]     | opendmarc    |         | epel       | postfix      |
| [✓]     | php          | dead    |            |              |
| [ ]     | postfix      |         |            |              |
| [ ]     | postgrey     |         | epel       | postfix      |
| [ ]     | spamassassin |         |            | postfix      |
| [✓]     | virtualhost  |         |            |              |
+---------+--------------+---------+------------+--------------+ Note the SystemD column which shows most services as . This is not an issue, because we have not configured/started those services, yet. dead Step 4 - Setup Finally, we may run Aetolos setup to install the required RPM packages and generate all the configuration files. We prefer to see the verbose output with the extra parameter. --verbose You will notice a warning about the dehydrated script, which tells us to specify the registration email address for Let’s Encrypt # ~/aetolos/aetolos --verbose --setup
[DEBUG] Check running system
[DEBUG] Detected: AlmaLinux 8.7 (Stone Smilodon)
[DEBUG] Check system memory
[DEBUG] Detected: 460MiB
[DEBUG] Check CPU cores
[DEBUG] Detected: 2
[DEBUG] Check proxy
[DEBUG] Loading Aetolos configuration
[DEBUG] Starting operating system setup
[DEBUG] Checking repository dependencies
[DEBUG] Checking package dependencies
[DEBUG] Installing package: php-fpm
[DEBUG] Checking SELinux requirements
[DEBUG] SELinux: enable httpd_can_network_connect
[DEBUG] SELinux: enable httpd_can_sendmail
[DEBUG] SELinux: enable httpd_read_user_content
[DEBUG] SELinux: enable httpd_enable_homedirs
[DEBUG] SELinux: enable httpd_home_tmp_aetolos.pp
[DEBUG] Checking certificate requirements
[DEBUG] Generating a self-signed certificate
[DEBUG] Certificate: /etc/pki/tls/certs/localhost.crt
[DEBUG] Fullchain: /etc/pki/tls/certs/localhost.fullchain
[DEBUG] Key: /etc/pki/tls/private/localhost.key
[DEBUG] Checking ACME client
[DEBUG] Downloading ACME client: dehydrated 0.7.1
[DEBUG] Installing ACME client under: /root/dehydrated/
[WARNING] ACME registration email set to: postmaster
[WARNING] Please change the ACME registration email by executing: '/root/aetolos/aetolos --verbose --module=dehydrated --registration-email=new-email'
[DEBUG] Checking module dependencies
[DEBUG] Save configuration: apache
[DEBUG] Writing to file: /etc/httpd/conf/httpd.conf
[DEBUG] Writing to file: /etc/httpd/conf.d/ssl.conf
[DEBUG] Writing to file: /etc/sysconfig/htcacheclean
[INFO] System memory: 460MB
[INFO] Allocate 50% of system memory to MariaDB: 230MB
[INFO] 70% of the above usage goes to total thread memory: 161MB
[INFO] The rest 30% goes to server buffers: 69MB
[INFO] MariaDB memory per connection: 18MB
[INFO] MariaDB max connections: 10
[INFO] MariaDB temporary table size: 16MB
[INFO] MariaDB query cache: 16MB
[INFO] Allocate 40% of system memory to Apache/PHP-FPM: 184MB
[INFO] Estimated average number of connections per CPU core: 9
[INFO] Apache StartServers: 1
[INFO] Apache ServerLimit: 2
[INFO] Apache ThreadsPerChild: 18
[INFO] Apache MinSpareThreads: 18
[INFO] Apache ThreadLimit: 22
[INFO] Apache MaxRequestWorkers: 36
[INFO] Apache maximum number of concurrent connections: 108
[DEBUG] Writing to file: /etc/logrotate.d/httpd
[DEBUG] Save configuration: dehydrated
[DEBUG] Writing to file: /root/dehydrated/config
[DEBUG] Writing to file: /root/dehydrated/hook.sh
[DEBUG] Writing to file: /etc/pki/letsencrypt/domains.txt
[DEBUG] Writing to file: /etc/cron.daily/dehydrated.cron
[DEBUG] Save configuration: mariadb
[DEBUG] Writing to file: /etc/systemd/system/mariadb.service.d/limitnofile.conf
[DEBUG] Writing to file: /etc/my.cnf.d/mariadb-server.cnf
[DEBUG] Save configuration: php
[DEBUG] Writing to file: /etc/php.ini
[DEBUG] Writing to file: /etc/php.d/10-opcache.ini
[DEBUG] Save configuration: virtualhost
[DEBUG] Writing to file: /etc/tmpfiles.d/hometmp.conf
[DEBUG] Reloading systemd As per the warning, we add an email address for Let’s Encrypt: # ~/aetolos/aetolos --verbose --module=dehydrated --registration-email=postmaster@example.tld Start MariaDB Unlike other services, MariaDB needs to be started and working, for Aetolos to add virtual hosts and the corresponding database permissions. So lets enable and start MariaDB: # systemctl --now enable mariadb At this point we may secure the MariaDB instance by running: /usr/bin/mysql_secure_installation This requires that you also create the file with the login details for root: /root/.my.cnf [client]
default-character-set="utf8mb4"
user="root"
password='the_password_set_in_the_previous_step' Add virtual hosts Now we are ready to add as many virtual hosts as we like (or as many as the server can handle). Before running any commands, we may take a second to think which virtual hosts will have a prefix subdomain, sometimes we may have a domain like example.tld with a www subdomain (www.example.tld), other times we may not want to use a prefix because we want our email addresses only at the top domain (user@example.tld and not user@www.example.tld). As an example, we will add three virtual hosts, two of them without a subdomain: # ~/aetolos/aetolos --verbose --module=virtualhost --add-virtualhost=example1.tld --no-prefix
[DEBUG] Verify domain: example1.tld
[DEBUG] Add virtual host: example1.tld
# ~/aetolos/aetolos --verbose --module=virtualhost --add-virtualhost=example2.tld --no-prefix
[DEBUG] Verify domain: example2.tld
[DEBUG] Add virtual host: example2.tld
# ~/aetolos/aetolos --verbose --module=virtualhost --add-virtualhost=example3.tld
[DEBUG] Verify domain: example3.tld
[DEBUG] Add virtual host: example3.tld We can now list all virtual hosts: # ~/aetolos/aetolos --module=virtualhost --list-virtualhosts
+----+---------------------+--------------+-------------+----------------+--------+--------------+
| ID | Timestamp           | Virtual host | System user | MariaDB prefix | Parked | Prefix alias |
+----+---------------------+--------------+-------------+----------------+--------+--------------+
| 1  | 2023-01-10 08:51:36 | example1.tld | example1tld | example1       | [ ]    |              |
| 2  | 2023-01-10 08:51:40 | example2.tld | example2tld | example2       | [ ]    |              |
| 3  | 2023-01-10 08:51:45 | example3.tld | example3tld | example3       | [ ]    | www          |
+----+---------------------+--------------+-------------+----------------+--------+--------------+ Each virtual host will “live” isolated within its own home directory, with its own user/group ownership, so lets take a look at our /home: # ls -la /home
total 0
drwxr-xr-x.  5 root        root         63 Jan 20 10:51 .
dr-xr-xr-x. 17 root        root        224 Dec 21  2021 ..
drwx--x--x.  8 example1tld example1tld 159 Jan 10 08:51 example1tld
drwx--x--x.  8 example2tld example2tld 159 Jan 10 08:51 example2tld
drwx--x--x.  8 example3tld example3tld 159 Jan 10 08:51 example3tld Setup After we made modifications with the Aetolos command, we need to generate new configuration files for all the relevant services (Apache, PHP-FPM, Dehydrated, etc). Thus, we execute Aetolos setup one last time. # ~/aetolos/aetolos --setup TLS certificates At this point all services will use the same self-signed certificate, thus it is now a good time to run dehydrated manually to gather all virtual host certificates. Since Aetolos uses the ACME protocol with domain validation via HTTP port 80, we first start our Apache server to service those requests. # systemctl start httpd
# ~/dehydrated/dehydrated --cron --config /root/dehydrated/config --keep-going
# systemctl stop httpd
# ~/aetolos/aetolos --setup Services We may now enable and start all services. # systemctl --now enable httpd httpd@example1.tld httpd@example2.tld httpd@example3.tld mariadb php-fpm
Created symlink /etc/systemd/system/multi-user.target.wants/httpd@example1.tld.service → /usr/lib/systemd/system/httpd@.service.
Created symlink /etc/systemd/system/multi-user.target.wants/httpd@example2.tld.service → /usr/lib/systemd/system/httpd@.service.
Created symlink /etc/systemd/system/multi-user.target.wants/httpd@example3.tld.service → /usr/lib/systemd/system/httpd@.service. You will notice that each virtual host has its own Apache service, this is a feature provided by systemd and allows us to define the virtual hosts into separate systemd services. The parameter will start all services. --now The architecture There should be special mention about the architecture used for hosting websites. For security reasons, each virtual host is isolated within unix accounts stored under their own directory. Public web content should be stored within the directory. /home public_html /home/example1tld                               -> virtual host home
/home/example1tld/etc                           -> email accounts
/home/example1tld/mail                          -> email storage
/home/example1tld/public_html                   -> web content
/home/example1tld/www                           -> symbolic link to public_html
/home/example1tld/tmp                           -> temp directory Aetolos At this point Aetolos has configured the server without any custom modifications, all changes are done on the default configuration files. We may delete Aetolos from the server and continue modifications manually or we may keep Aetolos in case we want to add more virtual hosts in the future. Credits Article photo by Manuel Geissinger from pexels

Stick It to The Man and Self-Host Your Own Web Server

Adhiérase a The Man y autohospede su propio servidor web

Collez-le à l'homme et auto-hébergez votre propre serveur Web

इसे द मैन से चिपकाएं और अपने स्वयं के वेब सर्वर को सेल्फ-होस्ट करें

男に固執し、独自のWebサーバーをセルフホストする

Atenha-se ao homem e auto-hospede seu próprio servidor da Web

Gắn bó với người đàn ông và tự lưu trữ máy chủ web của riêng bạn

坚持到底，自行托管您自己的 Web 服务器

Alluxio provides a comprehensive metrics system for monitoring the status of the Alluxio master, worker and client. Alluxio’s metrics system supports various kinds of metrics, e.g. an embedded JSON sink and the Prometheus sink. Users and developers can easily create a custom sink of Alluxio by implementing the Sink interface. In addition, Alluxio provides a metrics page in web UI showing some key information of Alluxio, such as bytes throughput and storage space. However, if you want more flexible and universal monitoring, additional work is required. This blog will introduce how Tencent uses Prometheus and Grafana to set up a monitoring system for Alluxio in 10 minutes. How Alluxio Metrics System Works The following framework depicts Alluxio’s metrics system. Types of Metrics Alluxio metrics are generated by different sources and consumed by sinks. The metric system polls sources periodically and passes metric reports to sinks. There are two types of metrics. Cluster metrics: aggregated from workers and clients, then calculated by the leading master. Cluster metrics provide snapshots of Alluxio cluster. Process metrics: collected by each Alluxio process, including master metrics, worker metrics, and client metrics. Metrics Naming Patterns In general, metrics of Alluxio follow two naming patterns. The first is for master metrics, which consist of Master, metricName, and some tags (optional). For example, Master.GetFileInfoOps. The second is for non-master metrics, which consists of processType, metricName, tags, and hostnName. For example, below is openExistingFile metrics for worker. The processType is worker, the metricName is openExistingFile, followed by three tags: user, UFS location, and UFS type. The last part is the hostName of worker. The Flow of Metrics from Worker to Master Since the master needs to collect metrics from workers and clients to calculate the cluster metrics, the clients and workers need to report their metrics to the master. Below is a diagram of the flow of metrics from the worker to the master. Workers and clients send the metrics to Alluxio master through the heartbeat. The block on the right is the worker process, and the left is the master process. It goes from the right to the left. The heartbeat process is under the control of BlockMasterSync, and the metrics and other information about the worker are passed to the RpcClient, then the Rpc server receives the heartbeat and processes the metrics from workers by MetricMaster. The metrics are stored in the MetricsStore and later will be aggregated and calculated. Client metrics are handled in a similar manner. Refer to the Alluxio source code for more details. How to Implement a Custom Alluxio Sink Alluxio supports many types of sinks. A sink specifies where the metrics are delivered to. For example, Alluxio has Http JSON sink, which is enabled by default, so we can view dashboards of Alluxio metrics in Alluxio web UI in the JSON format. In addition, Alluxio provides convenient and flexible sink interfaces for developers and users to implement their own sink. Passive Sink and Active Sink Sinks that Alluxio supports are listed below. In general, these sinks can be divided into two categories: passive sink and active sink. The difference between these two kinds of sinks is the way we get the metrics: Active: the left screenshot is the consolesink. If we enable the consolesink, the metrics will be printed into a standard output file, for example, the master.out or worker.out. The consolesink reports the metrics periodically, so you can get the metrics any time you want. From Alluxio’s perspective, it is active sink. Passive: the right screenshot is the HTTP JSON sink, which is the passive sink. A passive sink works as a service. We can get the metrics only when we send the requests to the server. For example, if we access the metrics/json location in the Alluxio worker server, we can get the following metrics in JSON format. How ConsoleSink and Prometheus Sink Work The ConsoleSink structure is shown below. We can find the ConsoleReporter in the ConsoleSink. It schedules the report that reports the metrics on a regular basis. We can see methods of the ScheduledReporter, in the report, that different types of metrics are printed in a specific format. The Prometheus sink operates in a completely different way. There is no ScheduledReporter to report the metrics, so we need to get metrics by ourselves. The passive sink needs to implement the getHandler method, so the master and worker process can start. For example, in the StartServingWebServer method of master process, the Prometheus handler is added to the webserver. We can access the specific location of master web server, then we can get the metrics in the format of Prometheus. E.g. MasterProcess Implement the Sink The first thing we need to do is to determine which kind of sink we want to implement, passive or active. For example, XmlSink of Alluxio prints the metrics to a specific path, so we know that it is an active sink. Just like the ConsoleSink, we need to implement the sink interface, and also construct a XmlReporter to report metrics in XML format. This gives us a custom sink. After that, we need to enable our sink by adding XmlSink class we just defined to metrics.properties. In addition, we can add some properties to our sink in this format. conf/metrics.properties Similarly, if you want to implement a passive sink, you can refer to the JSON sink or Prometheus sink. How to Set Up Monitoring of Alluxio in 10 Minutes Alluxio Web UI Monitor On the metrics tab for Alluxio web UI, we can monitor the state of the Alluxio cluster and get some key information about Alluxio. Even though the dashboard is convenient, it can sometimes be confusing (the screenshot on the right). In addition, if we want more information about Alluxio or a dashboard with more visuals, we will need another monitoring solution, which requires additional effort. We use Prometheus sink to bridge Alluxio and Grafana since both Alluxio and Grafana have good support for Prometheus. First, Prometheus scrapes metrics from Alluxio servers and transform into time-series data and store them. Then Grafana server gets this time series data from Prometheus, after which Grafana web UI will display metrics in dashboards. How to Set Up the Monitoring System It only takes four steps to set up this monitoring: Install and start Prometheus and Grafana server. It is quite simple to follow the tutorials using the default configuration. [ ] Add Alluxio Jobs to Prometheus, which can find Alluxio server and scrape the metrics automatically. In the Grafana part, we provide Grafana dashboard template so we can reuse it to quickly set up the Alluxio dashboard. [ ] Download and import the dashboard template. [ ] Modify variables of the template to make it our own dashboard. [ ] (16:03) is the demo video on how to import the dashboard template. Here We need to add Alluxio Jobs to Prometheus first (refer to Alluxio in the metrics section). Now we add two jobs in Prometheus. One is Alluxio master, and the other is Alluxio worker. Here we need to record the job_name, which is used to import Grafana dashboard. documentation The versions of components in the demo video are as follows: Prometheus Version: 2.22.2 Grafana Version: 7.5.6 Alluxio Version: 2.5.0-3 The following are the services set up in the demo video. There are two nodes in our cluster, worker node and master node: Prometheus Server @ master:9090 Grafana Server @ worker:3000 Alluxio Master @ master Alluxio Worker @ worker As can be seen in the screenshots below, there are 8 live workers in the cluster, and the monitoring system works well, with metrics in different panels. In the dashboard, we also list the labels of different rows. Adding or removing panels can be easily done on the dashboard. Alluxio IO Key Metrics Read Local & Read Remote & Alive workers … Storage Space Used & UFS Space Used … Workers Blocks Cached Blocks & Evicted Blocks … Logical Operations Mount Operations & File Pinned … Alluxio Metadata Operations Block Heartbeat Cost & Get status Cost … AsyncCache Blocks & Operations AsyncCacheSuccessedBlocks & AysncCacheFailedBlocks … Master JVM Memory Master Heap Memory & Total Memory … Summary By introducing Prometheus and Grafana, we have built a more flexible, agile and easy-to-use monitoring system for Alluxio. References Alluxio Documentation: Metrics System Grafana dashboards About the Author Pan Liu Big Data Engineer at Tencent Responsible for distributed computing with a focus on open source projects such as Alluxio and Presto Also published here: https://www.alluxio.io/blog/how-to-set-up-monitoring-system-for-alluxio-with-prometheus-and-grafana-in-10-minutes/

How Tencent uses Prometheus and Grafana to Set Up a Monitoring System in 10 Minutes

The term GitOps was first coined by Weaveworks in a popular article from August 2017. The problem it intends to solve was how to efficiently and safely deploy a Kubernetes application. The main tenants of this philosophy are: Use a Git repository as the single source of truth. Any change is made in the form of a Git commit. When the application state differ from the desired state (that is: what’s in Git), a reconciliation loop detect the drift and try to reach this state.directly from Weaveworks The reason why GitOps is especially suited to deploy cloud native applications is that Kubernetes follows the same declarative way of doing things: You submit a bunch of Kubernetes objects through a declarative document as YAML or JSON Kubernetes Operators process are endlessly evaluating the difference between the submitted objects and their real state in the cluster, adding, modifying or deleting them as needed When you understand the concept, you can apply the GitOps way not only to Kubernetes application but to anything described with code, for example code infrastructure. What is the difference between GitOps and the final deploy step of my CICD pipeline ? Very often your pipeline is triggered by a change in code (if not, it really should be). Therefore, it’s in fact the same starting point as GitOps. Your final pipeline step is then to run a command like kubectl apply. You run an imperative command to reach the desired state. In GitOps, you won’t do this: it’s an external tool that detects the drift in your Git repository and will run theses commands for you. You can think of it as a “pulling” way of doing things. Let’s look into these tools. What tools are available to implement GitOps ? Most commonly used tools are from Weaveworks and . You may find extensive comparisons of both tools but to sum it up: Flux ArgoCD Flux can only observe one repository at a time, meaning you have generally one flux instance running for each application. ArgoCD may observe multiple repositories, comes with a GUI dashboard, may be federated with an identity provider: it’s more enterprise ready. In this article, we will look to implement a GitOps model using ArgoCD. Our GitOps workflow Tools We will implement a GitOps scenario using: ArgoCD as the GitOps tool GitHub Actions as the CICD pipeline Kustomize to describe application deployments Starting point Code is available on . You will find step by step instructions on how to make it work for you by installing a Minikube cluster, ArgoCD and setup the required security tokens. GitHub Application Our application is a simple Go application displaying the good old “Hello World” string. main ( ) PORT = {
	startServer(handler)
} {
	http.HandleFunc( , handler)
	log.Printf( )
	http.ListenAndServe(fmt.Sprintf( , PORT), )
} {
	log.Printf( , r.Header.Get( ))
	host, err := os.Hostname() err != {
		host = }
	resp := fmt.Sprintf( , host)
	_, err = w.Write([] (resp)) err != {
		log.Panicf( , err)
	}
} package import "fmt" "log" "net/http" "os" const 8080 func main () ) func startServer (handler (http.ResponseWriter, *http.Request) func "/" "starting server..." ":%d" nil func handler (w http.ResponseWriter, r *http.Request) "received request from %s" "User-Agent" if nil "unknown host" "Hello from %s" byte if nil "not able to write http output: %s" The associated Dockerfile is quite simple, building the application then running it in a linux container. golang: as build alpine: FROM 1.14 WORKDIR /build COPY . . RUN CGO_ENABLED=0 go build -o hello-gitops cmd/main.go FROM 3.12 EXPOSE 8080 WORKDIR /app COPY --from=build /build/hello-gitops . CMD [ ] "./hello-gitops" Code pipeline Our pipeline uses two jobs: One for running tests, building and pushing the container on Dockerhub The second one will edit the Kustomize patch to bump the expected container tag to the new Docker image and then commit these changes. : Go name on: push: branches: [ master ] jobs: build: name: Build runs-on: ubuntu-latest steps: - name: Set up Go 1. x uses: actions/setup-go@v2 with: go-version: ^1.14 - name: Check out code uses: actions/checkout@v2 - name: Test run: |
        CGO_ENABLED=0 go test ./... - name: Build and push Docker image uses: docker/build-push-action@v1.1.0 with: username: ${{ secrets.DOCKER_USERNAME }} password: ${{ secrets.DOCKER_PASSWORD }} repository: ${{ secrets.DOCKER_USERNAME }}/hello-gitops tags: ${{ github.sha }}, latest deploy: name: Deploy runs-on: ubuntu-latest needs: build steps: - name: Check out code uses: actions/checkout@v2 - name: Setup Kustomize uses: imranismail/setup-kustomize@v1 with: kustomize-version: "3.6.1" - name: Update Kubernetes resources env: DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }} run: |
       cd kustomize/base
       kustomize edit set image hello-gitops=$DOCKER_USERNAME/hello-gitops:$GITHUB_SHA
       cat kustomization.yaml - name: Commit files run: |
        git config --local user.email "action@github.com"
        git config --local user.name "GitHub Action"
        git commit -am "Bump docker tag" - name: Push changes uses: ad-m/github-push-action@master with: github_token: ${{ secrets.GITHUB_TOKEN }} ArgoCD ArgoCD must be configured to observe our Git repository. Configuration is rather straightforward and can be done in the included GUI. You need to specify the relative path of the Kustomize patch to use though. GitOps Magic Note that at the end of the GitHub Actions pipeline, we don’t run any imperative command to deploy our application, we just changed our container version using Kustomize and auto-pushed these changes into our repository. If you do any code change, the pipeline is triggered and a new Docker image is pushed, the container version is updated and ArgoCD should catch the change. Everything should be green by then. Conclusion GitOps is a powerful and intelligible way of making a change to anything. I think it could be considered as the logical continuation of the “* as code” we see everywhere and the massive industry trend to move to more declarative, easier to understand models. Previously published behind paywall at https://medium.com/@emmanuel.sys/how-to-build-a-gitops-workflow-with-argocd-kustomize-and-github-actions-f919e7443295

Creating GitOps Workflow with ArgoCD, Kustomize and GitHub Actions

Marketing Tips for 2024 And Beyond, Or How To Market Smarter And More Efficiently

AI chatbots have truly found their place in today's business technology scene, reshaping how companies engage with customers and becoming an integral part of daily operations. Gone are the days when they were just a futuristic concept; now, these AI-powered chatbots engage in remarkably human conversations, providing round-the-clock support that's reshaping customer service and leaving its mark on various business areas. What's exciting is how they keep getting better at handling all sorts of user queries, constantly improving the user experience. focusing on innovative technology like AI chatbots to create more effective and engaging user interactions, marking a new era where technology and business seamlessly come together. Businesses are embracing this shift, Understanding the Challenges with Current AI Chatbots Even with all the advancements in AI chatbot technology, there are still some kinks to work out that can make the experience a bit frustrating at times. The main issue that pops up is that sometimes, chatbots just don't get what you're trying to say. This usually happens because, let's face it, chatbots aren't perfect at picking up on the little subtleties of language – think idioms, complex sentences, or the way we naturally chat with each other. This can lead to those annoying moments where you have to repeat yourself or reword your question, which can be pretty irritating. Another thing where AI chatbots can drop the ball is in figuring out if you're happy with the answers they're giving. For example, a chatbot might give you a technically correct answer, but it might miss the real worry or feeling behind your question. It's especially noticeable when you're feeling frustrated or confused, and all you get in return are standard, kind of robotic responses. It shows that these chatbots need a bit more emotional smarts. It's not just about understanding our words but also getting the emotions behind them. All this highlights the journey we're still on with AI – the aim isn't just to make chatbots that can talk back but to create ones that get us and connect on a more human level. Techniques for Refining AI Understanding of User Intent and Satisfaction AI development has come a long way, and now we're seeing some cool stuff being used to make AI chatbots better at figuring out what we want and how we feel. It's all about making these chatbots more effective and, well, more human-like. One big thing they're working on is Contextual Understanding. It's like teaching the AI to read between the lines, not just taking our words at face value but getting the whole picture. Say you're chatting with a bot and you keep talking about the same thing - the bot can now follow along and keep up with the conversation. It's smart enough to know if you're still on the same topic, bringing up something from before, or moving on to something new. This makes the chatbot's responses way more on point. Then there's Sentiment Analysis, which is super interesting. It's all about the chatbot picking up on your feelings based on your writing – like the words you choose, how you put together your sentences, or even the punctuation you use. This way, the AI can tell if you're happy, annoyed, or confused and can change how it replies to match your mood. It's not just about giving right answers; it's about giving answers that feel right. Personalization is another cool area. It's like the chatbot gets to know you personally. It remembers your past chats or uses info you've shared to make its responses more about you. So, it might suggest things you like, call you by your name, etc. This makes chatting with a bot feel like a real conversation with a human. All these new tricks mean that AI chatbots are getting better at answering questions and doing it in a way that feels more natural, more understanding, and more tailored to you. It's a big step towards making our interactions with AI more like talking to another person. How Microsoft Copilot is Innovating AI Chatbots Microsoft Copilot is an advancement in AI chatbots, extending beyond the conventional scope of such technologies. It is integrated across Microsoft's range of products, functioning as an AI tool that can handle various tasks. The key feature of Copilot is its ability to adapt to different user requirements, which marks a notable development in its capabilities. Initially launched as Bing Chat, Microsoft Copilot has been expanded to integrate into numerous Microsoft applications. It aids users in various activities, including coding, writing, and image generation, by adapting to their specific needs and understanding the context of their tasks. This represents a significant step in AI technology, particularly contextual understanding and application versatility. In the realm of Microsoft 365, Copilot is utilized to enhance the functionality of productivity software. It assists in activities such as composing emails in Outlook and creating data visualizations in Excel. This demonstrates the potential of AI to simplify and improve the efficiency of common tasks. Microsoft has also developed specialized versions of Copilot. For example, the Security Copilot focuses on cybersecurity, analyzing data to identify and counteract threats. This application of AI in security is indicative of its broader potential. Additionally, Copilot for Service and Sales are tailored for business operations, providing AI-driven customer relations and sales support. Overall, the diverse applications of Microsoft Copilot across different digital interactions and workflows reflect Microsoft's aim to offer AI assistance in various settings. By doing so, Microsoft contributes to the evolution of AI chatbots towards more personalized, context-sensitive, and multifaceted tools. This strategy aims to improve user efficiency and align with the growing expectations for AI technology in various sectors. Align AI's Approach to Analyzing and Monitoring Conversational Data Coxwave's Align AI platform functions in conversational AI by providing tools to businesses for monitoring and analyzing data from AI chatbot interactions. Align AI addresses the challenge of ensuring efficient and user-aligned interactions in the evolving AI technology landscape, particularly with systems like ChatGPT. The platform is designed to manage the occasional discrepancies between the outputs of AI models and their training data, which can affect user satisfaction. Align AI features real-time data ingestion, facilitated through a pre-built software development kit (SDK) and integration with Large Language Model (LLM) toolkits such as Langchain and LlamaIndex. The integration process, which can be completed in under 10 minutes, is advantageous for businesses aiming to swiftly implement and manage AI chat solutions. This capability allows for the prompt collection and analysis of conversational data, to enhance AI chatbot performance and responsiveness. The platform also includes a natural language universal search feature, functioning as a contextual semantic search engine. This enables product teams to use plain English for searches, like locating sessions where user dissatisfaction is evident. The system is designed to efficiently identify relevant conversational logs, quickly resolving specific interaction issues based on user feedback. Additionally, Align AI integrates a data analytics assistant named Copilot, providing a conversational interface for in-depth analysis of conversational data. Copilot's role is to generate insights, recommendations, and metrics to simplify the data analysis process. This allows product teams to process conversational data into actionable insights, potentially improving AI chatbot interactions and user experiences. Google Bard and Conversational AI An artificial intelligence chatbot created by Google, Google Bard is defined by its ability to incorporate data from the internet into its conversational framework. This approach differs from traditional chatbots that typically rely on predefined data. Bard's capability to access current information from the web provides a distinct feature compared to other AI chatbots like ChatGPT and Bing Chat. The core of Google Bard is built on Initially, Bard utilized LaMDA based on Google's Transformer neural network architecture. This architecture is also used in other AI models, such as GPT-3, which is the foundation for ChatGPT. Google's transition to PaLM 2, as announced at Google I/O 2023, reflects its focus on improving Bard's efficiency and performance. Google's Language Model for Dialogue Applications (LaMDA) and its more recent version, PaLM 2. A notable feature of Google Bard is its multimodal search capability, facilitated by integrating Google Lens. This feature lets users incorporate images into their queries, expanding the chatbot's utility for information gathering and learning. Adding image-based responses in late May enhances Bard's ability to provide more comprehensive answers, particularly for queries where visual context is beneficial. Google Bard was initially available to a select group but was later made accessible to the general public, as announced at Google I/O. This move expands the reach of advanced AI technologies to a broader user base. Best Practices for Iterative Testing and User Feedback Incorporation The whole deal with keeping AI chatbots sharp and useful boils down to constant testing and listening to what users say. It's like a never-ending cycle of improvement to make sure these chatbots stay relevant and do a good job of understanding what people need. Creating a solid system for getting feedback is super important. Imagine a chatbot as a student and every piece of feedback as a lesson. Users might rate how well the chatbot did or give specific comments about their chat. This is gold for figuring out how real people use the AI and what they think about it. But it's not just about collecting feedback; you've got to dig into it, really get what it means, and then use it to improve the chatbot. It's a team effort, with AI developers, the folks who design how the chatbot feels, and data whizzes all working together to polish up the chatbot. Then there's this thing called iterative testing. It's not just testing once and calling it a day; it's doing it repeatedly, tweaking things. It's like trying different recipes to see which cake tastes the best. They might do A/B testing, where they try out different versions of the chatbot to see which one hits the mark, or they might set up specific tests with users to pinpoint exactly what needs fixing. It's all about making the chatbot smarter and more in tune with users' wants. There are some cool real-life stories about this stuff working wonders. Like, this big online store used user feedback to make their chatbot better at suggesting products. Boom, happier customers and more sales. Or a telecom company's customer service chatbot that got so much better at understanding what people were asking that it solved more problems, faster. In short, the secret sauce to keeping AI chatbots on their A-game is this cycle of testing, getting feedback, and using that to make constant improvements. It's what makes sure these chatbots are high-tech and get what users need and want.

Building Smarter Chatbots: Enhancing AI Responsiveness to User Needs

What to Expect? Introduction The Basics of Behavioral Economics Common Cognitive Biases in Crypto-Trading. Emotional Influences on Trading Decisions. Behavioral Economics strategies for crypto traders. Case studies and Real-world Applications. Understanding human behavior in the cryptocurrency marketplace is just as important as understanding fundamentals. Why traders make certain decisions and how they can improve their strategies is insights that can be best learned through the field of behavioral economics, which is a hybrid of economics and psychology. With reference to principles of behavioral economics, this article shows how they can be used for making smarter constructive trading decisions within the economy. crypto The Basics of Behavioral Economics Behavioral economics combines psychological insights with economic theory to provide a more nuanced understanding of human behavior relating to financial context, thus making it interesting. On the other hand, traditional economics assumes that people are rational actors and, therefore, make decisions that will maximize their utility. However, behavioral economics acknowledges that humans do not always behave rationally due to various factors that hinder them from making optimal choices. To start with, the core concepts of behavioral economics include . Heuristics act as shortcuts in reasoning that simplify decision-making processes. Although they might be useful, they can also lead to cognitive biases, i.e., systematic thinking errors that affect how individuals make decisions and judgments. For example, some popular heuristics that may lead to such fallacies include the availability heuristic, whereby the individuals assess the likelihood of an event on how easily they recall similar cases, and the representativeness heuristic, where individuals assess the probability of an event by comparing it with a prototype. heuristics and biases are preferences that are based on heuristics. They can have a great impact on trading and even investment decisions. For instance, anchoring bias occurs when individuals rely too heavily on the first piece of information they receive (the “anchor”) when making decisions. In crypto trading, if a trader buys a cryptocurrency at a high price, that price becomes the anchor, and they may be reluctant to sell it at a lower price, even if the market conditions suggest it would be wise to do so. Biases is another key principle of behavioral economics developed by Daniel Kahneman and Amos Tversky. It explains how people value gains and losses differently, leading to inconsistent risk-taking behavior. For example, it is often more likely for someone to take risks when trying to avoid loss rather than making profit. In crypto trading, this is particularly relevant as the fear of missing out on potential gains may prompt traders to hold onto their assets for too long or invest in high-risk ventures without sufficient due diligence. Prospect theory Understanding these basic principles of behavioral economics is essential for crypto traders. It allows them to recognize the psychological traps that can lead to poor trading decisions and to develop strategies to counteract these biases. By doing so, traders can improve their ability to make rational, informed decisions that align with their investment goals and risk tolerance. Common Cognitive Biases in Crypto Trading When we talk about cognitive biases what do we actually mean? Well, Cognitive biases refer to systematic patterns of deviation from norm or rationality in judgment, often resulting in illogical conclusions or decision-making. In the context of , these biases can significantly influence a trader’s actions and may result in recurring errors of judgment and investment. crypto trading is one of the most common cognitive biases that affect traders. It happens when someone has an unreasonable level of belief in his or her ability to predict events or to control events that he or she cannot. This bias may show itself while trading crypto, where a trader tends to think they know more about the market than they actually do, and so can predict price movements, resulting in increased trade volumes and greater risks taken. For example, a trader might believe that against all odds, the losing position can turn into a winner and, therefore, place more funds on it. Overconfidence Bias , as opposed to making gains, is a preference for avoiding losses. Research shows that two times, the positive feeling from gain is roughly the same as the negative one from losing. In this case, behaviors such as hanging on to loss-making trades with the hope that they will bounce back or selling winners early to ‘lock in’ profits are typical patterns for an individual who prefers not to lose money rather than make gains through trading securities. Loss Aversion Bias refers to people’s tendency to seek, interpret, prefer, and retain information that supports their existing beliefs or ideas. In the volatile crypto market, a trader may disregard negative news or market indicators forecasting a slump in anticipation of the continued rise in the market. This can result in a failure to react suitably to market shifts, which may end up with financial losses. Confirmation Bias Other cognitive biases that affect crypto traders include: : This is a cognitive bias that occurs when an individual makes a decision based on the first piece of information they are exposed to. For example, if a trader purchases Bitcoin at a certain price, that price becomes the anchor and even if the market conditions indicate otherwise, it can be hard for the trader to dispose of Bitcoin at lower prices. Anchoring Bias : As its name suggests, this behavior involves doing what others do in the financial markets, especially in crypto trading. In some cases, herd behavior may lead to bubbles followed by crashes in crypto trading, which is very risky. Herd Mentality To fight these biases, traders must have a disciplined trading strategy in place, keep an eye on these common pitfalls, and learn about market trends and psychology over time. Traders who understand and acknowledge these cognitive biases can take deliberate steps to reduce their impact and make more logical trading choices. Section 3: Emotional Influences on Trading Decisions These emotions are very powerful and can influence human actions, and this is even more observable in the case of cryptocurrency trading. In the , traders experience rapid fluctuations with unpredictable outcomes that can evoke strong feelings which may make them act impulsively, disregarding their long-term investment goals. crypto market When the market goes down, or there is some negative news associated with a specific cryptocurrency, instantaneously kicks in. This usually prompts a fight-or-flight response, thereby causing investors to sell off their assets in a panic to avoid further losses. Such behavior only serves to intensify declines in the market and result in big financial losses for those who sell at the bottom. fear On the other hand, immediately takes over during upswings. It makes the traders overly optimistic, ignoring signs of overvaluation or market saturation. Decisions that are motivated by greed often involve exposure to too much risk as they aim at earning high returns leading to significant losses when the markets normalize. Greed Another emotional influence that can make traders make impulsive decisions is (fear of missing out). Therefore, when traders see others making huge profits from an asset that is going up in value, they may feel like there is no time to waste and rush into the market without doing enough research or having a clear investment plan. FOMO To control these emotional influences, it is crucial to develop emotional intelligence. This means being able to identify one’s own emotions, comprehend how they affect decision-making as well as keep them under control. This way, by understanding what triggers them emotionally and responding with reason and logic instead of being overwhelmed by such feelings, traders can remain calm and make better choices. Strategies to enhance emotional intelligence include: Mindfulness can help traders become conscious of their emotions and mental habits that result in reactive trading. Mindfulness practices: : Using stress-reducing exercises like deep breathing, working out and meditating can keep traders’ composure during market instability. Stress management techniques : Creating a group of people involved in this business to talk to and advise each other may balance decisions taken and reduce emotional biases. Support networks By enhancing emotional intelligence and learning techniques for managing emotions, traders are able to make more disciplined and farsighted approaches in the cryptocurrency markets. Section 4: Behavioral Economics Strategies for Crypto Traders Traders exploring the volatile world of cryptocurrency trading often use behavioral economics strategies as their guide. These strategies are meant to assist traders in realizing and mitigating the cognitive biases and emotional influences that result in bad decisions and monetary losses. One method is the application of . A checklist can be constructed from a simple yet powerful tool that ensures no important detail is missed before initiating a trade. Some of the items may include verifying market trends analysis, looking for global economic news that may impact crypto, and reviewing the trade’s risk-reward ratio. By following a checklist step by step, traders will avoid making impetuous decisions and engage in more disciplined trading. checklists Also, keeping is very critical. All trades are recorded in this trading journal, including why each was made, what came out of it, and any teaching it produced. This technique helps traders identify their behavior patterns when trading, recurring biases that affect them regularly, and how they can be improved upon. a trading journal are those that traders use when they set rules to be followed regardless of emotional state or market conditions. A few examples of these include setting predetermined entry and exit points, stop loss orders for reducing potential losses, and well-defined criteria for selecting investments. This ensures that fear and greed are eliminated from the trader’s emotions, making him or her stick to a plan. Pre-commitment strategies Another strategy that can be used is where funds are divided into different accounts for different purposes. For instance, one could allocate a particular section of their portfolio to long-term investments, another fraction to short-term trading, and some cash for high-risk – high-reward opportunities. Because of this, traders can make better choices and refrain from investing too much in one particular asset or trade. mental accounting, is a familiar concept involving spreading investments across different assets in order to lower risks associated with certain investments. In behavioral economics, diversification behaves as an antidote to overconfidence bias since not all trades will be profitable; hence, it is wise to spread risk in investment. Diversification Finally, Crypto traders should prioritize which serve as the most important strategies. Informed persons, on the other hand, can understand biases through the study of behavioral economics and psychology on trading, helping them in decision making. education and continued learning, These behavioral economics strategies can also help crypto traders expand their toolkit in order to make better choices that are logical and they are comfortable with considering their risk tolerance and trading goals. When applied systematically, these measures will ultimately enhance the performance of a trader in terms of trading and make it more enjoyable. Section 5: Case Studies and Real-World Applications The application of behavioral economics in crypto trading is not just theoretical; it has practical, real-world implications that can lead to tangible improvements in trading performance. By examining case studies and analyzing specific trading scenarios, traders can gain insights into how behavioral economics principles can be effectively applied. One of the most notable examples of behavioral economics in action is the Bitcoin bubble of 2017. During this period, the price of Bitcoin soared to nearly $20,000, driven by a surge in public interest and a classic case of market euphoria. Many traders, influenced by herd mentality and FOMO, bought into Bitcoin at high prices without a clear exit strategy. As the market corrected and prices plummeted, those who had not applied behavioral economics principles suffered significant losses. In contrast, traders who recognized the signs of a bubble and adhered to pre-set stop-loss orders were able to protect their capital and even profit from the volatility. The Bitcoin Bubble of 2017: The Use of : Another application of behavioral economics in the real world is incorporating behavioral indicators into algorithmic trading systems. Instead of relying solely on technical analysis, these systems examine market sentiment to inform trading decisions based on psychological patterns. It means that, for instance, a trading algorithm can be coded to each time it observes a sudden surge in posts on social media showing FOMO among retail investors, which might indicate an imminent correction of the price. Algorithmic Trading sell a cryptocurrency For example, behavioral economics can be used to analyze specific trading scenarios. For example, let us say there is a trader who is considering buying a cryptocurrency that has gained 200% in a short span. By virtue of its momentum, traditional economic theory may propose that this asset is worth investing in. In contrast, according to behavioral economics, the trader should take into account the likelihood of overconfidence bias and assess critically if the asset’s fundamentals justify its recent price increase. This way, the trader can choose more wisely and perhaps avoid purchasing at market rallies’ tops. Analyzing Trading Scenarios is a real-world example of how behavioral economics could have improved trading outcomes triggered by the onset of the COVID-19 pandemic. At the bottom of the market, many traders were selling their assets out of panic and fear. People who know behavioral economics, such as markets, tend to overreact to news, as well as the fact that it is important for one to maintain their calmness even under pressure could hold on to their investments or buy more at reduced prices, benefiting from the recovery of the market. The March 2020 market crash By studying these case studies and real-world applications, traders can learn from past successes and mistakes, applying the lessons of behavioral economics to their own trading strategies. With this knowledge, traders can make more rational decisions, manage their emotions effectively, and achieve better financial outcomes in the volatile world of cryptocurrency trading. The Future of Trading with Behavioral Economics The integration of behavioral economics into the future of trading is poised to revolutionize the way decisions are made in the financial markets, particularly within the realm of cryptocurrency. As we look ahead, the potential for behavioral economics to enhance automated trading systems and artificial intelligence (AI) is immense, promising a new era of trading that is more attuned to the nuances of human psychology. The future of trading is likely to witness a substantial rise in the use of automated trading systems and AI informed by behavioral economics. These systems will be built to analyze large amounts of market data such as price movements, trading volumes and news sentiment, but will also consider the psychological factors that affect trader behavior. These systems can then go ahead to carry out trades based on models that predict how traders are likely going to react under different market conditions and exploit human biases and emotional responses. Automated Trading Systems and AI Advancements in behavioral analytics will enable trading platforms to provide real-time insights into trader sentiment, potentially predicting market movements based on collective behavior. This could lead to the development of tools that alert traders to potential biases in their decision-making process or warn them about market conditions leading to irrational trading behavior. Behavioral Analytics : The future may bring trading platforms that will offer personalized trading experiences suited to individual traders’ psychological profiles. For instance, a platform could use a trader’s past data to identify behaviors linked to overconfidence or loss aversion and then adjust its interface and recommendations accordingly. Trading experiences made personal With the expansion of behavioral economics, we should anticipate an increase in educational materials and training programs focused on psychological aspects of trade. Consequently, traders will be empowered with information that will help them to spot biases, thus enabling them to make more rational investment decisions. Education And Training Regulatory Implications Additionally, regulation could also be affected by behavioral economics integrated into trading. For example, regulators can apply the principles of behavioral economics in order to develop policies that can shield traders from some of the common mistakes such as making hasty conclusions based on very little information or falling prey for fraudulent schemes which exploit their mental weaknesses. Conclusion In summary, traveling through the and taking into account behavioral economics shows that the mind of a crypto trader is full of psychological aspects influencing trading decisions. This article has explored cognitive biases in depth, emotions’ influence, and a number of approaches that could be used for making better judgments while coping with cryptocurrency trading. thoughts of a crypto trader The key takeaways from this exploration are clear: , such as overconfidence, loss aversion, and confirmation bias, can lead to systematic errors in judgment and must be recognized and mitigated. Cognitive biases , including fear, greed, and FOMO, can cloud judgment and must be managed through emotional intelligence and self-awareness. Emotional influences , such as checklists, trading journals, and pre-commitment strategies, provide a framework for disciplined decision-making. Behavioral economics strategies demonstrate the practical benefits of applying behavioral economics to trading, offering valuable lessons for traders. Case studies and real-world applications The future of trading with behavioral economics is bright, with potential advancements in automated trading systems, AI, and personalized trading experiences that cater to individual psychological profiles. One must apply the knowledge acquired through behavioral economics, refine strategies, and be aware of psychological pitfalls leading to less profitable transactions. If the field of behavioral economics is changing, then a dealer should also change his approach to it by studying new approaches and instruments for decision-making. However, this is not the end of the journey for those who want to know more about psychology and finance. This is an ongoing exploration of behavior economics that calls for traders to continue learning, reading more research, and engaging in discussions that question the traditional paradigms of trading. It’s time to integrate the principles of behavioral economics into your cryptocurrency trading with a view to making intelligent decisions.

SMARTSERV

smartserv.io

-- employees

Since n.d.

COMPANY RANKING

SMARTSERV

EVERGREEN INDEX #9409

Representing this company? Click here to claim and customize this page!

SmartServ WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

SMARTSERV

smartserv.io

-- employees

Since n.d.

COMPANY RANKING

SMARTSERV

EVERGREEN INDEX #9409

RELATED COMPANIESRANK

STORIES ABOUT SMARTSERV

Representing this company? Click here to claim and customize this page!

SmartServ WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!