Linkr

linkr

We are constantly thinking of ways ... ... We&#x27;ve launched at #1🏅 on Product Hunt 🥳 Thank you for the support! Linkr is <strong>an all-in-one scaling and monetization platform for creators</strong>....

Linkr | LinkedIn

The All-in-One Monetization Platform for Creators and Brands! You can create your link-in-bio, grow your following, monetize creativity, and prosper with <strong>Linkr</strong>.com.

Linkr: The All-in-One Monetization Platform for Creators and Brands.

<strong>linkr</strong> network | 1,272 followers on LinkedIn. Influencer marketing toolbox. Say goodbye to manual processes &amp; hello to streamlined influencer marketing campaigns! | Craft Influencer campaigns that empower your brand&#x27;s growth journey with AI-driven influencer recommendations, our personally verified ...

linkr network | LinkedIn

Join 25M+ people and link to everything you create, share and sell online. All from the one bio link.

Link in bio tool: Everything you are, in one simple link | Linktree

We provide comprehensive solutions, application development and cloud service consulting, bringing more possibilities for clients’ business opportunities.

Home | LINKR Limited

<strong>Linkr</strong>.in | 69 followers on LinkedIn. Share multiple links in one custom link and on one landing page perfect for any bio. | An online link management tool, where you can share multiple links in one link and on one landing page. Create a personalized profile, with a custom link created through ...

Linkr.in | LinkedIn

Information on valuation, funding, cap tables, investors, and executives for <strong>Linkr</strong>. Use the PitchBook Platform to explore the full profile.

Linkr Company Profile: Valuation & Investors | PitchBook

<strong>Linkr</strong>.in is free platform to add multiple links in one link and perfect for any social media profile or bio.

Linkr.in - Crunchbase Company Profile & Funding

1 billion members | Manage your professional identity. Build and engage with your professional network. Access knowledge, insights and opportunities.

A leading influencer marketing platform fostering brand growth, content creation, and impactful collaborations

About us | linkr network

LINKR of things

Get an edge on the competition with testing solutions from Link Engineering <strong>Company</strong>. We provide superior quality and customized equipment testing services that are tailored to meet your needs. Visit our website to learn more about how we can help you get ahead!

Link Engineering Company | Equipment, Testing & Support

Designed to engage and grow communities around topics of interest, <strong>Linkr</strong> is the go-to social LMS for education orgs, training <strong>companies</strong> and academic programs worldwide.

Linkr is a Social LMS that builds communities

Linkr Inc. | LinkedIn

<strong>Linkr</strong> all-in-one creator monetization platform: bio link, store, post for fans

Linkr: Link in Bio for Creator - Apps on Google Play

Link Group provides record keeping technology and information solutions, underpinned by our investment in technology, people and processes, to deliver active intelligence for <strong>companies</strong> and large asset owners and trustees across the globe.

Link Group

: Live Demo https://dlitsman.github.io/document-pip/ The Picture-in-picture API has been available in most browsers for quite some time. However, the main downside was that developers have very limited control over custom controls and the look and feel of it, as it only allows to use Video element as a PiP element. This forces developers to use canvas hacks for any custom UI. Recent updates in Chrome 116 change that by adding support. This creates new possibilities for creating a much richer UX. At the time of writing this article, this feature is supported only in Chrome and Edge. However, hopefully, other browsers will also add support soon. Document Picture-in-Picture API API Let's start by looking at the browser API before adding integration. For proper integration, we need to support three main operations: opening a window, closing and detecting a closed event, and detecting the feature itself. React API for opening picture-in-picture windows is very similar to the one you can use for regular . window.open() However, there are some important differences: The Picture-in-Picture window floats on top of other windows. The Picture-in-Picture window never outlives the opening window. The Picture-in-Picture window cannot be navigated. The Picture-in-Picture window position cannot be set by the website. You can check more details and full API about raw implementation in . Below, let's review the core operations we identified before. this great article 1. Opening To open new window const pipWindow = await documentPictureInPicture.requestWindow({
    width: 500, // optional
    heithg: 500, // optional
});

// You have full control over this PiP now
pipWindow.document.body.innerHTML = 'Hello from PiP'; It is important to note that you can only open this window in response to use interaction ( ); otherwise, you will get this error NOTE: User Activation DOMException: Failed to execute 'requestWindow' on 'DocumentPictureInPicture': Document PiP requires user activation 2. Closing You can listen to the event to detect when the PiP window is closing. For example, in case a user decides to close the PiP window. pagehide pipWindow.addEventListener("pagehide", (event) => {
    // do something when pip is closed by the browser/user
}); You can also decide to close the window at any moment programmatically: pipWindow.close(); 3. Detecting feature To detect if current runtime supports this API you can use this check: if ('documentPictureInPicture' in window) {
  // Feature supported
} Implementing Document Picture-in-Picture in React In the example above, we did some manual manipulations with pipWindow document DOM elements. This might be error-prone and hard to support. Alternatively, React can render the window's content and add interactivity. Especially if you already have React in the app itself. Let's dive into the code and build React components that will help us render custom components inside a PiP window. Create context We need a single source of truth to keep track of the existing open window, detect support of the feature in a browser, callbacks to open a window, etc. To make it easier to consume, we can make a that will store this information and make it available for other components in our app. Context type PiPContextType = {
  isSupported: boolean;
  pipWindow: Window | null;
  requestPipWindow: (width: number, height: number) => Promise<void>;
  closePipWindow: () => void;
};

const PiPContext = createContext<PiPContextType | undefined>(undefined); Now, let's create a Provider that will implement this API. type PiPProviderProps = {
  children: React.ReactNode;
};

export function PiPProvider({ children }: PiPProviderProps) {
  // Detect if the feature is available.
  const isSupported = "documentPictureInPicture" in window;

  // Expose pipWindow that is currently active
  const [pipWindow, setPipWindow] = useState<Window | null>(null);

  // Close pipWidnow programmatically
  const closePipWindow = useCallback(() => {
    if (pipWindow != null) {
      pipWindow.close();
      setPipWindow(null);
    }
  }, [pipWindow]);

  // Open new pipWindow
  const requestPipWindow = useCallback(
    async (width: number, height: number) => {
      // We don't want to allow multiple requests.
      if (pipWindow != null) {
        return;
      }

      const pip = await window.documentPictureInPicture.requestWindow({
        width,
        height,
      });

      // Detect when window is closed by user
      pip.addEventListener("pagehide", () => {
        setPipWindow(null);
      });

      // It is important to copy all parent widnow styles. Otherwise, there would be no CSS available at all
      // https://developer.chrome.com/docs/web-platform/document-picture-in-picture/#copy-style-sheets-to-the-picture-in-picture-window
      [...document.styleSheets].forEach((styleSheet) => {
        try {
          const cssRules = [...styleSheet.cssRules]
            .map((rule) => rule.cssText)
            .join("");
          const style = document.createElement("style");

          style.textContent = cssRules;
          pip.document.head.appendChild(style);
        } catch (e) {
          const link = document.createElement("link");
          if (styleSheet.href == null) {
            return;
          }

          link.rel = "stylesheet";
          link.type = styleSheet.type;
          link.media = styleSheet.media.toString();
          link.href = styleSheet.href;
          pip.document.head.appendChild(link);
        }
      });

      setPipWindow(pip);
    },
    [pipWindow]
  );

  const value = useMemo(() => {
    {
      return {
        isSupported,
        pipWindow,
        requestPipWindow,
        closePipWindow,
      };
    }
  }, [closePipWindow, isSupported, pipWindow, requestPipWindow]);

  return <PiPContext.Provider value={value}>{children}</PiPContext.Provider>;
} To make it easier to consume this Context we can also introduce helper hook export function usePiPWindow(): PiPContextType {
  const context = useContext(PiPContext);

  if (context === undefined) {
    throw new Error("usePiPWindow must be used within a PiPContext");
  }

  return context;
} Mounting Now, once we have access to pipWindow, we can render it using React API. Since is not part of our DOM tree that React manages, we need to use API to render it to different DOM elements. pipWindow createPortal Let's create a component that we can use to render inside the newly created Document Picture-in-Picture window. PiPWindow import { createPortal } from "react-dom";

type PiPWindowProps = {
  pipWindow: Window;
  children: React.ReactNode;
};

export default function PiPWindow({ pipWindow, children }: PiPWindowProps) {
  return createPortal(children, pipWindow.document.body);
} You can now use it in any component. This is a minimal example: function Example() {
  const { isSupported, requestPipWindow, pipWindow, closePipWindow } =
    usePiPWindow();

  const startPiP = useCallback(() => {
    requestPipWindow(500, 500);
  }, [requestPipWindow]);

  const [count, setCount] = useState(0);

  return (
    <div>
      {/* Make sure to have some fallback in case if API is not supported */}
      {isSupported ? (
        <>
          <button onClick={pipWindow ? closePipWindow : startPiP}>
            {pipWindow ? "Close PiP" : "Open PiP"}
          </button>
          {pipWindow && (
            <PiPWindow pipWindow={pipWindow}>
              <div
                style={{
                  flex: 1,
                  textAlign: "center",
                }}
              >
                <h3>Hello in PiP!</h3>
                <button
                  onClick={() => {
                    setCount((count) => count + 1);
                  }}
                >
                  Clicks count is {count}
                </button>
              </div>
            </PiPWindow>
          )}
        </>
      ) : (
        <div className="error">
          Document Picture-in-Picture is not supported in this browser
        </div>
      )}
    </div>
  );
} This will render the Document Picture-in-Picture with our custom component. You can easily add any custom styles or logic there. You can find complete source code and slightly more advanced examples in this repo: . It shows how to render a custom dynamic component that shares a state with a root window. https://github.com/dlitsman/document-pip : Live Demo https://dlitsman.github.io/document-pip/ Conclusion Document Picture-in-Picture is an excellent addition to the available APIs browsers provide. It opens new UX possibilities for different domains of apps, such as video conferencing, productivity, and more. In this article, I've shown how this API can be integrated with modern React using standard Context and Portal API. I've omitted the error handling part for clarity, but this should be trivial to implement.

How to Document Picture-in-Picture in React (with Typescript)

I've been a fan of for years. Reveal.js is a web-based presentation framework that makes it (mostly) easy to create slides with just basic HTML. Reveal.js many I don't mind Powerpoint at all, and it's incredibly powerful, but when I'm presenting on web topics (which is, usually, 99% of the time), I don't like the experience of "alt-tabbing" from a running Powerpoint to code or browser tabs. Reveal.js helps me avoid that. Using Reveal (I'm getting tired of typing the dot jay ess) is relatively simple. You add a script tag. You add two link tags for CSS (one for the core CSS and one for a theme), and then start writing HTML. The tag is used for each slide. Here's an example of how easy it is, from their docs: section <html>
  <head>
    <link rel="stylesheet" href="dist/reveal.css">
    <link rel="stylesheet" href="dist/theme/white.css">
  </head>
  <body>
    <div class="reveal">
      <div class="slides">
        <section>Slide 1</section>
        <section>Slide 2</section>
      </div>
    </div>
    <script src="dist/reveal.js"></script>
    <script>
      Reveal.initialize();
    </script>
  </body>
</html> In the snippet above, you can see the two tags representing each slide. There's quite a bit to it, and if you want to see more, check out their , but for today, I was curious if I could simplify the creation of Reveal presentations with web components. Here's what I came up with. section demo Version One First, I'll share the HTML I wanted to use. I actually wrote this first and then began building the web component so I could see it update itself. <reveal-preso theme="beige">
	<section>Slide 1b</section>
	<section>Slide 2</section>
	<section>Slide 3</section>
	<section data-background-color="aquamarine">
		<h2>🍦</h2>
	</section>
	<section data-background-image="https://placekitten.com/800/800">
		<h2>Image</h2>
	</section>	
</reveal-preso> My HTML makes use of the web component, , and supports a attribute. Inside the component are a set of tags for the slides. (As an FYI, I could have also built a child tag, and I do that in my next post!) I don't have any script or link tags at all. reveal-preso theme section reveal-slide will Now, let's look at the component definition. class RevealPreso extends HTMLElement {
	constructor() {
		super();
	}
	
	connectedCallback() {

		this.theme = 'black';
		if(this.hasAttribute('theme')) {
			this.theme = this.getAttribute('theme');
		}

		let currentHTML = this.innerHTML;
		this.innerHTML = `
<div class="reveal">
	<div class="slides">
		${currentHTML}
	</div>
</div>
		`;
		
		// load reveal.js
		const script = document.createElement('script');
		script.type = 'text/javascript';
		script.async = true;
		script.src = 'https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/reveal.js';
		document.head.appendChild(script);
		
		const link = document.createElement('link');
		link.rel = 'stylesheet';
		link.type='text/css';
		link.href = 'https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/reveal.min.css';
		document.head.appendChild(link);

		const theme = document.createElement('link');
		theme.rel = 'stylesheet';
		theme.type='text/css';
		theme.href = `https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/theme/${this.theme}.min.css`;
		document.head.appendChild(theme);
		
		script.addEventListener('load', () => {
			Reveal.initialize();
		});

	}
}

if(!customElements.get('reveal-preso')) customElements.define('reveal-preso', RevealPreso); As you can see, this is relatively simple. My rewrites the inner HTML such that it's wrapped with the that Reveal expects. I then dynamically load all three resources - my JavaScript and both CSS resources. connectedCallback divs I've got an event listener on the script such that when it's been loaded, I can initialize the presentation. From what I could see (via Googling and Stack Overflow), there are no for CSS scripts. I saw a few suggested workarounds, but I decided to keep it simple and just worry about the JavaScript resource. I accept that may be problematic. onload One more issue - my code checks for the theme argument one time only. If you were to change it via JavaScript later, it would not pick up on that. (If I may be so bold as to suggest a best practice here, I'd probably suggest you have code to recognize changes to attributes or clearly document what's not going to work.) Here's how it looks: always https://codepen.io/cfjedimaster/pen/MWPJgMJ?embedable=true Personally, I think this is pretty cool! But notice that it expects the web view. That's the default for Reveal and probably how most people would use it, but I really wanted to see if it was possible to Reveal along with other web content. Here's how I did that. entire embed Version Two First, I checked the docs. I had only ever used Reveal as a full web view presentation, and I didn't know if the framework itself supported it. Turns out, it absolutely has an mode. There's also support for presentations. embedded multiple embedded This requires two things - a slight change to how you initialize the Reveal object and supplying specific dimensions of the container holding your presentation. I began by modifying my HTML a bit: <h2>Preso</h2>

<p>
	Here is my preso. It brings all the boys to the yard.
</p>

<reveal-preso height="700px" theme="dracula">
	<section>Slide 1b</section>
	<section>
		<h2>Plan</h2>
		<ul>
			<li class="fragment">Phase One - Collect Underpants</li>
			<li class="fragment">Phase Two - ?</li>
			<li class="fragment">Phase Three - Profit</li>
		</ul>
	</section>
	<section>Slide 3</section>
	<section data-background-color="aquamarine">
		<h2>🍦</h2>
	</section>
	<section data-background-image="https://placekitten.com/800/800">
		<h2>Image</h2>
	</section>	
</reveal-preso>

<footer>
End of page.
</footer> I've got some basic crap on top and bottom, and in the tag, I've added a . My component is going to support both and , but it will default both. Now, let's look at the updated component: reveal-preso height height width class RevealPreso extends HTMLElement {
	constructor() {
		super();
	}
	
	connectedCallback() {
		console.log('connected callback called');
		
		// defaults
		this.width = '100%';
		this.height = '500px';
		this.theme = 'black';
		if(this.hasAttribute('width')) {
			this.width = this.getAttribute('width');
		}
		if(this.hasAttribute('height')) {
			this.height = this.getAttribute('height');
		}
		if(this.hasAttribute('theme')) {
			this.theme = this.getAttribute('theme');
		}

		let currentHTML = this.innerHTML;
		this.innerHTML = `
<div class="reveal" style="width: ${this.width}; height: ${this.height}">
	<div class="slides">
		${currentHTML}
	</div>
</div>
		`;
		
		// load reveal.js
		const script = document.createElement('script');
    script.type = 'text/javascript';
    script.async = true;
		script.src = 'https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/reveal.js';
		document.head.appendChild(script);
		
		const link = document.createElement('link');
		link.rel = 'stylesheet';
		link.type='text/css';
		link.href = 'https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/reveal.min.css';
		document.head.appendChild(link);

		const theme = document.createElement('link');
		theme.rel = 'stylesheet';
		theme.type='text/css';
		theme.href = `https://cdnjs.cloudflare.com/ajax/libs/reveal.js/4.5.0/theme/${this.theme}.min.css`;
		document.head.appendChild(theme);

		script.addEventListener('load', () => {
		 Reveal(this.querySelector( '.reveal' ), {
				embedded: true,
				keyboardCondition: 'focused' // only react to keys when focused
		 }).initialize();
		
		});

	}
}

if(!customElements.get('reveal-preso')) customElements.define('reveal-preso', RevealPreso); I've updated the code to look for and now and default both. When I rewrite the inner HTML content, I include those values. Lastly, I changed how I initialize the presentation. You can see this in action here: height width https://codepen.io/cfjedimaster/pen/GRYrRmK?embedable=true There are still things I'd tweak here. I'd definitely add support for changing the height and width. Reveal itself also supports recognizing changes to its size. One note - I did do a quick test with 2 presentations on the page, and it worked, but it only shows one theme which I believe there is no workaround as Reveal expects only one theme CSS. It may be possible, but I'm not sure. Next Version? As I said earlier, I want to iterate on this one more time. I want to create a child tag, (or perhaps something shorter) and look into importing the tag from another JavaScript resource. reveal-slide I also want to support dynamically changing the height and width. I'll work on this tomorrow or later this month. As always, let me know what you think!

How to Create a Web Component for Reveal.js

Reveal.js এর জন্য কিভাবে একটি ওয়েব কম্পোনেন্ট তৈরি করবেন

So erstellen Sie eine Webkomponente für Reveal.js

Reveal.js용 웹 구성 요소를 만드는 방법

Reveal.js için Web Bileşeni Nasıl Oluşturulur

This article will not guide you through the process of setting up a virtual environment and installing FastAPI to build a to-do application. Instead, it will offer a new perspective, If you have experience with using FastAPI, for creating backend systems. In the past, you may have performed database queries within your API view or business domain module. However, it is recommended to stop this practice. The repository pattern is a better option as it promotes writing cleaner code and avoids potential issues. In this article, I will explain the reasons for using this design pattern and the advantages it brings. Introduction A repository pattern is an interface where data access logic is stored. To put it simply, the beautiful idea behind using a repository pattern is to decouple the data access layer (database) from the service access layer (domain) of the application. CRUD (create, read, update, delete, etc) operations are done through methods without having to worry about database connections, commands, etc. We will be building a simple URL shortener for the sake of this article. You will find the complete code of the project on my GitHub; you must watch closely to see how incredibly awesome RP (repository pattern) is. In our models, we have the following code: # Stdlib Imports
from datetime import datetime

# SQLAlchemy Imports
from sqlalchemy import Column, String, Integer, DateTime

# Own Imports
from config.database import Base, DATABASE_ENGINE


async def create_tables():
    Link.metadata.create_all(bind=DATABASE_ENGINE)


class Link(Base):
    __tablename__ = "links"

    id = Column(Integer, primary_key=True, index=True)
    original = Column(String)
    shortened = Column(String(4))
    date_created = Column(DateTime, default=datetime.now)
    date_modified = Column(DateTime, onupdate=datetime.now)

    def __str__(cls) -> str:
        """
        `__str__` is a special method that returns a string representation of an object.

        :param cls: The class object
        :return: The shortened version of the original link
        """
        return cls.shortened.__str__() For the sake of the readers that are new to FastAPI, I will quickly go over  what and does. The async method is responsible for creating the database tables of the defined links class. We are defining the necessary fields (columns) we want to have in our links table. create_tables Link create_tables Next would be the module called , this is where we are going to create the interface where our data access logic is stored. We have the following code: repository.py # Stdlib Imports
from typing import List

# SQLAlchemy Imports
from sqlalchemy.orm import Session

# Own Imports
from config.deps import get_db
from shortener.models import Link


class LinkRepository:
    """Repository responsible for performing operations (CRUD, etc) on links table."""

    def __init__(self) -> None:
        self.db: Session = get_db().__next__()

    async def create(self, original: str, shortened: str) -> Link:
        """
        This method is responsible for creating a new link object.

        :param original: original url link
        :param shortened: shortened url link

        :return: the link object
        """

        link = Link(original=original, shortened=shortened)

        self.db.add(link)
        self.db.commit()
        self.db.refresh(link)

        return link

    async def get(self, skip: int, end: int) -> List[Link]:
        """
        This method retrieves a list of links objects.

        :param skip: The number of links to skip
        :type skip: int

        :param end: The number of links to retrieve
        :type end: int

        :return: A list of link objects
        """

        links = self.db.query(Link).offset(skip).limit(end).all()
        return links

    async def get_code(self, code: str) -> Link:
        """
        This method retrieves a link object that matches the code.

        :param code: The shortened code of the link
        :type code: str

        :return: The link object
        """

        link = self.db.query(Link).filter_by(shortened=code).first()
        return link


link_repository = LinkRepository() To begin using our repository class; we need to initialize it. def __init__(self) -> None:
    self.db: Session = get_db().__next__() The purpose of this method is to initialize an instance of the class by creating a database session and storing it in an instance variable . By doing this, the database session will be created and stored in the instance of the class when the class is instantiated and will be available for use throughout the lifetime of the instance. self.db is a function that is responsible for creating a database session, yielding it, and rolling back the transaction If an exception occurs during the database operation, the function will catch the exception and call the method to rollback the transaction. This ensures that any changes made to the database during the transaction are undone in case of an error; and the block of the function will close the session using the method, regardless of whether an exception was raised or not. get_db db.rollback() finally db.close() The code for this function is as follows: # Own Imports
from config.database import SessionLocal


def get_db():
    """
    This function creates a database session,
    yield it to the get_db function, rollback the transaction
    if there's an exception and then finally closes the session.

    Yields:
        db: scoped database session
    """

    db = SessionLocal()
    try:
        yield db
    except Exception:
        db.rollback()
    finally:
        db.close() The method is responsible for creating a new object with the given original URL link and shortened code. After which it stores it in the variable. Then, the method adds the link to the database by calling . create Link link self.db.add(link) Next, the method commits the changes to the database by calling . The method is then called with the object as an argument to refresh the state of the link in the database. Finally, the method returns the object to the caller. self.db.commit() refresh link link The method is responsible for retrieving a list of objects from the database. The method creates a query to retrieve objects from the database using the statement. The method is then called on the query to specify the number of links to skip, and the method is called to specify the number of links to retrieve. Finally, the method is called on the query to retrieve all the links that match the criteria. get Link Link self.db.query(Link) offset limit all The is responsible for retrieving a single object. The method creates a query to retrieve a object from the database using the statement. The method is then called on the query to specify the criteria for retrieving the link, in this case, the shortened code. Finally, the method is called on the query to retrieve the first link that matches the criteria. get_code Link Link self.db.query(Link) filter_by first In summary, the methods provide a convenient and asynchronous way of doing a certain thing in the database, be it; creating and storing new objects in the database, or to retrieve a list of objects from the database or to retrieve a single object while ensuring that the database session is properly managed and the transaction is committed if there are no exceptions. Link Link Link Now that you understand what is going on, let’s move on to our services access layer; this is where the domain logic is stored. We have the following code: # Stdlib Imports
import random
import string

# FastAPI Imports
from fastapi.responses import RedirectResponse

# Own Imports
from shortener.repository import link_repository, Link


async def shorten_link() -> str:
    """
    This function returns a random string of 4 characters.

    :return: A string of 4 random letters.
    """
    
    shrt_str = "".join(random.choice(string.ascii_letters) for i in range(4))
    return shrt_str


async def create_shortened_link(original: str) -> Link:
    """
    This function creates a shortened link for the given original link.

    :param original: str - the original link that we want to shorten
    :type original: str

    :return: A Link object
    """

    shortened_link = await shorten_link()
    link = await link_repository.create(original, shortened_link)
    return link


async def redirect_to_original_link(code: str) -> str:
    """
    This function takes a code and returns the original link.

    :param code: str - the code that was generated by the shortener
    :type code: str

    :return: redirect to original link
    """
    
    link = await link_repository.get_code(code)
    return RedirectResponse(link.original) If you take a look at the functions and , we are accessing the and methods in our repository interface. We have eliminated writing database queries in our service layer, making our code clean and quick to debug. create_shortened_link redirect_to_original_link create get_code Advantages of Using Repository Pattern Using repository design patterns offers several advantages, including: Facilitating the testing of your application's logic Reducing the occurrence of duplicated database operations Central management of the database layer, enabling the implementation of access policies with ease The ability to define strong annotations for domain entities. Final Thoughts In this article, we explained the benefits of using the repository design pattern in software development. The repository pattern separates the data access layer from the service access layer in an application. This leads to a cleaner and more organized code base, and reduces duplicated database operations. We used a simple URL shortener as an example to illustrate the implementation of the repository pattern. The code demonstrates how to create a database table and how to store data access logic in a repository class. Find the complete code to this example . here

Adopting the Repository Pattern for Enhanced Backend Development With FastAPI

ChatGPT is a large language model developed by OpenAI that allows the automatic generation of text based on initial input. In this article, we'll explore how to use ChatGPT to create high-quality content quickly and efficiently. Introduction to ChatGPT ChatGPT is a Transformer-like language model pre-trained on a large amount of text on the internet. With this training, the model can generate coherent and plausible text in response to initial input. How to use ChatGPT To use ChatGPT, you need to log in generation provided by OpenAI. Once logged in (either by email with various social accounts such as Google), it will be possible to enter an initial input and automatically generate the desired text. at the interface It is important to note that ChatGPT works best with inputs of adequate length and that the text generated can have variable quality depending on the input provided. Examples of using ChatGPT Such a model allows it to be integrated into different fields and areas as with the right input information, it is possible to expand the conversation with this "AI", and below are some interesting areas: Generation of product descriptions for e-commerce, by entering the basic information of the product, we can obtain a better and more in-depth description of the same Creation of blog articles, a function appreciated by many and which allows you to have a basic structure of the article, which we will then add, modify and edit the same to make it better Generation of automatic responses for chatbots, very useful for obtaining a wide range of responses to be pasted into the chatbots used on the site to help the visitor with doubts and frequently asked questions Advertising copywriting is also excellent for marketing as it can take advantage of its skills to help us create advertising and marketing in seconds and with different nuances for every type of need Limitations of ChatGPT Despite its great potential, ChatGPT has some limitations. In particular, the model cannot generate original content and cannot wholly replace human creativity. Also, the template may cause implausible or inappropriate text in some cases. The secret plugin for Chat GPT Now that we have a first smattering of what ChatGPT is, the time has come to talk about a recent plugin for this chat that allows you to manage and already have various interesting models and templates just a click away, allowing us to create content and more at depending on the model chosen. This plugin, which is a browser extension, was made by Christoph C. Cemper, who started working in the internet marketing industry as SEO and Link Builder in 2003. He started developing SEO software for internal use in 2006. In 2009, Christoph launched his popular SEO tools like LinkResearchTools in the SaaS model. When the famous Google Penguin update changed the rules of SEO in 2012, Christoph launched Link Detox, a software to find risky links in a website's backlink profile. Christoph has been speaking and writing about link risk management since early 2011 and introduced the technology and formal process for ongoing link checks in 2012 as well as the proactive removal and "disavow" of bad links, as well as URL inspector. But only recently, to be exact on January 8, 2023, released the browser extension (which indicates AI Prompt Manager), which integrates within ChatGPT, showing us the relative interface to quickly access the various prompts already created, both by the AIPRM team and by other users, as also other users can create their prompts and publish them in the interface: AIPRM How AIPRM works After installing the plugin in the browser (a simple procedure that can be done in 1 click), starting from the top, we see two menus, one for the Public Prompts and the other for those created by us, Own Prompts: Below we find other drop-down submenus from where we can choose the type of topic "Topic" and also the activity "Activity", and among other things, we can also sort them based on popularity, as the various prompts can be voted by users who judge whether or not the proposed prompt works: Generate the prompt Once we have chosen the model for the prompt, we just have to enter the keyword or text we want to process; in this case, we have used the "Keyword Strategy" model by entering the NFT keyword: After a few seconds, a splendid table is generated where the data is all organized: Conclusions ChatGPT is an important tool for automatic content generation and can be particularly useful for speeding up text creation. However, it is important to use the model with knowledge of the facts and to keep in mind its limitations. The same rule also applies to AIPRM as the prompts we find are not always useful or allow us to obtain an acceptable result, so we need to test them to see if they can be of help and support to what has already been done and these tools are not used as a complete replacement of professional figures that allow the creation of contents and strategies optimally and professionally. Finally, we leave you with an in-depth video where he illustrates the plugin and how to use it: https://www.youtube.com/watch?v=NrfJCsHUb60&embedable=true

The Secret Plugin for ChatGPT3

El complemento secreto para ChatGPT3

Le plugin secret pour ChatGPT3

ChatGPT3 के लिए गुप्त प्लगइन

ChatGPT3 のシークレット プラグイン

O plugin secreto para ChatGPT3

Plugin bí mật cho ChatGPT3

ChatGPT3 的秘密插件

It takes place somewhere between 1999 and 2000. In 1999, the word “community” took on a new meaning on the web. One that would have a lasting impact for years to come. Napster was released by two teenagers—Shawn Fanning and Sean Parker—from their dorm room. It’s peer to peer technology let college students swap music over a network, with anyone else in the world. It was a simple premise, one rested on a fundamental belief about technology: computers create community. In a short time, Napster—and its simple premise—would throw the entire music industry into upheaval. 1999, the year of Napster’s release, was an important year for community. If you could give people the means to publish on the web, many believed that something like a global, shared, utopic digital gathering of peers felt possible. That year saw the release of a number of sites approaching community from different angles. The Cluetrain Manifesto was a new age business take on community. The website itself featured a collection of ninety-five theses (modeled on Martin Luther’s 95 Theses). The site’s creators—a set of four businessmen and writers—used the list of theses to reframe modern business in the context of an evolving internet. “Markets are conversations,” read the first one. According to the writers of the theses, conversations enabled by the web were, in turn, reshaping markets for everyday individuals, giving them access to information previously only held by the business elite. The site invited others to participate in its authorship, through comment threads and a public petition (sort of like a guestbook). But the site’s creators also generated conversation outside of the site through a web of blog posts, news articles, and link rolls. By making the website a conversation through the mechanics of the web, it provided its very first thesis; a community of shared outward interest. The Cluetrain Mainfesto’s deft use of an emerging network of blogs became its most memorable contribution. Blogging, as a concept, had been around for years. It was on the minds of Meg Hourihan and Evan Williams when they created the web design shop Pyra Labs in 1997. Hourihan and Williams were united by the draw of the web as a place of shared discovery and connection. Out of some early experimentation with the web platform, they created a dead-simple web publishing tool they called Blogger. Blogger removed a lot of the complexity of publishing online. There were other tools for creating websites; Geocities, Tripod, LiveJournal, and the like. But Blogger was about as simple as it came. And Blogger was for blogs. Users could log on, fill out a title and a textbox, click “Publish,” and have their blog post on the web. Blogger replaced the complexity of hand-editing HTML and uploading it to servers with a clean and simple tool. Within a year, they had a hosted version known as Blogspot as well. It gave people without a background in technology the ability to plug into a growing and thriving community which would be known, and then sincerely, as the “blogosphere.” first ironically All of a sudden, blogs began to dominate the global conversation. Mostly young writers published frequently, sometimes in short streams of links, sometimes in long essays. There wasn’t a set format, or editorial board, or any of the traditional barriers to entry. And most importantly, writers linked to one another often, connecting bits of the blogging universe together into a loose network of peers. Writers collected large followings through (digital) word of mouth. Political blogs were a major part of the early 2000’s, and they even supplanted some mainstream coverage. Blogs, on their own, are just websites. But blogs banded together by the types of commenting and linkrolls that platforms like Blogger made possible were something else entirely. They were a community. Matthew Haughey worked at Pyra Labs. He was on the team, along with Paul Basch Jack Dorsey, and others, that helped created the Blogger software. But before it took off, he left to explore a different dimension of community. One that was more centrally linked than the universe of blogs. At the time, Haughey recalls his attempt to bring the experience of blogging to a more connected, single website that acts as a meeting ground for individuals. The site was called Metafilter; its first version was launched in the spring of 1999. Any user could come to Metafilter and post a link, covering “anything and everything about interesting sites found on the web,” as . Visitors could clickthrough to the link, of course. But they could also—and this is where the site became powerful—come back to the post and discuss it with other people on Metafilter in threaded comments. Haughey first described it on his blog It’s a format likely familiar to modern day web-surfers (think a proto-Reddit), but in 1999 it was still a novel idea. Bringing strangers together like that, Metafilter had the same potential as any other site to descend into a twisted knot of poisonous and hurtful language. But throughout it’s history, it’s been able to avoid that pitfall. And that’s largely thanks to the community that uses it. In fact, the community itself was so tight nit that they ended up with a moniker of their own, Mefites. Over the years, during times of crisis or unrest around the world, Metafilter has become a place of discussion and even, on occasion, shared grief. There are stories of members who got married, who found long-lost friends, who aided one another in crisis. by a group of “Mefites” to save several young women from a sex trafficking ring. There are many ways to describe the Metafilter community, but I find this paragraph from Hazlitt sums it up rather well (if not all that conciesely): One article recalls a particular daring rescue “The MetaFilter community comprises feminists, computer engineers, current and former liberal arts nerds, thick-skulled autodidacts, at least two or three pretty famous science fiction writers, a European phage researcher, a New Orleans undertaker, , design geeks, MMORPG nerds, geeks and nerds of all description, people who work at Walmart, Starbucks, and McDonald’s, dads, moms, , factory workers, small-town politicians, unemployed people, , small business owners, pastors, people in porn, aid workers in Africa, , , , retirees, bedbound people, and people with no particularly noteworthy traits beyond their prolific , their , or their nuanced views on or to a .” this guy at least one person in Antarctica this woman him her 13-(almost-14)-year-olds raconteurishness devastatingly true evenkeeledness how to find your passion how dump motherfucking asshole Underneath it all are the moderators, the lifeblood of the Metafilter community. They are often plucked from the threads of the site and given jobs. Every comment is read by a moderator, regular people able to make nuanced decisions about what remains on the site and what gets tossed. Metafilter’s combination of a fiercely passionate user base, meaningful online connection, ease of use, norms and practices created by its users, and of course, moderators, contributed to a vision of online community popular on the early web. There was some that believed Metafilter arranged the pieces in just the right way. They had created the utopic vision of the most optimistic futurists and technologists. There was a sense that this could be the web’s future, a shared communal spirit of helpfulness and upliftment. And that is the story of 1999, at least for community. One that looked forward to a world of options and possibilities. By the end of of 1999, community was already becoming a buzz-word, though other centralized platforms were coming online. Already, AsianAve was demonstrating the possibility of early social networks, and in 2001, BlackPlanet launched to an even wider audience. By the mid-2000’s, sites like MySpace and Friendster would bring the concept to a general audience, and a new version of community would emerge, one that is far closer to our modern understanding of it. In 2001, Omar Wasow launched the social media platform BlackPlanet, building on the success of partner site AsianAve. Together, these site’s would prove the value of community. This post introduced 3 milestones to the . Timeline Blogger August 23, 1999 Pyra Labs, a web development studio created by Evan Williams and Meg Hourihan, releases the first version of Blogger, an early blogging tool which allows users to use a simple form to write posts that were sent to their server. Blogger was one of several tools on the early web that made web publishing simple and accessible, and helped spread blogging to a growing community of indie publishers and writers. In 2003, Google would acquire the service. MetaFilter July 14, 1999 Former Blogger employee Matthew Haughey launches his own take on blogging with a community weblog. Visitors to MetaFilter could post a link and a brief description, which was used to generate conversation through threaded comments on the site. Because of its presence on the early web, and a loyal group of followers, the MetaFilter has created a largely active and productive example of an online community. Cluetrain Manifesto March 25, 1999 A collection of authors and business analysts publish 95 theses of modern business to the web under the moniker . Years before social media platforms entered the mainstream, the site is able to generate conversation through news outlets, personal websites, and digital word of mouth. It is an early example of the kind of web virality. Cluetrain Manifesto View the Full Timeline Sources Matthew Haughey. "Sixteen Years." MetaTalk. March 3, 2015. http://Sixteen%20Years%20|%20MetaTalk%20%20Matthew%20Haughey%20|%20March%204,%202015 Stephen Thomas. "The Internet’s First Family." October 10, 2014. https://hazlitt.net/longreads/internets-first-family Katie Rogers and Ruth Spencer. "The blog turns 20: a conversation with three internet pioneers." The Guardian. January 1, 2014. https://www.theguardian.com/media/2014/jan/29/blog-turns-twenty-conversation-internet-pioneers Laura Axelrod. "Brad L. Graham, coined the term ‘blogosphere,’ dies at 41." Al.com. January 1, 2010. https://www.al.com/scenesource/2010/01/brad_l_graham_coined_the.html First Published . Here

In 1999, the Word “Community” Took on a New Meaning on the Web

En 1999, la palabra “Comunidad” adquirió un nuevo significado en la Web

En 1999, le mot « communauté » prend un nouveau sens sur le Web

1999 में, "समुदाय" शब्द ने वेब पर एक नया अर्थ ग्रहण किया

1999 年、「コミュニティ」という言葉が Web 上で新しい意味を持つようになりました

Em 1999, a palavra “comunidade” assumiu um novo significado na web

Năm 1999, từ “Cộng đồng” mang một ý nghĩa mới trên Web

1999 年，“社区”一词在网络上有了新的含义

What you always have as a Kubernetes cluster is usually always the bare minimum. Be it a cluster you set up yourself in a cluster of RasberryPi’s or using Amazon EKS or any other form you set up your Kubernetes cluster, it is NEVER production-ready. The keyword here is production-ready. What do we mean when we say production-ready. In very simple terms, it means it is ready to face the world. It is ready to face the good the bad and the ugly traffic that will come to it and still stand strong despite whatever comes to it. Putting this in perspective, it is quite important to find a bench-mark to work with in determining if our cluster is production-ready. The following checklist is my best recommendation to follow to know if your cluster is production-ready, . https://learnk8s.io/production-best-practices In this article, I am looking at tools to have that will make your cluster production-ready. I shall be using the 5 pillars of the to categorize the different types of tools/services that you must have in the cluster to dim it fit for production. Take note, that this list is bare-minimum, the number of services you can deploy in your cluster is endless, but you do not want to deploy so much. AWS Well-Architected Framework The Categories The categories for the different tools are as follows: Reliability and Availability Security Network, Monitoring & Observability Backup/Recovery Cost Optimization Cluster Visualization Reliability and Availability These two terms are actually mean different things; reliability means that a system is doing what is designed to do effectively, while availability is when a system is accessible by the user. These two are very necessary for your applications in your Kubernetes cluster. There are tools that can help your applications to be highly available. Tools Horizontal Pod Autoscaler (HPA) Karpenter (https://github.com/aws/karpenter). Cluster-Autoscaler ( ). https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler Goldilocks ( ). https://github.com/FairwindsOps/goldilocks While HPA is for scaling pods based on CPU and Memory metrics, Karpenter and Cluster-Autoscaler scale nodes are based on the pod capacity of the nodes. Goldilocks helps you recommend the appropriate CPU and Memory metrics for your pods based on how much has been consumed over a period of time. Security The security of your cluster is a very essential part of running workloads in the Kubernetes cluster. Security in Kubernetes is of two folds. First is the security from an external attack on your API server which is usually secured with certificates, but an extra later of putting the API server in a private network reduces the surface area of attack because it is not exposed to the public internet. The other security operations have to do with scanning your cluster for proper configurations to ensure the pods running follow proper security standards. Here are some security tools that can help scan container-based workloads and Kubernetes clusters. Tools Snyk ( ) https://snyk.io Kubelinter ( ) https://github.com/stackrox/kube-linter Kubehunter ( ) https://github.com/aquasecurity/kube-hunter Checkov ( ) https://checkov.io Kube-Scan ( ) https://github.com/octarinesec/kube-scan Network, Monitoring & Observability What is a Kubernetes cluster without its network? The network is used to send and receive traffic within the cluster and outside the cluster. It is important to be able to sketch a flow of traffic within the cluster. It makes it easy to identify bottlenecks like; slow or unresponsive microservices. This is where a comes into play. service mesh ServiceMesh Tools Istio ( ) https://istio.io Linkrd ( ) https://linkrd.io AWS AppMesh (https://aws.amazon.com/app-mesh) Consul ( ) https://www.consul.io/ Monitoring & Observability The availability and Mean Time to Recover (MTTR), of your system is high proportionate to the depth of monitoring and observability in the system. Monitoring helps to collect logs and metrics of worker nodes and pods/applications running within the cluster. To know more about logs and metrics get my book on . There are many monitoring tools out there. But I will pick about three of them that stand out in different scenarios. Observability on the other end is a combination of Application Performance Management (APM), bug tracing and application tracing, with the focus on knowing what is going on within the application. Amazon CloudWatch Monitoring Tools/Services Prometheus (prometheus.io) — for collecting metrics. Grafana (grafana.net) — for data visualization of data from different sources. Amazon CloudWatch Container Insights. Netdata ( ). https://netdata.cloud Observability Tools Amazon X-Ray ( ). https://aws.amazon.com/xray/ Datadog (https://datadog.com). AWS CloudMap ( ). https://aws.amazon.com/cloud-map/ Jaegar ( ). https://www.jaegertracing.io/ Backup/Recovery Backing up all components of your cluster can be a lifesaver in times of disaster or during a migration process. Deployments, Pods, Secrets, ConfigMaps, ClusterRole, ClusterRoleBinding, and all other resources in Kubernetes. The backup of the cluster is stored as a zip file in any of the popular object storage services such as , , . This data can also be retrieved at any time or to an identical cluster with a single command and all resources backed up will be automatically restored. It can also be configured to run a periodic backup of the cluster resources. Amazon S3 Azure Blob Storage Google Cloud Storage Tool(s) ( ) Velero https://velero.io Cost Optimization Most times the cost which is tangible for a Kubernetes cluster in a cloud environment is usually the cost of the Master Node (Control Plane) and the worker nodes and other underlying infrastructure with which they are running on. These costs are clearly displayed in the Billing dashboard of the cloud provider. They can be optimized by choosing better pricing option for the nodes within the cluster. But you can granularly check cost from pod consumption and cascade that cost to numerical dollar value. This can give very interesting insights on application that are costing more to run. Tool(s) Kubecost ( ) https://www.kubecost.com/ Cluster Visualization By deafult, Kubernetes has a dashboard. But most times this dashboard is barely used and it has very limited features which forces most Kubernetes Administrators to learn commands to get what they want. But sometimes, it can be time consumting, trying to find the right command to check for certain resources and perform a comparison or get quick feedback on the behavior of pods or services within the cluster. Some tools actually make managing Kubernetes cluster more fun. kubectl Tool(s) Lens ( ) https://k8slens.dev/ Rancher ( ) https://rancher.com Conclusion There is no perfect Kubernetes cluster, the tools mentioned here are suggestions of tools that you should have in your cluster to get the best out of it. At least one tools from the five sections mentioned is needed to have proper visibility and governance of your Kubernetes cluster. Also published . here

Kubernetes Cluster Must-Haves To Be Production Ready

We'll be building a blog site with the Angular framework, Scully for static site generation(SSG) and then deploying the project on Netlify so that it can be accessible to the public. What this article covers Using Angular to build the blog architecture Installing Scully library to handle static site Generation Netlify deployment Demo of this project Repository for the demo Setup requirements We'll be using the following tools for this project Angular v13 Tailwind Scully Node v14.15 (or higher) is an application design framework and development platform for creating efficient and sophisticated single-page apps. It's an opensource frontend framework built by Google. Angular is a library used for generating static sites built with Angular and ushers you into the jamstack. SSGs generate static pages when you build your project so that what you publish/deploy is the already built pages which can be indexed by google(for some of that SEO good good) and served quickly to clients. Without scully, our angular project will go through client side rendering where each page of the application that is visited is rendered by the browser at runtime. Scully is a CSS utility library that is used to speed up the styling of applications by offering flexibility and conciseness. Tailwind Now that we have some background on the project, we can start building. Generating the Angular project Use the command below to generate a new angular project. You can name your project what you like. I have chosen angular-blog ng new angular-blog You'll see the following questions. We want routing and SCSS stylesheet format. ? Would you like to add Angular routing? Yes
? Which stylesheet format would you like to use? SCSS After the project has been generated, serve the application using the ng serve command ng serve You'll be greeted with the standard angular welcome template. Navigate to and delete the entire content (we don't want that welcome page showing up) and then place tags since this is where all our modules and components will be displayed based on the route configuration in app.component.html <router-outlet></router-outlet> app.routing-module.ts Installing Scully Run the command below to install scully and automatically make all the necessary configurations to the project ng add @scullyio/init During the installation, you'll get the question below. As at the time of this writing, is the most stable renderer so we'll choose that. pupeteer ? Which route renderer would you like to use?
  Scully platform server
> Puppeteer
  Playwright (beta) Here is what the terminal looks like after the installation process The schematic of the scully installation made a couple of changes which include; init installing the pupeteer plugin updating the by importing the app.module.ts ScullyLibModule updating the package.json file with scully commands for building and serving the generated pages "scully": "npx scully --",
  "scully:serve": "npx scully serve --" created a file which is the scully configuration file. scully.angular-blog.config.ts Adding Blog Support to Our Project Scully has a schematic for creating the blog section for our project ng generate @scullyio/init:blog This adds a lazy-loaded blog module's routes to the Angular application( ) and creates a folder for the blog's markdown files(where our blog posts will live). Below is the current route configuration in updated by scully. app.routing-module.ts ./blog app.routing-module.ts const routes: Routes = [{
  path: 'blog',
  loadChildren: () => import('./blog/blog.module').then(m => m.BlogModule)
}]; It also updates the with the blog routes to prerender. scully.angular-blog.config.ts A Few Other Configurations Now we have a module for our blog feature. The next things we need to do are; create a component for the list of blog posts using the command below ng generate component blog/blog-list create a component that will show the actual blog post content using the command below ng generate component blog/blog-post Fix up our route configuration in as below blog.routing.module.ts const routes: Routes = [
{
  path: '',
  component: BlogComponent,
  children: [
    {path: ':slug', component: BlogPostComponent},
    {path: '', component: BlogListComponent}
    ]
}
]; Lastly, we add the in the to handle routing in the module.This page will display the blog list and blog posts based on the route configuration in <router-outlet></router-outlet> blog.component.html blog-routing.module.ts Configuring the Route Entry Point for Scully After sorting out the module for our blog feature, we need to create an entry point for scully (typically the home page of our app). It is suitable to leverage the Angular lazy-loaded module feature for our app home page because this part of our app is separate from the blog part. Create a with the following command: home module ng generate module home --route=home --module=app-routing This updates the route configuration in with the path for the . Set its path to an empty string. app-routing.module.ts home module const routes: Routes = [
  {
    path: 'blog',
    loadChildren: () => import('./blog/blog.module').then((m) => m.BlogModule),
  },
  {
    path: '',
    loadChildren: () => import('./home/home.module').then((m) => m.HomeModule),
  },
  { path: '**', redirectTo: 'blog', pathMatch: 'full' },
]; You can always add a redirect below the route configuration for the blog module if you don't want the home page to be accessed yet. {path:'',redirectTo:'blog',pathMatch:'full'}, Building the Angular-Scully App After all those configurations, we need to build our project with Angular, build with Scully then serve the built project on the Scully server but first, let's restart the Angular server.Build the project by running ng build Then we build with scully using npx scully We can also modify the command in our so that it will run the two previous commands. build package.json "build": ng build && npm run scully -- --scanRoutes Now we can use to achieve the same thing. After those two commands, a folder is created in the root directory of our project. This folder contains the two built versions of our site, The folder named is the one built by Angular while the one named contains the static pages generated by scully. Now, we can start the scully server using the command: npm run build dist angular-blog static npx scully serve After the server starts successfully, navigate to to see the angular app running, then in a separate tab, open this link to see the static site. You browser should show a white page with the text .To check our actual blog post (created by the schematic) go to the markdown file in the folder and copy the value of the property in the frontmatter. http://localhost:4200/blog http://localhost:1668/blog blog-list works! init:blog blog slugs ---
title: 2022-04-29-blog
description: 'blog description'
published: false
slugs:
    - ___UNPUBLISHED___l2kp8pyl_z4RfUZ7hSOMdOfldi8yqeZcOKuebIId2
--- That is the current path(generated by scully) to the blog post when . It's a private route to your blog post when it's still in draft version so you can share with anyone to get an article review before publishing. When you are ready to publish the post, you can set and remove the property which will allow scully use the file name(without the extension) as its path when it generates the static pages. published: false published: true slugs Go to address bar of the tab serving the static site and paste the slug after then press enter. You should see the content of the blog post. Now, we have confirmed that our blog feature is fully functional so next up is to add more blog posts. http://localhost:1668/blog/ Creating Blog Posts We can create a blog post with the command below. The option takes the name of your post. name ng generate @scullyio/init:post --name="Post 1" This creates a markdown file in the folder. When we open the newly created markdown file, we see this blog ---
title: Post 1
description: blog description
published: false
---

# Post 1 As you now know, the content between the three dashes is the frontmatter and below the frontmatter is the blog content.The frontmatter is where we can add information about the post such as metadata, SEO e.t.c. Let's update this markdown file to look like this ---
title: Post 1
description: blog description
published: true
image: /assets/images/enigma.jpg
seo: {
metaDescription: First post for my angular scully blog,
metaTitle: First post
},
---

# Post 1 I have added an image in the corresponding directory which I'll render in post. When we're satisfied with our markdown file, we can build with the command. npx scully A Tip on Knowing Which to Build With is only needed when you modified something in your angular app. The scully config file, plugins, and eventual markdown files are not part of your Angular app. Although this may seem evident, if this is your first time using Scully it is easy to rebuild Angular even if it is not needed. When writing Scully plugins OR modifying your blog's markdown files, you DO NOT need to ng build the app each time you re-run Scully. Again, ng build Angular only if the Angular app changes ng build Showing All Blog Posts Let's head over to to work out the logic that handles data for the component. In this component, we will inject the as a dependency which will give us access to the blog posts routes. blog-list.component.ts ScullyRoutesService import { Component, OnInit } from '@angular/core';
import {ScullyRoute, ScullyRoutesService} from "@scullyio/ng-lib";
import {Observable} from "rxjs";

@Component({
  selector: 'app-blog-list',
  templateUrl: './blog-list.component.html',
  styleUrls: ['./blog-list.component.scss']
})
export class BlogListComponent implements OnInit {
  links$: Observable<ScullyRoute[]> = this.scully.available$;

  constructor(private scully: ScullyRoutesService) { }

  ngOnInit(): void {
    this.getPublishedPosts();
  }

  getPublishedPosts() {
    this.links$ = this.links$.pipe(tap(val) => console.log(val))
  }
} What we want to render are the published posts, that's why we get the published routes from the property on the .In the we can build the template that shows all blog posts. We'll work with the code below for now. available$ ScullyRoutesService blog-list.component.html <div>
  <ul>
    <li *ngFor="let post of links$ | async">
    <a [href]="post.route">{{post.title}}</a>
    </li>
  </ul>
</div> After you save, you should see an array of two routes in the console. We can't see any blog posts route yet because we haven't built with scully after changing the property to .Let's ensure that the property in our markdown files are set to then build with scully to update our published routes. Now when we reload, we should see an array of 4 routes in the console. However, since we only want blog posts routes, we'll need to transform our data with some rxjs. Let's update the function published true published true getPublishedPosts getPublishedPosts() {
    this.links$ = this.links$.pipe(map((links) => links.filter((link) =>
      link.route.startsWith('/blog/'))),tap((val) => console.log(val)));
  } To ensure the scully version of our site is updated, let's run the command: npm run build Now we should have our page like this. You can click on the links to see that they show the corresponding posts. Accessing the Data in the Blog Post Page We can get the route data of a particular page we navigate to with the help of the by subscribing to the observable returned by the method. Add the code below to the ScullyRoutesService getCurrent() blog-post.component.ts import {Component, OnDestroy, OnInit} from '@angular/core';
import {ScullyRoute, ScullyRoutesService} from "@scullyio/ng-lib";
import {Subject, takeUntil} from "rxjs";
import {tap} from "rxjs/operators";

@Component({
  selector: 'app-blog-post',
  templateUrl: './blog-post.component.html',
  styleUrls: ['./blog-post.component.scss']
})
export class BlogPostComponent implements OnInit, OnDestroy {
  currentRoute: ScullyRoute = {} as ScullyRoute;
  onDestroy$ = new Subject<void>();

  constructor(private scully: ScullyRoutesService) {
  }

  ngOnInit(): void {
    this.getCurrentPost()
  }

  getCurrentPost() {
    this.scully.getCurrent()
      .pipe(takeUntil(this.onDestroy$))
      .subscribe((routeData: ScullyRoute) => {
        this.currentRoute = routeData;
      });
  }

  ngOnDestroy() {
    this.onDestroy$.next();
    this.onDestroy$.complete();
  }
} Details of our current route is assigned to property and this allows us use the route data for that particular post the way we want. this.currentRoute Styling Our Blog Firstly, we need to create another component which will be our reusable component for the blog cards. Use the command: ng generate component blog/blog-list/blog-card Open the and place the code below inside it blog-card.component.html <li *ngFor="let post of links$ | async">
    <a [href]="post.route">{{post.title}}</a>
</li> Then we make use of this component in our via the selector in this way blog-list.component.html app-blog-card <div>
  <ul>
    <app-blog-card [post]="post" *ngFor="let post of links$ | async"></app-blog-card>
  </ul>
</div> We are also passing each route object in the array as through the component therefore, we will need to receive this data from the parent component( ) in our child component ( ) using the decorator. Let's do that by putting the code below in the post app-blog-card blog list blog card Input() blog-card.component.ts import {Component, Input, OnInit} from '@angular/core';
import {ScullyRoute} from "@scullyio/ng-lib";

@Component({
  selector: 'app-blog-card',
  templateUrl: './blog-card.component.html',
  styleUrls: ['./blog-card.component.scss']
})
export class BlogCardComponent implements OnInit {
  @Input() post: Partial<ScullyRoute> = {};

  constructor() { }

  ngOnInit(): void {
  }
} Finally, Some Styling You can use any styling format you want. I'll be using tailwind. Let's use the straightforward to configure it in our project. After the configuration is done, we'll need to restart the angular server. Update the with the new template below tailwind documentation blog-card.component.html <li class="h-full">
  <a [href]="post.route" class="h-full w-full lg:max-w-full lg:flex hover:bg-gray-100">
    <div
      class="h-48 lg:h-auto lg:w-48 flex-none bg-cover rounded-t lg:rounded-t-none lg:rounded-l text-center overflow-hidden"
      [style.background-image]="'url(' + (post['image'] || 'https://images.unsplash.com/photo-1496494118863-9cf5d1e70cd6?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=870&q=80') + ')'"
      title="Mountain">
    </div>
    <div
      class="w-full border-r border-b border-l border-gray-400 lg:border-l-0 lg:border-t lg:border-gray-400  rounded-b lg:rounded-b-none lg:rounded-r p-4 flex flex-col justify-between leading-normal">
      <div class="mb-8">
        <div class="text-gray-900 font-bold text-xl mb-2">{{post.title}}</div>
        <p class="text-gray-700 text-base">{{post['seo']?.metaDescription || post['description']}}</p>
      </div>
    </div>
  </a>
</li> Also update the blog-list.component.html <div>
  <ul class="p-10 grid grid-cols-1 sm:grid-cols-1 md:grid-cols-1 lg:grid-cols-1 xl:grid-cols-3 gap-5">
    <app-blog-card [post]="post" *ngFor="let post of links$ | async"></app-blog-card>
  </ul>
</div> The code below adds a header to our site. Add it in app.component.html <nav class="flex flex-wrap items-center justify-between bg-gray-800 p-6 w-full">
  <div>
    <a class="text-white no-underline hover:text-white hover:no-underline" routerLink="/">
      <span class="text-2xl">Angular scully blog</span>
    </a>
  </div>
  <ul class="list-reset flex justify-end flex-1 items-center">
    <li class="mr-3">
      <a class="inline-block text-white no-underline hover:text-gray-200 hover:text-underline py-2 px-4"
         routerLinkActive="" routerLink="/blog">blog</a>
    </li>
  </ul>
</nav>
<router-outlet></router-outlet> Now we have a nice user interface that shows all blog post Let's add the code below for the blog post user interface( ) blog-post.component.html <main class="mx-auto max-w-screen-sm max-w-screen-lg">
   <img [src]="currentRoute['image'] || 'https://cdn.mos.cms.futurecdn.net/4uiRZ5nNAgpHSifSjaKwcC-970-80.jpg.webp'"
      alt="nft"/>
   <h3>ScullyIo content</h3>
   <hr>
   
   <scully-content></scully-content>
   <hr>
   <h4>End of content</h4>
</main> Finally, use the command to build the project and checkout the scully static version in your browser. npm run build Pushing to Github Create a repository on and then copy the remote url ( ) so that we can add it for our project using the command below: Github https://github.com/<github-username>/<repository-name>.git git remote add origin https://github.com/<github-username>/<repository-name>.git Rename the branch to with the command below: main git branch -M main Push to github with the command below: git push origin main Here's a link to the . repository for this article demo Deploying to Netlify After pushing our Angular Scully blog to github, we are ready to deploy on Netlify. If you do not have an account yet, you can or go ahead and log in to your account if you have one.Choose import from git Select Github Connect the repository you want to deploy. You may need to configure netlify for your github account if it has not been setup. This is needed for netlify to have access to the repository Provide the path to the folder where the scully generated static pages are as well as the build command Click the button and watch as netlify builds your project. Congratulations on making it to the end and have fun personalising your site as you like. signup here Deploy site Here's a link to the deployed site Conclusion I do hope this article has been helpful in guiding you through creating your blog site with Angular and scully from scratch. You can leave questions or suggestions in the comments or reach out to me on twitter @BrunoElo if you like. Thanks for reading! Also published . here

Creating an Angular Blog With Scully and Deploying on Netlify

Web apps are still useful tools for data scientists to present their data science projects to users. Since we may not have web development skills, we can use open-source python libraries like Streamlit to easily develop web apps in a short time. TABLE OF CONTENTS Introduction to Streamlit Installation and Set up Develop the Web App Test the Web App Conclusion 1. Introduction to Streamlit Streamlit is an open-source python library for creating and sharing web apps for data science and machine learning projects. The library can help you create and deploy your data science solution in a few minutes with a few lines of code. Streamlit can seamlessly integrate with other popular python libraries used in Data science such as NumPy, Pandas, Matplotlib, Scikit-learn and many more. Note: Streamlit uses React as a frontend framework to render the data on the screen. 2. Installation and Set up Streamlit requires python >= 3.7 version in your machine. To install streamlit, you need to run the command below in the terminal. pip install streamlit You can also check the version installed on your machine with the following command. streamlit --version streamlit, version 1.1.0 After successfully installing streamlit, you can test the library by running the command below in the terminal. streamlit hello Streamlit's Hello app will appear in a new tab in your web browser. This shows that everything is running ok, we can move on and create our first web app by using Streamlit. 3. Develop the Web App In this part, we are going to deploy the trained NLP model that predicts the sentiment of a movie's review (positive or negative). You can access the source code and the dataset . here The data science web app will show a text field to add the movie's review and a simple button to submit the review and make predictions. Import Important Packages The first step is to create a python file called app.py and then import required python packages for both streamlit and the trained NLP model. streamlit st os numpy np sklearn.feature_extraction.text TfidfVectorizer, CountVectorizer string punctuation nltk.tokenize word_tokenize nltk nltk.corpus stopwords nltk.stem WordNetLemmatizer re joblib warnings
 
warnings.filterwarnings( ) np.random.seed( ) stop_words = stopwords.words( ) # import packages import as import import as from import # text preprocessing modules from import # text preprocessing modules from import import from import from import import # regular expression import import "ignore" # seeding 123 # load stop words "english" Function to Clean the Review The reviews can have unnecessary words and characters that we don't need when making predictions. We will clean the review by removing stopwords, numbers, and punctuation. Then we will convert each word into its base form by using the lemmatization process in the NLTK package. The function will handle all necessary steps to clean our review before making a prediction. text_cleaning() text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text) text = .join([c c text c punctuation]) remove_stop_words:
        text = text.split()
        text = [w w text w stop_words]
        text = .join(text) lemmatize_words:
        text = text.split()
        lemmatizer = WordNetLemmatizer()
        lemmatized_words = [lemmatizer.lemmatize(word) word text]
        text = .join(lemmatized_words) text # function to clean the text @st.cache : def text_cleaning (text, remove_stop_words=True, lemmatize_words=True) # Clean the text, with the option to remove stop_words and to lemmatize word # Clean the text r"[^A-Za-z0-9]" " " r"\'s" " " r"http\S+" " link " r"\b\d+(?:\.\d+)?\s+" "" # remove numbers # Remove punctuation from text "" for in if not in # Optionally, remove stop words if for in if not in " " # Optionally, shorten words to their stems if for in " " # Return a list of words return Function to Make Prediction The python function called will do the following tasks. make_prediction() Receive the review and clean it. Load the trained NLP model. Make a prediction. Estimate the probability of the prediction. Finally, it will return the predicted class and its probability. clean_review = text_cleaning(review) model = joblib.load( ) result = model.predict([clean_review]) probas = model.predict_proba([clean_review])
    probability = .format(float(probas[:, result])) result, probability # functon to make prediction @st.cache : def make_prediction (review) # clearn the data # load the model and make prediction "sentiment_model_pipeline.pkl" # make prection # check probabilities "{:.2f}" return if the trained NLP model predicts 1, it means Positive and if it predicts 0, it means Negative. Note: Create App Title and Description You can create the title of your web app and its description by using the title() and write() method from streamlit. st.title( )
st.write( ) # Set the app title "Sentiment Analyisis App" "A simple machine laerning app to predict the sentiment of a movie's review" To show the web app, you need to run the following command in your terminal. streamlit run app.py Then you will see the web app automatically pop up in your web browser or you can use the local URL created http://localhost:8501. Create a Form to Receive a Movie's Review The next step is to create a simple form by using streamlit. The form will show a text field to add your review and below the text field, it will show a simple button to submit the review added and then make a prediction. form = st.form(key= )
review = form.text_input(label= )
submit = form.form_submit_button(label= ) # Declare a form to receive a movie's review "my_form" "Enter the text of your movie review" "Make Prediction" Now, you can see the form on the web app. Make Predictions and show Results Our last piece of code is to make predictions and show results whenever a user adds a movie’s review and clicks the "make prediction" button on the form section. After clicking the button, the web app will run the function and show the result on the web app in the browser. make_prediction() submit: result, probability = make_prediction(review) st.header( ) int(result) == :
        st.write( , probability) :
        st.write( , probability) if # make prediction from the input text # Display results of the NLP task "Results" if 1 "This is a positive review with a probabiliy of " else "This is a negative review with a probabiliy of " 4. Test the Web App With a few lines of code, we have created a simple data science web app that can receive a movie review and predict if it is a positive review or a negative review. To test the web app, fill the text field by adding a movie review of your choice. I added the following movie review about movie released in 2021. Zack Snyder's Justice League "I loved the movie from the beginning to the end. Just like Ray Fisher said, I was hoping that the movie doesn't end. The begging scene was mind blowing, liked that scene very much. Unlike 'the Justice League' the movie show every hero is best at their own thing, make us love every character. Thanks, Zack and the whole team." Then click the make prediction button and view the result. As you can see on the web app we have created, the trained NLP model predicts the review added is with a probability of positive 0.64. I recommend you add another movie review on the data science web app we have created and test it again. 5. Conclusion There are a lot of features and components from Streamlit that you can use to develop a data science web app the way you want. What you have learned here, are some of the common elements from streamlit. To learn more you can visit their beautiful designed documentation pages here. If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next article!. You can also find me on Twitter and you can read more articles like this . @Davis_McDavid here Want to keep up to date with all the latest in Data Science? in the footer below! Subscribe to our newsletter

How to Use Streamlit and Python to Build a Data Science App

Cómo usar Streamlit y Python para crear una aplicación de ciencia de datos

This is the second and final part of the series on How to build and deploy an NLP model with FastAPI. In , we looked at how to build an NLP model that can classify movie reviews into different sentiments. the first part In this second and final part, you will learn What is FastAPI and how to install it. How to deploy your model with FastAPI. How to use your deployed NLP model in any Python application. So let’s get started.🚀 What is FastAPI? FastAPI is the fast and modern python web framework for building different . It provides higher performance, easier to code, and comes up with automatic & interactive documentation. FastAPI is built upon two major python libraries – (for web handling) and (for data handling & validation). FastAPI is very fast compared to Flask because it brings asynchronous function handlers to the table. APIs Starlette Pydantic If you want to know more about FastAPI, I recommend you read this by Sebastián Ramírez. article In this article, we will try to use some of the features presented in FastAPI to serve our NLP model. How To Install FastAPI Firstly, make sure you install the latest version (with pip): pip install fastapi You will also need an ASGI server for production such as . uvicorn pip install uvicorn Deploy NLP Model with FastAPI In this section, we are going to deploy our trained model as a REST API with FastAPI. The code for our API will be saved in a python file called , this file will be responsible for running our FastAPI app. NLP main.py Import packages The first step is to import packages that will help us to build the FastAPI app and run the NLP model. string punctuation nltk.tokenize word_tokenize nltk nltk.corpus stopwords nltk.stem WordNetLemmatizer re os os.path dirname, join, realpath joblib uvicorn fastapi FastAPI # text preprocessing modules from import # text preprocessing modules from import import from import from import import # regular expression import from import import import from import Initializing a FastAPI App Instance We can use the following code to initialize the FastAPI app. app = FastAPI(
    title= ,
    description= ,
    version= ,
) "Sentiment Model API" "A simple API that use NLP model to predict the sentiment of the movie's reviews" "0.1" As you can see we have customized the configuration of our FastAPI application by including: Title of the API Description of the API. The version of the API. Load the NLP model To load the model we use method and add the path to the model directory. The name of the  NLP model is . joblib.load() sentiment_model_pipeline.pkl open(
    join(dirname(realpath(__file__)), ), ) f:
    model = joblib.load(f) # load the sentiment model with "models/sentiment_model_pipeline.pkl" "rb" as Define a Function to Clean the Data We will use the same function called from Part 1 that cleans the review data by removing stopwords,  numbers, and punctuation, and finally, convert each word into its base form by using the lemmatization process in the NLTK package. text_cleaning() text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text) text = .join([c c text c punctuation]) remove_stop_words: stop_words = stopwords.words( )
        text = text.split()
        text = [w w text w stop_words]
        text = .join(text) lemmatize_words:
        text = text.split()
        lemmatizer = WordNetLemmatizer()
        lemmatized_words = [lemmatizer.lemmatize(word) word text]
        text = .join(lemmatized_words) text : def text_cleaning (text, remove_stop_words=True, lemmatize_words=True) # Clean the text, with the option to remove stop_words and to lemmatize word # Clean the text r"[^A-Za-z0-9]" " " r"\'s" " " r"http\S+" " link " r"\b\d+(?:\.\d+)?\s+" "" # remove numbers # Remove punctuation from text "" for in if not in # Optionally, remove stop words if # load stopwords "english" for in if not in " " # Optionally, shorten words to their stems if for in " " # Return a list of words return Create Prediction Endpoint The next step is to add our prediction endpoint called " " with the GET request method. /predict-review @app.get("/predict-review") “An API endpoint is the point of entry in a communication channel when two systems are interacting. It refers to touchpoints of the communication between an API and a server.” Then we define a prediction function for this endpoint. The name of the function is called with a review parameter. predict_sentiment() The predict_sentiment() function will do the following tasks. Receive the movie review. Clean the movie review by using the function. text_cleaning() Make a prediction by using our NLP model. Save the prediction result in the variable (either 0 or 1). output Save the probability of the prediction in the variable and format it into 2 decimal places. probas Finally, return prediction and probability result. cleaned_review = text_cleaning(review) prediction = model.predict([cleaned_review])
    output = int(prediction[ ])
    probas = model.predict_proba([cleaned_review])
    output_probability = .format(float(probas[:, output])) sentiments = { : , : } result = { : sentiments[output], : output_probability} result @app.get("/predict-review") : def predict_sentiment (review: str) """
    A simple function that receive a review content and predict the sentiment of the content.
    :param review:
    :return: prediction, probabilities
    """ # clean the review # perform prediction 0 "{:.2f}" # output dictionary 0 "Negative" 1 "Positive" # show results "prediction" "Probability" return Here are all blocks of codes in the file. main.py string punctuation nltk.tokenize word_tokenize nltk nltk.corpus stopwords nltk.stem WordNetLemmatizer re os os.path dirname, join, realpath joblib uvicorn fastapi FastAPI

app = FastAPI(
    title= ,
    description= ,
    version= ,
) open(
    join(dirname(realpath(__file__)), ), ) f:
    model = joblib.load(f) text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text)
    text = re.sub( , , text) text = .join([c c text c punctuation]) remove_stop_words: stop_words = stopwords.words( )
        text = text.split()
        text = [w w text w stop_words]
        text = .join(text) lemmatize_words:
        text = text.split()
        lemmatizer = WordNetLemmatizer()
        lemmatized_words = [lemmatizer.lemmatize(word) word text]
        text = .join(lemmatized_words) text cleaned_review = text_cleaning(review) prediction = model.predict([cleaned_review])
    output = int(prediction[ ])
    probas = model.predict_proba([cleaned_review])
    output_probability = .format(float(probas[:, output])) sentiments = { : , : } result = { : sentiments[output], : output_probability} result # text preprocessing modules from import # text preprocessing modules from import import from import from import import # regular expression import from import import import from import "Sentiment Model API" "A simple API that use NLP model to predict the sentiment of the movie's reviews" "0.1" # load the sentiment model with "models/sentiment_model_pipeline.pkl" "rb" as # cleaning the data : def text_cleaning (text, remove_stop_words=True, lemmatize_words=True) # Clean the text, with the option to remove stop_words and to lemmatize word # Clean the text r"[^A-Za-z0-9]" " " r"\'s" " " r"http\S+" " link " r"\b\d+(?:\.\d+)?\s+" "" # remove numbers # Remove punctuation from text "" for in if not in # Optionally, remove stop words if # load stopwords "english" for in if not in " " # Optionally, shorten words to their stems if for in " " # Return a list of words return @app.get("/predict-review") : def predict_sentiment (review: str) """
    A simple function that receive a review content and predict the sentiment of the content.
    :param review:
    :return: prediction, probabilities
    """ # clean the review # perform prediction 0 "{:.2f}" # output dictionary 0 "Negative" 1 "Positive" # show results "prediction" "Probability" return Run the API The following command will help us to run the FastAPI app we have created. uvicorn main:app --reload Here are the settings we have defined for uvicorn to run our FastAPI app. the file main.py that has the FastAPI app. main: the object created inside of main.py with the line app = FastAPI(). app: : Enables the server to automatically restart whenever we make changes in the code. --reload FastAPI provides an Automatic Interactive API documentation page. To access it navigate to in your browser and then you will see the documentation page created automatically by FastAPI. http://127.0.0.1:8000/docs The documentation page shows the name of our API, the description, and its version. It also shows a list of available routes in our API that you can interact with. To make a prediction first click the " " route and then click on the button " , it allows you to fill the review parameter and directly interact with the API. predict-review Try it out" Fill the review field by adding a movie review of your choice. I added the following movie review about movie released in 2021. Zack Snyder's Justice League "I loved the movie from the beginning to the end. Just like Ray fisher said, I was hoping that the movie doesn't end. The begging scene was mind blowing, liked that scene very much. Unlike 'the Justice League' the movie show every hero is best at their own thing, make us love every character. Thanks, Zack and the whole team." Then click the execute button to make a prediction and get the result. Finally, the result from the API shows that our NLP model predicts the review provided has sentiment with the probability of . Positive 0.70 Use NLP model in any Python Applications To use our NLP API in any python application, we need to install the requests python package. This python package will help us to send HTTP requests to the FastAPI app we have developed. To install the requests package run the following command. pip install requests Then create a simple python file called . This file will be responsible to send our HTTP requests. python_app.py We first import requests package. requests r import as Add a movie review about Movie. Godzilla vs Kong (2021) review = # add review "This movie was exactly what I wanted in a Godzilla vs Kong movie. It's big loud, brash and dumb, in the best ways possible. It also has a heart in a the form of Jia (Kaylee Hottle) and a superbly expressionful Kong. The scenes of him in the hollow world are especially impactful and beautifully shot/animated. Kong really is the emotional core of the film (with Godzilla more of an indifferent force of nature), and is done so well he may even convert a few members of Team Godzilla." Then add the review in a key parameter to pass to the HTTP request. keys = { : review} "review" Finally, we send a request to our API to make a prediction of the review. prediction = r.get( , params=keys) "http://127.0.0.1:8000/predict-review/" Then we can see the prediction results. results = prediction.json()
print(results[ ])
print(results[ ]) "prediction" "Probability" This will show the prediction and its probability. Here are the results. Positive 0.54 Wrapping Up Congratulations 👏👏, you have made it to the end of this part 2. I hope you have learned something new on how to deploy your NLP model with FastAPI. If you want to learn more about FastAPI, I recommend taking this created by . full FastAPI course Bitfumes You can download the project source code  used in this article here: https://github.com/Davisy/Deploy-NLP-Model-with-FastAPI If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next article!. You can also find me on Twitter and you can read more articles like this . @Davis_McDavid here Want to keep up to date with all the latest in machine learning? Subscribe to our newsletter in the footer below!

How To Build and Deploy an NLP Model with FastAPI: Part 2

Model deployment is one of the most important skills you should have if you're going to work with NLP models. Model deployment is the process of integrating your model into an existing production environment. The model will receive input and predict an output for decision-making for a specific use case. “Only when a model is fully integrated with the business systems, we can extract real value from its predictions”. - Christopher Samiullah There are different ways you can deploy your model into production, you can use Flask, Django, Bottle e.t.c .But in today's article, you will learn how to build and deploy your NLP model with FastAPI. NLP In this series of  articles, you will learn: How to build a NLP model that classifies IMDB Movies reviews into different sentiments. What is FastAPI and how to install it. How to deploy your model with FastAPI. How to use your deployed NLP model in any Python application. In part 1, we will focus on building an NLP model that can classify movie reviews into different sentiments. So let’s get started! How to Build the NLP Model First, we need to build our NLP model. We are going to use the to build a simple model that can classify if the review about the movie is Positive or Negative. Here are the steps you should follow to do that. IMDB Movie dataset Import Important packages First, we import important python packages to load data, clean the data, create a machine learning model (classifier), and save the model for deployment. numpy np pandas pd sklearn.model_selection train_test_split sklearn.pipeline Pipeline sklearn.naive_bayes MultinomialNB sklearn.metrics (
    accuracy_score,
    classification_report,
    plot_confusion_matrix,
) sklearn.feature_extraction.text TfidfVectorizer, CountVectorizer string punctuation nltk.tokenize word_tokenize nltk nltk.corpus stopwords nltk.stem WordNetLemmatizer re dependency ( , , , , ,
):
    nltk.download(dependency) warnings
warnings.filterwarnings( ) np.random.seed( ) # import important modules import as import as # sklearn modules from import from import from import # classifier from import from import # text preprocessing modules from import # text preprocessing modules from import import from import from import import #regular expression # Download dependency for in "brown" "names" "wordnet" "averaged_perceptron_tagger" "universal_tagset" import "ignore" # seeding 123 Load the dataset from the data folder. data = pd.read_csv( , sep= ) # load data "../data/labeledTrainData.tsv" '\t' Show sample of the dataset. data.head() # show top five rows of data Our dataset has 3 columns. - This is the id of the review Id - either positive(1) or negative(0) Sentiment - comment about the movie Review Check the shape of the dataset. data.shape # check the shape of the data (25000, 3) The dataset has 25,000 reviews. We need to check if the dataset has any missing values. data.isnull().sum() # check missing values in data id                   0 sentiment    0 review           0 dtype: int64 The output shows that our dataset does not have any missing values. How to Evaluate Class Distribution We can use the method from the pandas package to evaluate the class distribution from our dataset. value_counts() data.sentiment.value_counts() # evalute news sentiment distribution 1    12500 0    12500 Name: sentiment, dtype: int64 In this dataset, we have an equal number of positive and negative reviews. How to Process the Data After analyzing the dataset, the next step is to preprocess the dataset into the right format before creating our machine learning model. The reviews in this dataset contain a lot of unnecessary words and characters that we don't need when creating a machine learning model. We will clean the messages by removing stopwords, numbers, and punctuation. Then we will convert each word into its base form by using the lemmatization process in the NLTK package. The function will handle all necessary steps to clean our dataset. text_cleaning() stop_words =  stopwords.words( ) text = re.sub( , , text)
    text = re.sub( , , text)
    text =  re.sub( , , text)
    text = re.sub( , , text) text = .join([c c text c punctuation]) remove_stop_words:
        text = text.split()
        text = [w w text w stop_words]
        text = .join(text) lemmatize_words:
        text = text.split()
        lemmatizer = WordNetLemmatizer() 
        lemmatized_words = [lemmatizer.lemmatize(word) word text]
        text = .join(lemmatized_words) (text) 'english' : def text_cleaning (text, remove_stop_words=True, lemmatize_words=True) # Clean the text, with the option to remove stop_words and to lemmatize word # Clean the text r"[^A-Za-z0-9]" " " r"\'s" " " r'http\S+' ' link ' r'\b\d+(?:\.\d+)?\s+' '' # remove numbers # Remove punctuation from text '' for in if not in # Optionally, remove stop words if for in if not in " " # Optionally, shorten words to their stems if for in " " # Return a list of words return Now we can clean our dataset by using the function. text_cleaning() data[ ] = data[ ].apply(text_cleaning) #clean the review "cleaned_review" "review" Then split data into feature and target variables. X = data[ ]
y = data.sentiment.values #split features and target from  data "cleaned_review" Our feature for training is the variable and the target is the variable. cleaned_review sentiment We then split our dataset into train and test data. The test size is 15% of the entire dataset. X_train, X_valid, y_train, y_valid = train_test_split(
    X,
    y,
    test_size= ,
    random_state= ,
    shuffle= ,
    stratify=y,
) # split data into train and validate 0.15 42 True How to Actually Create Our NLP Model We will train the Multinomial Naive Bayes algorithm to classify if a review is positive or negative. This is one of the most common algorithms used for text classification. But before training the model, we need to transform our cleaned reviews into numerical values so that the model can understand the data. In this case, we will use the method from scikit-learn. TfidfVectorizer will help us to convert a collection of text documents to a matrix of TF-IDF features. TfidfVectorizer To apply this series of steps(pre-processing and training), we will use a from scikit-learn that sequentially applies a list of transforms and a final estimator. Pipeline class sentiment_classifier = Pipeline(steps=[
                                 ( ,TfidfVectorizer(lowercase= )),
                                 ( ,MultinomialNB())
                                 ]) # Create a classifier in pipeline 'pre_processing' False 'naive_bayes' Then we train our classifier. sentiment_classifier.fit(X_train,y_train) # train the sentiment classifier We then create a prediction from the validation set. y_preds = sentiment_classifier.predict(X_valid) # test model performance on valid data The model's performance will be evaluated by using the evaluation metric. We use accuracy_score because we have an equal number of classes in the sentiment variable. accuracy_score accuracy_score(y_valid,y_preds) 0.8629333333333333 The accuracy of our model is around which is a good performance. 86.29% Save Model Pipeline The model pipeline will be saved in the model’s directory by using the python package. joblib joblib 

joblib.dump(sentiment_classifier, ) #save model import '../models/sentiment_model_pipeline.pkl' Wrapping Up Congratulations 👏👏, you have made it to the end of this part 1. I hope you have learned something new on how to build a NLP model. In part 2 we will learn how to deploy our NLP model with FastAPI and run it in python applications. If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in part 2! You can also find me on Twitter . @Davis_McDavid And you can read more articles like this . here For more AI and machine learning guides, be sure to in the footer below. subscribe to our newsletter

How To Build and Deploy an NLP Model with FastAPI: Part 1

provides an SDK and robust back-end for real time chat applications, but it’s missing a front-end. If you need a chat UI, as well as a whole bunch of other useful components, then might be what you’re looking for. Twilio Programmable Chat KendoReact Kendo UI provides well designed and tested components that you can use within your , , and applications. In this post we will build a Twilio Chat application with React and the components. React Angular Vue jQuery KendoReact conversational UI What you’ll need If you want to build along with this tutorial, then you’ll need a few things: A Twilio account (you can ) sign up for a Twilio account for free here A and an , both of which you can create in the (keep these nearby, you’ll need them soon) Twilio Chat service API key and secret Twilio console to build our React app and to run our server (we need a server to generate access tokens to authenticate our users with Twilio Programmable Chat) Node.js If you want to skip ahead, you can check out . the code for this application in this GitHub repo Let’s get started We’re going to use the that I built in as the basis for this app. This app gives us an easy way to run a Node.js server and React front-end with one command and comes with endpoints ready to create Access Tokens for Twilio Programmable Chat. or clone the application, change into the directory, and install the dependencies: React and Express starter application this post Download git clone -b twilio https://github.com/philnash/react-express-starter.git twilio-chat-kendocd twilio-chat-kendonpm install Copy the file to then fill in the blanks with your Twilio account SID, the chat service, and API keys you generated earlier. .env.example .env cp .env.example .env Run the application to make sure everything is working so far. On the command line run: npm run dev You will see an application that looks like this open in your browser at localhost:3000. We have our Twilio Chat application ready and our React app set up. Let’s get building. Preparing to chat There’s a bit of work we need to do before we start on the chat integration. We need to install some dependencies, remove the example app, and add a bit of style. Let’s start with those dependencies. We’ll need the module to connect with Twilio Chat and then a few KendoReact modules that will provide the components we're going to use: twilio-chat npm install twilio-chat @progress/kendo-react-conversational-ui \@progress/kendo-react-inputs @progress/kendo-react-buttons \@progress/kendo-react-intl @progress/kendo-theme-material Next, strip back to the basics, including the CSS for the KendoReact Material theme: src/App.js import React, { Component } from 'react';import '@progress/kendo-theme-material/dist/all.css'; class App extends Component {constructor(props) {super(props);} render() {return <p>Hello world</p>;}} export default App; To give the application a bit more style and layout (without too much effort) add the Bootstrap CSS to the of : <head> public/index.html <!DOCTYPE html><html lang="en"><head><title>React App</title><linkrel="stylesheet"href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css"integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO"crossorigin="anonymous"/></head> With that done it’s time to build our first component. Building a login form For users to join our chat we need them to log in and choose a username. If you are building this into an existing application, you probably already have users and a login system. For this post we’re just going to fake it by presenting a login form that asks for a username. Create a new file, , and open it up. We'll make this a as the login form itself doesn't need to store any state. Start with the following boilerplate: src/Login.js functional component import React from 'react'; const Login = props => {return;};export default Login; To make our Login form fit in with our conversational UI, we’ll use KendoReact components. At the top import the and components: Button Input import React from 'react';import { Button } from '@progress/kendo-react-buttons';import { Input } from '@progress/kendo-react-inputs'; Modify the function to return the following JSX: Login const Login = props => {return (<form className="k-form" onSubmit={props.handleLogin}><fieldset><legend>Log in</legend><div className="mb-3"><Inputname="username"label="Username"required={true}style={{ width: '100%' }}value={props.username}onChange={props.handleUsernameChange}/></div><div><Button type="submit" primary={true}>Sign in</Button></div></fieldset></form>);}; That’s quite the chunk of JSX, so let’s break it down. The whole thing is a containing a and . Then inside there is an component and a component. These are the KendoReact components that we imported. They act like regular and elements but fit in with the KendoReact style. <form> <fieldset> <legend> <Input> <Button> <input> <button> The JSX also includes some properties we need to provide the component with; a username and two functions to handle events. We’ll add these to the component so we can pass them in as properties. <App> Open up and start by importing the new component. src/App.js <Login> import React, { Component } from 'react';import '@progress/kendo-theme-material/dist/all.css';import Login from './Login'; Define the two functions that we’ll be passing to the component. One function needs to handle the user typing in the input and update the username stored in the state. The other handles the form being submitted and will set the state to show that the user is logged in. Add these below the component's constructor in : <Login> <App> src/App.js handleLogin(event) {event.preventDefault();this.setState({ loggedIn: true });}handleUsernameChange(event) {this.setState({ username: event.target.value });} In the constructor we need to initialise the state and bind these functions to the component: constructor(props) {super(props);this.state = {username: '',loggedIn: false};this.handleLogin = this.handleLogin.bind(this);this.handleUsernameChange = this.handleUsernameChange.bind(this);} Now let’s update the function to show the username if the state says the user is logged in, and the component otherwise. render <Login> render() {let loginOrChat;if (this.state.loggedIn) {loginOrChat = <p>Logged in as {this.state.username}</p>;} else {loginOrChat = (<LoginhandleLogin={this.handleLogin}handleUsernameChange={this.handleUsernameChange}username={this.state.username}/>);}return (<div className="container"><div className="row mt-3 justify-content-center">{loginOrChat}</div></div>);} If your application is still running, return to the browser and you will see the login form. Otherwise start the app with and open . Enter your name in the form and press enter or click "Sign in". npm run dev localhost:3000 Hooking up Programmable Chat Now we can use the username to generate an access token, and connect our logged in user with chat. Create a new file called and open it up. We'll create a class based component for the chat app, so add the following boilerplate: src/ChatApp.js import React, { Component } from 'react'; class ChatApp extends Component {} export default ChatApp; There are a few things we need to do in this component: Retrieve an access token from the server and initialise the Twilio Chat client Setup a chat channel and join it, loading any existing messages Create a function to send a message Render the KendoReact Conversational UI Before any of that we’ll need to import two modules; twilio-chat and the KendoReact conversationalUI. At the top of add: src/ChatApp.js import React, { Component } from 'react';import Chat from 'twilio-chat';import { Chat as ChatUI } from '@progress/kendo-react-conversational-ui'; Let’s set up some initial state in the constructor too. We’ll need a list of messages, an error state in case anything goes wrong, and a boolean to show if the chat is loading, which will start as . true class ChatApp extends Component {constructor(props) {super(props);this.state = {error: null,isLoading: true,messages: []};}} Getting an access token The starter project is already setup to return a token when we pass an identity to the endpoint. We'll use the API to make the request as part of the lifecycle event. We use here as the React documentation tells us that this is a good place to load external data. /chat/token fetch componentDidMount componentDidMount The response with the access token will be JSON, so we’ll need to parse it using the response object’s method then once it's parsed, we can use the token to initialise the Chat client. json Creating the Chat client returns a promise so we can chain all these methods. Once the Chat client is created we will pass off to another method to finish the setup. We should also handle any errors with a method. catch Add this code to the class below the constructor: ChatApp componentDidMount() {fetch('/chat/token', {headers: { 'Content-Type': 'application/x-www-form-urlencoded' },method: 'POST',body: `identity=${encodeURIComponent(this.props.username)}`}).then(res => res.json()).then(data => Chat.create(data.token)).then(this.setupChatClient).catch(this.handleError);} Write the method to handle the error. We’ll set a message in the state and log the full error so we can debug if we have any trouble. handleError(error) {console.error(error);this.setState({error: 'Could not load chat.'});} Setting up a Chat channel We’ve initialised our Chat client with an access token but there’s more to do. Once the promise resolves we need to use the new chat client to join a channel. As this is our first time through the process we’ll check to see if the channel exists. If so, we’ll attempt to join it; otherwise, we’ll create it then join it. Add the following method to the class: setupChatClient setupChatClient(client) {this.client = client;this.client.getChannelByUniqueName('general').then(channel => channel).catch(error => {if (error.body.code === 50300) {return this.client.createChannel({ uniqueName: 'general' });} else {this.handleError(error);}}).then(channel => {this.channel = channel;return this.channel.join().catch(() => {});}).then(() => {// Success!}).catch(this.handleError);} We catch the error in the middle in case the channel doesn’t exist (a 50300 error) and create the channel. Also, if joining a channel throws an error we catch it and do nothing. This handles the case when the user is already a member of the channel. If everything works the code will get to the success comment. At this stage the channel has loaded, so we can set our state variable to . We also need to load existing messages and set up a listener for new messages. isLoading false Replace the comment above with: // Success! .then(() => {  
    this.setState({ isLoading: false });  
    this.channel.getMessages().then(this.messagesLoaded);  
    this.channel.on('messageAdded', this.messageAdded);  
  }) Receiving Messages We need to write the and methods we just referenced above, but before we do we need to consider the . We need to translate the message object from the format Twilio provides it to that which can be used by the conversational UI component. messagesLoaded messageAdded format that the KendoReact conversational UI wants the messages Let’s write a function that can take a and return a message object for KendoReact: message from the Chat service twilioMessageToKendoMessage(message) {return {text: message.body,author: { id: message.author, name: message.author },timestamp: message.timestamp};} Now we can write the and methods. runs when we first load the existing messages to a channel so we fill up with all the messages we receive. messagesLoaded messageAdded messagesLoaded state.messages messagesLoaded(messagePage) {this.setState({messages: messagePage.items.map(this.twilioMessageToKendoMessage)});} will receive one message as its argument so we use the callback version of to add the message to the list. Note we also use the spread operator ( ) to copy the existing messages into the new state. messageAdded [setState](https://reactjs.org/docs/react-component.html#setstate) ... messageAdded(message) {this.setState(prevState => ({messages: [...prevState.messages,this.twilioMessageToKendoMessage(message)]}));} Sending messages We also need a function to send a message to a channel. This function will be called by the KendoReact Conversational UI when a user types a message in the message box and sends it by clicking the send button or pressing enter. To handle it, we need to send the message text onto the channel. Displaying the message will be handled by the existing event we are listening to on the channel. messageAdded Add the following function to the class: ChatApp sendMessage(event) {this.channel.sendMessage(event.message.text);} Tidying up and rendering the Conversational UI We have some final parts to complete before we can see the chat in action. We should handle the component being unmounted. We can do this by shutting the chat client instance down. componentWillUnmount() {this.client.shutdown();} The Conversational UI expects a user object, which we will create using our user identity. We also need to bind all of our callback functions to the component. Add the following to the constructor: constructor(props) {super(props); this.state = {  
  error: null,  
  isLoading: true,  
  messages: \[\]  
};  
this.user = {  
  id: props.username,  
  name: props.username  
};  

this.setupChatClient = this.setupChatClient.bind(this);  
this.messagesLoaded = this.messagesLoaded.bind(this);  
this.messageAdded = this.messageAdded.bind(this);  
this.sendMessage = this.sendMessage.bind(this);  
this.handleError = this.handleError.bind(this); } Rendering the chat Now we have everything in place we can render the Conversational UI. Create a method in that handles the various states of the component. If there are errors or if the chat is still loading, we will render a message, otherwise we will render the KendoReact Conversational UI component, passing the user object, the messages and the callback method to be run when the user sends a message. render src/ChatApp.js render() {if (this.state.error) {return <p>{this.state.error}</p>;} else if (this.state.isLoading) {return <p>Loading chat...</p>;}return (<ChatUIuser={this.user}messages={this.state.messages}onMessageSend={this.sendMessage}width={500}/>);} Lastly we need to render this entire component from the component. Import the component at the top of . <App> <ChatApp> src/App.js import React, { Component } from 'react';import Login from './Login';import ChatApp from './ChatApp';import '@progress/kendo-theme-material/dist/all.css'; Now update the function of the to return the component when the user is logged in. render <App> component <ChatApp> render() {let loginOrChat;if (this.state.loggedIn) {loginOrChat = <ChatApp username={this.state.username} />;} else {loginOrChat = (<LoginhandleLogin={this.handleLogin}handleUsernameChange={this.handleUsernameChange}username={this.state.username}/>);}return (<div className="container"><div className="row mt-3">{loginOrChat}</div></div>); Reload the app, login and start chatting. You can open another browser window and login with a different name to see the messages going back and forth. This is just the start is a powerful SDK for chatting and makes it really easy to display the chat in a React application. Most of the work we had to do was generating an access token and setting up the Twilio Chat. Once we’d written a couple of functions that translated the messages from Twilio to KendoReact and from KendoReact to Twilio the UI just fell into place. Twilio Programmable Chat KendoReact’s Conversational UI You can get all the code for this application in the . GitHub repo Check out the for other features of this UI, such as , useful when the other side is a bot, and , for ways to display media messages or other views, like lists or carousels, within your chat. KendoReact documentation suggested actions message attachments The KendoReact Conversational UI is also available for , and if you prefer a different framework, and there are plenty of other useful components you could use to build your application. jQuery Angular Vue Have you used KendoReact before? Or are you building chat into your app and on the lookout for a sweet UI? Let me know what you think in the comments or on . Twitter at @philnash Originally published at www.twilio.com .

Build a Chat App with Twilio and KendoReact

Find the right React Unit Test Tools Pick up the right Unit Test tool for React Component is confusing, as the result of from google, hundreds of combination of chai+jsdom, jest+mocha, mocha+enzyme etc, come up to my eyes. Hey, Google, Can you just tell me the BESTest one and don’t make me think? ‘react unit test’ Unit Test of React Component is a bit different, rather than verifying output of functions, Unit Test in React requires 4 extra testing purpose ( ): Ref Artem Testing basic component rendering Testing props Testing events Testing event handlers Two most popular options are and . After spending hours in try out those tools, I end up in the great Jest Enzyme Airbnb open sourced Enzyme. jest is a JavaScript test runner maintained by Facebook. Included performance, mocking, , code coverage, sandbox. Jest snapshot When using Jest to test a React or React Native application, you can write a snapshot test that will save the output of a rendered component to file and compare the component’s output to the snapshot on subsequent runs. This is useful in knowing when your component changes its behaviour. jsdom + Mocha provides React the required DOM to render to, implementing a suitable subset of browser’s DOM implementations entirely in node/io.js. jsdom Enzyme is a library that wraps packages like , and to create a simpler interface for writing unit tests (work with shallow rendering). React TestUtils JSDOM CheerIO Example This is the of the example using E to test React component: git nzyme Install $ git clone https://github.com/wahengchang/react-test-must-know$ npm install Run Tests $ npm test > jest**PASS ** src/__tests__/**simpleFoo-test.jsPASS ** src/__tests__/ Foo-test.js **Test Summary**› Ran all tests. (7 total in 2 test suites, run time 2.08s) › 7 tests passed Should know 1.Verfity values of state/proprs in a component const wrapper = shallow(<ComponentName />);

expect(wrapper.state().data).toBe('something');expect(wrapper.props().data).toBe('something'); 2.Verfity values of tag in a component const wrapper = shallow(<ComponentName />);

expect(wrapper.find('h4').length).toBe(1);expect(wrapper.find('h4').at(0).text()).toBe('Something'); 3.Simulating click event of a button const wrapper = shallow(<ComponentName />);

expect(wrapper.state().data).toBe('state1');wrapper.find('button').simulate('click');expect(wrapper.state().data).toBe('state2'); Trick Asserting style ( ) from wrapper.find('.myClassname') .get(0).style;   expect(containerStyle).to.have.property('opacity', '1'); Asserting class name ( ) from const span = mount(<Test />).find('span');expect(span.html().match(/style="([^"]*)"/i)[1]).toBe('color: #000;'); *Remark Shallow Rendering testing a component as a unit, import { shallow } from 'enzyme';const wrapper = shallow(<MyComponent />); Full Rendering Components that may with DOM APIs, or may require the full lifecycle in order to fully test the component (i.e., etc.) interact componentDidMount i mport { mount } from 'enzyme';      const wrapper = **mount**(<MyComponent />); Static Rendering It is used to render react components to and analyze the resulting HTML structure. static HTML import { render } from 'enzyme';const wrapper = render(<MyComponent />); enzyme.wraper A wrapper refers to the enzyme wrapper class that provides the API ( ). more wrapper. (Foo)wrapper. ('.icon-star')wrapper. ('button').simulate('click')wrapper. (<div className="unique" />)wrapper. ().datawrapper. ().data find find find contains props state Reference: https://github.com/wahengchang/react-test-must-know http://blog.iannelson.systems/12-reasons-why-i-love-unit-tests/ https://github.com/facebook/jest/blob/master/examples/snapshot/Link.react.js https://github.com/facebook/jest https://facebook.github.io/jest/docs/tutorial-react.html https://github.com/facebook/jest/tree/master/examples/snapshot https://www.codementor.io/vijayst/unit-testing-react-components-jest-or-enzyme-du1087lh8 https://hackernoon.com/testing-react-components-with-jest-and-enzyme-41d592c174f#.d3lo5wnl5 http://airbnb.io/enzyme/docs/api/shallow.html

[React] Review: Component Unit Test is easy

Cold outreach isn’t easy. There's always the risk of coming across as something we definitely don't want to be: a spammer. As I wrapped up my coffee order and went to my favorite spot, a message popped up from someone I cold DM’d on LinkedIn. A heartfelt message: “Hey, I don’t need your tool. But thanks to you, now I know that I need to find a way to block spammers like you.” "Gosh," I sweat. “Wait, was I just scolded? Did I just become the very thing I don’t like the most - a spammer?” How did this happen? It was the early days of our startup journey. We had just finished the first prototype and were eager to find our first users. Inspired by the gospel of "doing things that don’t scale," I decided it was time to start reaching out. Aware of how irritating it can be to receive unsolicited messages, I was determined to approach outreach in the most appropriate manner possible. 1. Only target those who fit our ideal audience profile 2. Craft a message addressing their potential pain points and how our product can help them Then I put in the work. First, I registered for LinkedIn Premium, using its tools to find the best matches based on our ideal persona. I scoured the platform, wholeheartedly selecting the top 50 potential users. Then, I spent more days crafting the perfect outreach message, obsessing over every comma, and double-checking for any grammar errors. I even compared my message to the best templates on LinkedIn lol. Filled with both hope and worry, I finally hit send. About 5 to 10 people accepted InMail, and only 2 or 3 replied. Unfortunately, none of the responses were positive. Then I immediately found the solution and get 80% CVR! No, it didn’t happen. After that incident, I turned my efforts to Reddit, as my previous first post mentioned, and I got some traction there. Quit hard selling As time passed, I looked at LinkedIn again and reflected on it. As I stepped into the shoes of the recipients, it dawned on me: no matter how well-crafted the message, problems, and solutions, or how perfectly their profiles aligned with the target persona, if they didn't have the need, hard selling them something would only feel like spam. That’s why I find LinkedIn more valuable for a different reason: Understanding target users. It's about understanding their challenges with note-taking and what they're looking to solve. It's not optimal to sell anything when you're clueless about users’ pain points. With this mindset, I shifted gears and saw remarkable outcomes (with hard work, of course; nothing is easy at this stage, haha): I got hundreds of interview hours with our target audience, helping us understand their problems, their pain points, and what we need to serve them better with Saner.ai And there you have it, LinkedIn - from being scolded to having hundreds of insightful conversations. Next up, User interviews: Uhm, do I really have to do them? I'm kinda shy… Cold outreach isn’t easy. There's always the risk of coming across as something we definitely don't want to be: a spammer. As I wrapped up my coffee order and went to my favorite spot, a message popped up from someone I cold DM’d on LinkedIn. A heartfelt message: “Hey, I don’t need your tool. But thanks to you, now I know that I need to find a way to block spammers like you.” "Gosh," I sweat. “Wait, was I just scolded? Did I just become the very thing I don’t like the most - a spammer?” How did this happen? It was the early days of our startup journey. We had just finished the first prototype and were eager to find our first users. Inspired by the gospel of "doing things that don’t scale," I decided it was time to start reaching out. Aware of how irritating it can be to receive unsolicited messages, I was determined to approach outreach in the most appropriate manner possible. 1. Only target those who fit our ideal audience profile 2. Craft a message addressing their potential pain points and how our product can help them Then I put in the work. First, I registered for LinkedIn Premium, using its tools to find the best matches based on our ideal persona. I scoured the platform, wholeheartedly selecting the top 50 potential users. Then, I spent more days crafting the perfect outreach message, obsessing over every comma, and double-checking for any grammar errors. I even compared my message to the best templates on LinkedIn lol. Filled with both hope and worry, I finally hit send. About 5 to 10 people accepted InMail, and only 2 or 3 replied. Unfortunately, none of the responses were positive. Then I immediately found the solution and get 80% CVR! No, it didn’t happen. After that incident, I turned my efforts to Reddit , as my previous first post mentioned, and I got some traction there. turned my efforts to Reddit Quit hard selling As time passed, I looked at LinkedIn again and reflected on it. As I stepped into the shoes of the recipients, it dawned on me: no matter how well-crafted the message, problems, and solutions, or how perfectly their profiles aligned with the target persona, if they didn't have the need, hard selling them something would only feel like spam. if they didn't have the need, hard selling them something would only feel like spam. That’s why I find LinkedIn more valuable for a different reason: Understanding target users. Understanding target users. It's about understanding their challenges with note-taking and what they're looking to solve. It's not optimal to sell anything when you're clueless about users’ pain points. With this mindset, I shifted gears and saw remarkable outcomes (with hard work, of course; nothing is easy at this stage, haha): I got hundreds of interview hours with our target audience, helping us understand their problems, their pain points, and what we need to serve them better with Saner.ai And there you have it, LinkedIn - from being scolded to having hundreds of insightful conversations. Next up, User interviews: Uhm, do I really have to do them? I'm kinda shy…

How I Succeed With Cold Outreach On LinkedIn

Authors:
(1) Vasiliki Kougia, University of Vienna, Faculty of computer science, Vienna, Austria & UniVie Doctoral School Computer Science, Vienna, Austria;
(2) Simon Fetze, University of Vienna, Faculty of computer science, Vienna, Austria;
(3) Thomas Kirchmair, University of Vienna, Faculty of computer science, Vienna, Austria;
(4) Erion Çano, University of Vienna, Faculty of computer science, Vienna, Austria;
(5) Sina Moayed Baharlou, Boston University, Department of Electrical and Computer Engineering, Boston, MA, USA;
(6) Sahand Sharifzadeh, Ludwig Maximilians University of Munich, Faculty of Computer Science, Munich, Germany;
(7) Benjamin Roth, University of Vienna, Faculty of computer science, Vienna, Austria. Table of Links Abstract and Introduction Related Work MemeGraphs Benchmarking Analysis Conclusion, Acknowledgments, and References ABSTRACT Memes are a popular form of communicating trends and ideas in social media and on the internet in general, combining the modalities of images and text. They can express humor and sarcasm but can also have offensive content. Analyzing and classifying memes automatically is challenging since their interpretation relies on the understanding of visual elements, language, and background knowledge. Thus, it is important to meaningfully represent these sources and the interaction between them in order to classify a meme as a whole. In this work, we propose to use scene graphs, that express images in terms of objects and their visual relations, and knowledge graphs as structured representations for meme classification with a Transformer-based architecture. We compare our approach with ImgBERT, a multimodal model that uses only learned (instead of structured) representations of the meme, and observe consistent improvements. We further provide a dataset with human graph annotations that we compare to automatically generated graphs and entity linking. Analysis shows that automatic methods link more entities than human annotators and that automatically generated graphs are better suited for hatefulness classification in memes. Keywords hate speech · internet memes · knowledge graphs · multimodal representations. 1 Introduction Internet memes are items such as images, videos, or twitter posts that are widely shared on social media and typically relate to several subjects, such as politics, social, news, and current internet trends.[1] Memes are a popular form of communication and they are often used as a means to express an opinion or stance in a humorous or sarcastic manner, but they can also be hateful and promote problematic content that is likely to hurt specific groups of people and hence be harmful to society in general [2]. Thus, analyzing trending memes can provide insight into people’s reactions and opinions to important societal matters, as well as to the traits of different groups. This can help in tasks like filtering out harmful memes from internet platforms or extracting user opinions for socioeconomic studies. This work focuses on memes in the form of images with some form of superimposed text (sometimes referred to with the technical term image macros) with the goal of detecting hateful content. Lately, there has been increased interest in deep learning models for analyzing memes and classifying them [23, 10, 11], for example in the context of the Hateful Memes competition organized by Facebook [13] and the shared task in the Workshop on Online Abuse and Harms (WOAH) 2021 that was the continuation of the first competition [21]. Another shared task in Semeval 2022 aimed at detecting misogyny in memes [11]. Alongside these shared tasks, the corresponding datasets were published with human annotations capturing important properties such as hatefulness and misogyny. Recent works use multimodal representation learning based on image features from Convolutional Neural Networks (CNNs), Transformer-based language models for the text [13, 3, 14] or multimodal (vision+language) Transformer models in order to classify memes [13]. Some works additionally incorporate specifically extracted image  features such as race [33], person attributes [1, 23], and automatic image captioning output [7, 4]. However, none of these works have included the relations between objects in the form of scene graphs or background knowledge in the form of a text description for the objects depicted in the image. In this paper, we address the issue of classifying hateful memes by performing an automated augmentation in order to represent the visual information and background knowledge (Fig. 1). We built on the MultiOFF dataset, which contains memes extracted from social media during the 2016 U.S. Presidential Election [28]. An off-the-shelf scene graph generation model was employed to produce scene graphs, which contain detected visual objects and relations between them for each meme, and a NER model to detect entities that we linked to background knowledge. The scene graphs were serialized as text resulting in a unified way to represent all the modalities expressed in a meme. This allows using a (unimodal) text classifier to classify the multimodal memes. Hence, we incorporated the automatically produced augmentations to classify the memes using a text-based Transformer model and show that they can improve its performance. The explicit representation of the image as serialized tokens also provides a more interpretable intermediate representation (compared to hidden layers in multimodal models such as ImgBERT [13, 14]). Furthermore, in order to examine how the results of the automatic augmentation would deviate from human ones, we performed manual augmentation. Two human evaluators corrected the automatically produced scene graphs and manually added background knowledge. We compare our automatic MemeGraphs method with models operating on the manually augmented data (only for training or for both training and inference) and find that automatic augmentations assist in achieving better results than manual ones. Contribution Our contributions can be summarized as follows: • We propose MemeGraphs, a novel method for classifying memes utilizing scene graphs augmented with knowledge and providing insights for processing multimodal documents. • We show that adding this kind of knowledge to a text-based Transformer model can improve its classification performance. Furthermore, we show that this yields improvements compared to a simple model only using learned representations to classify the memes, such as ImgBERT. • We conduct extensive experiments with manual and automatic settings for obtaining this knowledge and show that the automatic setting of our MemeGraphs method provides more meaningful information. In the following, we discuss related work and present our MemeGraphs method. Subsequently, in Section 4, we describe the models we implemented and report their results. Finally, we provide a qualitative analysis, including a discussion of the findings of human augmentation, and compare this with the automatic MemeGraphs method.[2] [1] Disclaimer: This paper contains examples of hateful content. [2] The code and data for the MemeGraphs method are available on: https://github.com/vasilikikou/memegraphs. This paper is available on arxiv under CC 4.0 license. Authors: (1) Vasiliki Kougia, University of Vienna, Faculty of computer science, Vienna, Austria & UniVie Doctoral School Computer Science, Vienna, Austria; (2) Simon Fetze, University of Vienna, Faculty of computer science, Vienna, Austria; (3) Thomas Kirchmair, University of Vienna, Faculty of computer science, Vienna, Austria; (4) Erion Çano, University of Vienna, Faculty of computer science, Vienna, Austria; (5) Sina Moayed Baharlou, Boston University, Department of Electrical and Computer Engineering, Boston, MA, USA; (6) Sahand Sharifzadeh, Ludwig Maximilians University of Munich, Faculty of Computer Science, Munich, Germany; (7) Benjamin Roth, University of Vienna, Faculty of computer science, Vienna, Austria. Authors: Authors: (1) Vasiliki Kougia, University of Vienna, Faculty of computer science, Vienna, Austria & UniVie Doctoral School Computer Science, Vienna, Austria; (2) Simon Fetze, University of Vienna, Faculty of computer science, Vienna, Austria; (3) Thomas Kirchmair, University of Vienna, Faculty of computer science, Vienna, Austria; (4) Erion Çano, University of Vienna, Faculty of computer science, Vienna, Austria; (5) Sina Moayed Baharlou, Boston University, Department of Electrical and Computer Engineering, Boston, MA, USA; (6) Sahand Sharifzadeh, Ludwig Maximilians University of Munich, Faculty of Computer Science, Munich, Germany; (7) Benjamin Roth, University of Vienna, Faculty of computer science, Vienna, Austria. Table of Links Abstract and Introduction Abstract and Introduction Related Work Related Work MemeGraphs MemeGraphs Benchmarking Benchmarking Analysis Analysis Conclusion, Acknowledgments, and References Conclusion, Acknowledgments, and References ABSTRACT Memes are a popular form of communicating trends and ideas in social media and on the internet in general, combining the modalities of images and text. They can express humor and sarcasm but can also have offensive content. Analyzing and classifying memes automatically is challenging since their interpretation relies on the understanding of visual elements, language, and background knowledge. Thus, it is important to meaningfully represent these sources and the interaction between them in order to classify a meme as a whole. In this work, we propose to use scene graphs, that express images in terms of objects and their visual relations, and knowledge graphs as structured representations for meme classification with a Transformer-based architecture. We compare our approach with ImgBERT, a multimodal model that uses only learned (instead of structured) representations of the meme, and observe consistent improvements. We further provide a dataset with human graph annotations that we compare to automatically generated graphs and entity linking. Analysis shows that automatic methods link more entities than human annotators and that automatically generated graphs are better suited for hatefulness classification in memes. Keywords hate speech · internet memes · knowledge graphs · multimodal representations. Keywords Keywords 1 Introduction Internet memes are items such as images, videos, or twitter posts that are widely shared on social media and typically relate to several subjects, such as politics, social, news, and current internet trends.[1] Memes are a popular form of communication and they are often used as a means to express an opinion or stance in a humorous or sarcastic manner, but they can also be hateful and promote problematic content that is likely to hurt specific groups of people and hence be harmful to society in general [2]. Thus, analyzing trending memes can provide insight into people’s reactions and opinions to important societal matters, as well as to the traits of different groups. This can help in tasks like filtering out harmful memes from internet platforms or extracting user opinions for socioeconomic studies. This work focuses on memes in the form of images with some form of superimposed text (sometimes referred to with the technical term image macros) with the goal of detecting hateful content. Lately, there has been increased interest in deep learning models for analyzing memes and classifying them [23, 10, 11], for example in the context of the Hateful Memes competition organized by Facebook [13] and the shared task in the Workshop on Online Abuse and Harms (WOAH) 2021 that was the continuation of the first competition [21]. Another shared task in Semeval 2022 aimed at detecting misogyny in memes [11]. Alongside these shared tasks, the corresponding datasets were published with human annotations capturing important properties such as hatefulness and misogyny. Recent works use multimodal representation learning based on image features from Convolutional Neural Networks (CNNs), Transformer-based language models for the text [13, 3, 14] or multimodal (vision+language) Transformer models in order to classify memes [13]. Some works additionally incorporate specifically extracted image  features such as race [33], person attributes [1, 23], and automatic image captioning output [7, 4]. However, none of these works have included the relations between objects in the form of scene graphs or background knowledge in the form of a text description for the objects depicted in the image. In this paper, we address the issue of classifying hateful memes by performing an automated augmentation in order to represent the visual information and background knowledge (Fig. 1). We built on the MultiOFF dataset, which contains memes extracted from social media during the 2016 U.S. Presidential Election [28]. An off-the-shelf scene graph generation model was employed to produce scene graphs, which contain detected visual objects and relations between them for each meme, and a NER model to detect entities that we linked to background knowledge. The scene graphs were serialized as text resulting in a unified way to represent all the modalities expressed in a meme. This allows using a (unimodal) text classifier to classify the multimodal memes. Hence, we incorporated the automatically produced augmentations to classify the memes using a text-based Transformer model and show that they can improve its performance. The explicit representation of the image as serialized tokens also provides a more interpretable intermediate representation (compared to hidden layers in multimodal models such as ImgBERT [13, 14]). Furthermore, in order to examine how the results of the automatic augmentation would deviate from human ones, we performed manual augmentation. Two human evaluators corrected the automatically produced scene graphs and manually added background knowledge. We compare our automatic MemeGraphs method with models operating on the manually augmented data (only for training or for both training and inference) and find that automatic augmentations assist in achieving better results than manual ones. Contribution Our contributions can be summarized as follows: Contribution • We propose MemeGraphs, a novel method for classifying memes utilizing scene graphs augmented with knowledge and providing insights for processing multimodal documents. • We show that adding this kind of knowledge to a text-based Transformer model can improve its classification performance. Furthermore, we show that this yields improvements compared to a simple model only using learned representations to classify the memes, such as ImgBERT. • We conduct extensive experiments with manual and automatic settings for obtaining this knowledge and show that the automatic setting of our MemeGraphs method provides more meaningful information. In the following, we discuss related work and present our MemeGraphs method. Subsequently, in Section 4, we describe the models we implemented and report their results. Finally, we provide a qualitative analysis, including a discussion of the findings of human augmentation, and compare this with the automatic MemeGraphs method.[2] [1] Disclaimer: This paper contains examples of hateful content. [2] The code and data for the MemeGraphs method are available on: https://github.com/vasilikikou/memegraphs. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

MemeGraphs: Linking Memes to Knowledge Graphs

As a marketer, you must know about various platforms that are a perfect place for generating leads for your business. You might already have been using Instagram, Facebook, and Twitter. The one platform you might not know about is LinkedIn. If you have yet to make the most out of this platform or if you have only dipped your toe into the lead generation opportunities it offers, now is the time to get started with LinkedIn. Chances are that your competitors are already using it, and it's never too late to catch up using advanced LinkedIn lead generation tools to find leads and convert them into customers. So, here's a guide on how to get B2B leads from LinkedIn. How to Create a LinkedIn Lead Generation Strategy? Generating leads on LinkedIn might feel a little overwhelming. But the truth is with little effort and time; you can become an expert in LinkedIn lead generation. For marketers who want to take the next step, here's how to use LinkedIn for lead generation: Optimize Your LinkedIn Page You can expect your website to generate leads if it's properly laid out, there are Smart SEO goals set up, it provides proper information, and its content is useful and up-to-date. Similarly, if your LinkedIn profile is optimized, your customers will buy from you. Now, you must be wondering: how to optimize your LinkedIn profile, so it is compelling enough for lead generation? Start by asking yourself the following questions that will justify what your audience expects from you: What information does your audience expect to see when they first land on your profile?
What phrases or keywords might your audience be looking for to assess your product or service? Use these questions to decide what to put on your profile that can attract your audience to your brand. Make sure to add a catchy headline and a to-the-point summary. Also, do not forget to add the visuals. It is estimated that profiles with visuals are more likely to be viewed as compared to others. So, select high-quality visuals that describe your brand products or services. Post-High-Quality Content on Your LinkedIn Page To make sure that your LinkedIn profile has a great online presence, consider posting high-quality content types. Featuring the content on your page can help you position yourself as a knowledgeable source that establishes credibility with potential clients. When you're known to be a valuable source, you will soon start connecting with like-minded professionals who match perfectly with your ideal customer profile. If you post regularly, your profile will be shown on your leads feed, and the familiarity will make it easier to build further conversations. If you think that your LinkedIn friends are professionals in your sector, the content you upload will expose you to new audiences. When your connections 'Like' a post you've created, it may appear in the feed of a new lead. This lead will see that your shared connection liked your post, attesting to your reliability and authority and maybe motivating them to make a connection request. To ensure that you are creating content your audience might want to see, follow your page analytics that resonates the most with them, and post content accordingly. Examine Your LinkedIn Profile Views Chances are you will get only 1-2 profile visits each day, and you will most likely ignore them. Do not do such a thing. Each profile view is worth a lot as it can be a possible lead you missed. It could also be a valuable lead that reaches out to you. They can be a potential client that matters more than a random name in your cold email list. There's a simple solution to this if you ignore your profile visits. Just select "Who viewed your profile" in your page dashboard, and scroll to the names that showed interest in your profile. Send a message to each one of them, and it's possible that some of them will be your potential leads and be interested in your product or service. Be a Part of Groups You must wonder how to get business leads from LinkedIn. Well, LinkedIn groups are the best way to do such a thing. There are thousands of LinkedIn groups that are relevant to you and your brand. Professionals use such groups to gain insight into their industry and also to engage with other members. The best part - these groups are private by default, so you can expect high-quality lead generation on LinkedIn. You could also create your own group from the start, but it can be a difficult and time-consuming thing to do. The best way to make the most out of such groups is to find the relevant, ready-made one. These are the groupings that contain your buyer persona and are closely related to the industry in which you operate. Small groups limit your lead potential, while large groups cause your message to get lost. It is best to aim for both. To make your opinion known, use the 'Discussion' option at the top of the group's site and post questions, comments, or assertions. Your messaging should be targeted to each group, and you should know who you're writing to so they can make the best judgment about your organization. Make Use of LinkedIn Automation Tools There are a bunch of the best LinkedIn automation tools like Dripify and Octopus CRM that marketers can use to boost a LinkedIn strategy. These tools let you automate your LinkedIn activity and help you generate potential leads for your brand. It enables you to automate message requests, schedule messages, and also track your responses. It saves you a lot of time by automating all your time-consuming activities on LinkedIn while you can focus on other relevant lead generation tasks. With automation tools, you can automate almost anything on LinkedIn in one command center and dashboard. You can develop LinkedIn lead-generation campaigns that might provide remarkable results. Also, you can keep an eye on these campaigns' performance and monitor your total LinkedIn lead generation progress. Nurture Connections Generating leads is only the first step toward having meaningful prospects. You can not expect each lead to be directly impressed by your product pitch; some of them need nurturing too. The first step towards moving a lead to a sales funnel is having a direct conversation with the connection. Send a custom connection request, and follow it up with a catchy InMail that urges them to respond. There's no secret recipe to being a perfect conversation starter, but personalization works best. Try to strike up a conversation about something you both have in common. Expect this process to take some time. Some of the questions you can ask the lead are: What challenges are they facing in their business?
What are long-term and immediate priorities? Finally, when the lead starts asking questions about your product, it's time for you to pitch them and turn the lead into a client. Give and Get Referrals One of the best LinkedIn marketing strategies is to give and get referrals. You should introduce yourself to each new lead as your network of first-degree relationships expands. Share your e-business card, if possible. Making the initial remark breaks the ice, allows for the prospect of collaboration, and lessens the awkwardness of asking them to be directed to someone else later. Look through a recent client's relationships to discover which ones might be helpful to your company. If you are confident enough in your relationship, send them a list of the individuals, and ask if they mind sending a brief introduction of you to each one. The worst-case scenario is that they refuse. A sales team knows how to ask and who to ask for referrals. They can outperform the competition, reach decision-makers in a single call, and develop connections that can lead to sales. Start Using LinkedIn for Lead Generation Now! Leads are like gold to salespeople and marketers. LinkedIn is the best way where you can generate potential leads for brands that can soon be converted into valuable clients. But even though LinkedIn lead generation might be profitable, it takes time to do. It is likely that you spend months without seeing any results if you don't use the proper tactics to target the appropriate audience. You have to be consistent with your lead generation strategy and take time to find valuable LinkedIn connections using the tips given in this guide. Optimize your profile, strike up meaningful conversations, or share high-quality content. Even then, not every prospect will turn into a sale - but you will have a great chance of converting those leads that are interested in buying from you!** As a marketer, you must know about various platforms that are a perfect place for generating leads for your business. You might already have been using Instagram, Facebook, and Twitter. The one platform you might not know about is LinkedIn. The one platform you might not know about is LinkedIn. If you have yet to make the most out of this platform or if you have only dipped your toe into the lead generation opportunities it offers, now is the time to get started with LinkedIn. Chances are that your competitors are already using it, and it's never too late to catch up using advanced LinkedIn lead generation tools to find leads and convert them into customers. So, here's a guide on how to get B2B leads from LinkedIn. LinkedIn lead generation tools LinkedIn lead generation tools How to Create a LinkedIn Lead Generation Strategy? Generating leads on LinkedIn might feel a little overwhelming. But the truth is with little effort and time; you can become an expert in LinkedIn lead generation. Generating leads on LinkedIn might feel a little overwhelming. But the truth is with little effort and time; you can become an expert in LinkedIn lead generation. For marketers who want to take the next step, here's how to use LinkedIn for lead generation: Optimize Your LinkedIn Page You can expect your website to generate leads if it's properly laid out, there are Smart SEO goals set up, it provides proper information, and its content is useful and up-to-date. Smart SEO goals Similarly, if your LinkedIn profile is optimized, your customers will buy from you. Now, you must be wondering: how to optimize your LinkedIn profile, so it is compelling enough for lead generation? how to optimize your LinkedIn profile, so it is compelling enough for lead generation? Start by asking yourself the following questions that will justify what your audience expects from you: What information does your audience expect to see when they first land on your profile? What phrases or keywords might your audience be looking for to assess your product or service? What information does your audience expect to see when they first land on your profile? What information does your audience expect to see when they first land on your profile? What phrases or keywords might your audience be looking for to assess your product or service? What phrases or keywords might your audience be looking for to assess your product or service? Use these questions to decide what to put on your profile that can attract your audience to your brand. Make sure to add a catchy headline and a to-the-point summary. Also, do not forget to add the visuals. It is estimated that profiles with visuals are more likely to be viewed as compared to others. So, select high-quality visuals that describe your brand products or services. Post-High-Quality Content on Your LinkedIn Page To make sure that your LinkedIn profile has a great online presence, consider posting high-quality content types. Featuring the content on your page can help you position yourself as a knowledgeable source that establishes credibility with potential clients. When you're known to be a valuable source, you will soon start connecting with like-minded professionals who match perfectly with your ideal customer profile. If you post regularly, your profile will be shown on your leads feed, and the familiarity will make it easier to build further conversations. If you think that your LinkedIn friends are professionals in your sector, the content you upload will expose you to new audiences. When your connections 'Like' a post you've created, it may appear in the feed of a new lead. This lead will see that your shared connection liked your post, attesting to your reliability and authority and maybe motivating them to make a connection request. To ensure that you are creating content your audience might want to see, follow your page analytics that resonates the most with them, and post content accordingly. Examine Your LinkedIn Profile Views Chances are you will get only 1-2 profile visits each day, and you will most likely ignore them. Do not do such a thing. Each profile view is worth a lot as it can be a possible lead you missed. It could also be a valuable lead that reaches out to you. They can be a potential client that matters more than a random name in your cold email list. There's a simple solution to this if you ignore your profile visits. Just select "Who viewed your profile" in your page dashboard, and scroll to the names that showed interest in your profile. Send a message to each one of them, and it's possible that some of them will be your potential leads and be interested in your product or service. Be a Part of Groups You must wonder how to get business leads from LinkedIn. Well, LinkedIn groups are the best way to do such a thing. There are thousands of LinkedIn groups that are relevant to you and your brand. Professionals use such groups to gain insight into their industry and also to engage with other members. You must wonder how to get business leads from LinkedIn. The best part - these groups are private by default, so you can expect high-quality lead generation on LinkedIn. You could also create your own group from the start, but it can be a difficult and time-consuming thing to do. The best way to make the most out of such groups is to find the relevant, ready-made one. These are the groupings that contain your buyer persona and are closely related to the industry in which you operate. Small groups limit your lead potential, while large groups cause your message to get lost. It is best to aim for both. To make your opinion known, use the 'Discussion' option at the top of the group's site and post questions, comments, or assertions. Your messaging should be targeted to each group, and you should know who you're writing to so they can make the best judgment about your organization. Make Use of LinkedIn Automation Tools There are a bunch of the best LinkedIn automation tools like Dripify and Octopus CRM that marketers can use to boost a LinkedIn strategy. These tools let you automate your LinkedIn activity and help you generate potential leads for your brand. It enables you to automate message requests, schedule messages, and also track your responses. It saves you a lot of time by automating all your time-consuming activities on LinkedIn while you can focus on other relevant lead generation tasks. LinkedIn automation tools With automation tools, you can automate almost anything on LinkedIn in one command center and dashboard. You can develop LinkedIn lead-generation campaigns that might provide remarkable results. Also, you can keep an eye on these campaigns' performance and monitor your total LinkedIn lead generation progress. Nurture Connections Generating leads is only the first step toward having meaningful prospects. You can not expect each lead to be directly impressed by your product pitch; some of them need nurturing too. The first step towards moving a lead to a sales funnel is having a direct conversation with the connection. Send a custom connection request, and follow it up with a catchy InMail that urges them to respond. There's no secret recipe to being a perfect conversation starter, but personalization works best. Try to strike up a conversation about something you both have in common. Expect this process to take some time. Some of the questions you can ask the lead are: What challenges are they facing in their business? What are long-term and immediate priorities? What challenges are they facing in their business? What challenges are they facing in their business? What are long-term and immediate priorities? What are long-term and immediate priorities? Finally, when the lead starts asking questions about your product, it's time for you to pitch them and turn the lead into a client. Give and Get Referrals One of the best LinkedIn marketing strategies is to give and get referrals. You should introduce yourself to each new lead as your network of first-degree relationships expands. Share your e-business card, if possible. Making the initial remark breaks the ice, allows for the prospect of collaboration, and lessens the awkwardness of asking them to be directed to someone else later. Look through a recent client's relationships to discover which ones might be helpful to your company. If you are confident enough in your relationship, send them a list of the individuals, and ask if they mind sending a brief introduction of you to each one. The worst-case scenario is that they refuse. A sales team knows how to ask and who to ask for referrals. They can outperform the competition, reach decision-makers in a single call, and develop connections that can lead to sales. Start Using LinkedIn for Lead Generation Now! Leads are like gold to salespeople and marketers. LinkedIn is the best way where you can generate potential leads for brands that can soon be converted into valuable clients. But even though LinkedIn lead generation might be profitable, it takes time to do. But even though LinkedIn lead generation might be profitable, it takes time to do. It is likely that you spend months without seeing any results if you don't use the proper tactics to target the appropriate audience. You have to be consistent with your lead generation strategy and take time to find valuable LinkedIn connections using the tips given in this guide. Optimize your profile, strike up meaningful conversations, or share high-quality content. Even then, not every prospect will turn into a sale - but you will have a great chance of converting those leads that are interested in buying from you!** Optimize your profile, strike up meaningful conversations, or share high-quality content.

How to Get Business Leads from LinkedIn?

কিভাবে LinkedIn থেকে বিজনেস লিড পাবেন?

Wie erhält man Geschäftskontakte über LinkedIn?

¿Cómo conseguir clientes potenciales comerciales de LinkedIn?

Comment obtenir des prospects sur LinkedIn ?

लिंक्डइन से बिजनेस लीड कैसे प्राप्त करें?

LinkedIn からビジネスリードを取得するにはどうすればいいですか?

LinkedIn에서 비즈니스 리드를 얻는 방법은 무엇입니까?

Como obter leads de negócios no LinkedIn?

Как получить потенциальных клиентов из LinkedIn?

LinkedIn'den İş Potansiyeli Nasıl Alınır?

Làm cách nào để có được khách hàng tiềm năng kinh doanh từ LinkedIn?

如何从 LinkedIn 获取商业线索？

Chaotic Links Theory: Exploring the Intersection of Classical Cryptography and Quantum Potentiality

The Surprising Link Between Cybersecurity Incidents and SEO

সাইবারসিকিউরিটি ঘটনা এবং সিইওর মধ্যে আশ্চর্যজনক লিঙ্ক

Der überraschende Zusammenhang zwischen Cybersicherheitsvorfällen und CEO

El sorprendente vínculo entre los incidentes de ciberseguridad y el director ejecutivo

Le lien surprenant entre les incidents de cybersécurité et le PDG

साइबर सुरक्षा घटनाओं और सीईओ के बीच आश्चर्यजनक संबंध

サイバーセキュリティインシデントとCEOの意外な関係

사이버 보안 사고와 CEO 사이의 놀라운 연관성

A ligação surpreendente entre incidentes de segurança cibernética e CEO

Удивительная связь между инцидентами в области кибербезопасности и генеральным директором

Siber Güvenlik Olayları ile CEO Arasındaki Şaşırtıcı Bağlantı

Mối liên hệ đáng ngạc nhiên giữa sự cố an ninh mạng và CEO

网络安全事件与 CEO 之间的惊人联系

In the context of global digitalization, governments have implemented various legislations on data privacy. However, some companies make minimal changes to their operations to formally comply with requirements or even ignore them if there are no precedents of sanctions. Moreover, violations can happen involuntarily. Using link shorteners is a common practice. You can create whatever link you want using services like Bitly, Rebrand, TinyURL, IPLogger, Cuttly, or many others, and instead of showing a user a long, clumsy link, give them one that looks good. Privacy policies of link shorteners state compliance with all legislative requirements concerning the processing and storage of personal data. If you are the one creating a link on the website, you will be asked to express consent to your data being collected. But what happens if you just click a link created by someone else? Your data is gathered and processed, and in most cases, without your consent, as you do not have the opportunity to give it; you just follow a link. While in some instances, the processing of personal data can be justified, for example, for purposes connected with the functioning of the service, sometimes such collection goes above and beyond the norm. One way link-shortening services monetize is by selling analytical data about clicks to different companies. The data may include details about the geography of clicks, sources of traffic, types of devices and browsers used, as well as language preferences - all of which are of significant interest for optimizing marketing campaigns, analyzing sales effectiveness, and so on. To provide such analytics, link-shortening services may need to collect, process, and store personal data on their servers. Some of this information, for example, the country and city, is usually based on the user's IP address. This pertains to the processing of personal information according to data privacy regulations such as GDPR classification. Often, users are not aware of such processing - even if mentioned somewhere, it may be buried in tons of legal documents located on an external website, which is rarely, if at all, being visited.


Many link-shortening services use cookies, recording them in the browser of the user who clicked on the link. In the EU and many other countries, placing non-functional cookies in users' browsers requires active opt-in.


Some of the services offer integration into the short links tracking pixels from third-party services, such as Facebook, which also uses cookie technology. Scripts executed to make it work collect data and send it back to the platform. Data policies of these platforms usually require explicit consent from end-users before loading such pixels into their browsers, but if a tracking pixel is activated during a click-through on a short link, there’s an issue with obtaining it.


And the last one - this user data can be transferred beyond the territories of the EU or the US unless there are adequate safeguards in place. Thus, if the creators of a short link are located in one country, they automatically gain access to information about all the users who click it, regardless of their geographic location. While some platforms provide such adequate safeguards, some of them do not. For example, GA4 is valid for transfers from the EU to the US, while TikTok pixels do not have adequate certification under the Data Privacy Framework. Therefore, user consent for transfers might be required. According to European legislation, the user's consent to the processing, and transferring, of personal data must be explicit, informed, and given freely. In the US context, similar initiatives for the protection of personal data also exist (the California Consumer Privacy Act (CCPA), the Virginia Consumer Data Protection Act (VCDPA), and the Children’s Online Privacy Protection Act (COPPA)). These laws, although not as unified as the GDPR in Europe, reflect a growing trend in the United States toward more stringent data protection. Still, there are hundreds of millions of users, who use short links and leave their data without realizing that it can be used for commercial purposes. According to Bit.ly, it processes 10 billion redirects through its short links per month. Rebrand.ly reports that their links are clicked 2 billion times a month. It's crucial to note that some services may not fully grasp the extent to which they violate legislative requirements, so the initial step is to fully acknowledge the problem. Once done, efforts can be directed towards solutions, such as creating intermediary pages akin to those utilized by websites to obtain user consent. While this may lengthen the user's journey, it presents a method to adhere to regulations for both link-shortening services and the companies utilizing them. There could also be additional strategies to explore. Upon recognizing the issue, optimism can be fostered for the development of technologies that contribute to creating a safer and more ethical digital space. In the context of global digitalization, governments have implemented various legislations on data privacy. However, some companies make minimal changes to their operations to formally comply with requirements or even ignore them if there are no precedents of sanctions. Moreover, violations can happen involuntarily. In the context of global digitalization, governments have implemented various legislations on data privacy . However, some companies make minimal changes to their operations to formally comply with requirements or even ignore them if there are no precedents of sanctions. Moreover, violations can happen involuntarily. data privacy Using link shorteners is a common practice. You can create whatever link you want using services like Bitly, Rebrand, TinyURL, IPLogger, Cuttly, or many others, and instead of showing a user a long, clumsy link, give them one that looks good. Privacy policies of link shorteners state compliance with all legislative requirements concerning the processing and storage of personal data. If you are the one creating a link on the website, you will be asked to express consent to your data being collected. But what happens if you just click a link created by someone else? Your data is gathered and processed, and in most cases, without your consent, as you do not have the opportunity to give it; you just follow a link. While in some instances, the processing of personal data can be justified, for example, for purposes connected with the functioning of the service, sometimes such collection goes above and beyond the norm. One way link-shortening services monetize is by selling analytical data about clicks to different companies. The data may include details about the geography of clicks, sources of traffic, types of devices and browsers used, as well as language preferences - all of which are of significant interest for optimizing marketing campaigns, analyzing sales effectiveness, and so on. To provide such analytics, link-shortening services may need to collect, process, and store personal data on their servers. Some of this information, for example, the country and city, is usually based on the user's IP address. This pertains to the processing of personal information according to data privacy regulations such as GDPR classification. Often, users are not aware of such processing - even if mentioned somewhere, it may be buried in tons of legal documents located on an external website, which is rarely, if at all, being visited. Many link-shortening services use cookies, recording them in the browser of the user who clicked on the link. In the EU and many other countries, placing non-functional cookies in users' browsers requires active opt-in. Some of the services offer integration into the short links tracking pixels from third-party services, such as Facebook, which also uses cookie technology. Scripts executed to make it work collect data and send it back to the platform. Data policies of these platforms usually require explicit consent from end-users before loading such pixels into their browsers, but if a tracking pixel is activated during a click-through on a short link, there’s an issue with obtaining it. And the last one - this user data can be transferred beyond the territories of the EU or the US unless there are adequate safeguards in place. Thus, if the creators of a short link are located in one country, they automatically gain access to information about all the users who click it, regardless of their geographic location. While some platforms provide such adequate safeguards, some of them do not. For example, GA4 is valid for transfers from the EU to the US, while TikTok pixels do not have adequate certification under the Data Privacy Framework. Therefore, user consent for transfers might be required. To provide such analytics, link-shortening services may need to collect, process, and store personal data on their servers. Some of this information, for example, the country and city, is usually based on the user's IP address. This pertains to the processing of personal information according to data privacy regulations such as GDPR classification. Often, users are not aware of such processing - even if mentioned somewhere, it may be buried in tons of legal documents located on an external website, which is rarely, if at all, being visited. To provide such analytics, link-shortening services may need to collect, process, and store personal data on their servers. Some of this information, for example, the country and city, is usually based on the user's IP address. This pertains to the processing of personal information according to data privacy regulations such as GDPR classification . Often, users are not aware of such processing - even if mentioned somewhere, it may be buried in tons of legal documents located on an external website, which is rarely, if at all, being visited. GDPR classification GDPR classification Many link-shortening services use cookies, recording them in the browser of the user who clicked on the link. In the EU and many other countries, placing non-functional cookies in users' browsers requires active opt-in. Many link-shortening services use cookies, recording them in the browser of the user who clicked on the link. In the EU and many other countries, placing non-functional cookies in users' browsers requires active opt-in. Some of the services offer integration into the short links tracking pixels from third-party services, such as Facebook, which also uses cookie technology. Scripts executed to make it work collect data and send it back to the platform. Data policies of these platforms usually require explicit consent from end-users before loading such pixels into their browsers, but if a tracking pixel is activated during a click-through on a short link, there’s an issue with obtaining it. Some of the services offer integration into the short links tracking pixels from third-party services, such as Facebook, which also uses cookie technology. Scripts executed to make it work collect data and send it back to the platform. Data policies of these platforms usually require explicit consent from end-users before loading such pixels into their browsers, but if a tracking pixel is activated during a click-through on a short link, there’s an issue with obtaining it. And the last one - this user data can be transferred beyond the territories of the EU or the US unless there are adequate safeguards in place. Thus, if the creators of a short link are located in one country, they automatically gain access to information about all the users who click it, regardless of their geographic location. While some platforms provide such adequate safeguards, some of them do not. For example, GA4 is valid for transfers from the EU to the US, while TikTok pixels do not have adequate certification under the Data Privacy Framework. Therefore, user consent for transfers might be required. And the last one - this user data can be transferred beyond the territories of the EU or the US unless there are adequate safeguards in place. Thus, if the creators of a short link are located in one country, they automatically gain access to information about all the users who click it, regardless of their geographic location. While some platforms provide such adequate safeguards, some of them do not. For example, GA4 is valid for transfers from the EU to the US, while TikTok pixels do not have adequate certification under the Data Privacy Framework. Therefore, user consent for transfers might be required. According to European legislation , the user's consent to the processing, and transferring, of personal data must be explicit, informed, and given freely. In the US context, similar initiatives for the protection of personal data also exist (the California Consumer Privacy Act (CCPA) , the Virginia Consumer Data Protection Act (VCDPA) , and the Children’s Online Privacy Protection Act (COPPA) ). These laws, although not as unified as the GDPR in Europe, reflect a growing trend in the United States toward more stringent data protection. According to European legislation According to European legislation (the California Consumer Privacy Act (CCPA) (the California Consumer Privacy Act (CCPA) the Virginia Consumer Data Protection Act (VCDPA) the Virginia Consumer Data Protection Act (VCDPA) the Children’s Online Privacy Protection Act (COPPA) the Children’s Online Privacy Protection Act (COPPA) Still, there are hundreds of millions of users, who use short links and leave their data without realizing that it can be used for commercial purposes. According to Bit.ly, it processes 10 billion redirects through its short links per month. Rebrand.ly reports that their links are clicked 2 billion times a month. reports reports It's crucial to note that some services may not fully grasp the extent to which they violate legislative requirements, so the initial step is to fully acknowledge the problem. Once done, efforts can be directed towards solutions, such as creating intermediary pages akin to those utilized by websites to obtain user consent. While this may lengthen the user's journey, it presents a method to adhere to regulations for both link-shortening services and the companies utilizing them. There could also be additional strategies to explore. Upon recognizing the issue, optimism can be fostered for the development of technologies that contribute to creating a safer and more ethical digital space.

Stories, News & Mentions about LINKR

Linkr’s Stories on HackerNoon

Linkr's News & Mentions