Hundreds of thousands of companies today use webinars and physical events for thought leadership, promoting products, and strengthening customer relationships

Contentware

contentware

TL;DR 💨 Contentlayer reduces a lot of friction in publishing the content on my static website. 😍 MDX with remark and rehype plugins is awesomely convenient and powerful. 🍵 Next.js jells very well with Contentlayer and MDX I fully embraced (SSG) for my website to optimize the site speed and scaling in the future. Static Site Generation Recently I’ve been researching on reducing the effort to create a new article on my website. There were many touch points in my project setup in order to: Next.js Publish a new article Estimate reading time Update the list of articles Create a new RSS feed Update the sitemap What Was The Problem? I analyzed a little more and found out the friction was in my MDX usage. My file structure looked like this: my-blog
├── public
├── data
│   └── blogs.json
├── components
│   └── Blog.tsx
└── pages
    ├── blogs
    │   ├── blog-one.mdx
    │   ├── blog-two.mdx
    │   └── blog-three.mdx
    └── index.tsx It is the recommended by Next.js. I was using and to transform MDX into pages. standard setup @mdx-js/loader @next/mdx Take for example, the content looked like this: pages/blogs/blog-one.mdx pages/blogs/blog-one.mdx import Blog from '../../components/Blog'

export const meta = {
  title: 'Blog One🚀',
  publishedAt: 'February 4, 2022'
  description: "Learn how to build a Next.js blog with MDX and Contentlayer!",
  cover: '/optimized/articles/blog-one/hero.webp',
}

export default ({ children }) => (
  <Blog
    title={meta.title}
    description={meta.description}
    cover={meta.cover}
    publishedAt={meta.publishedAt}
  >
    {children}
  </Blog>
)

Hey There👋

Welcome to Blog one✨ Let's learn together! named-exported a meta data. It was picked up by the the default component that took care of the layout and rendered the meta data. blog-one.mdx The component looked like this: <Blog /> components/Blog.tsx import { BlogProps } from './types'

export default function Blog(props: BlogProps) {
  return (
    <article>
      <h1>{props.title}</h1>
      <h2>{props.description}</h2>
      <p>
        {props.publishedAt}
      </p>
      <img alt={props.title} src={props.cover} width="100%" loading="lazy" />
      {props.children}
    </article>
  )
} I was treating MDX files as pages. Because the data in each MDX file was trapped in the page, I duplicated all the meta data and aggregated them in . I used it to maintain the list of articles on my website, the RSS feed, and the for SEO. meta data/blogs.json sitemap It would be much better if I could treat the MDX files as data, and generate pages based on the data. This way, . Publishing a new article ideally could be much more frictionless. I could use the MDX files as data points and page content at the same time I came across and found out he was using a alpha library called to solve the problem. Lee Robinson’s website Contentlayer What is Contentlayer is an library in its early stage that turns content into data. It works roughly like this: Contentlayer It takes in headless CMS or local content in YAML, JSON, MDX, or Markdown as source. It transforms the content into TypeScript types and data files in JSON that includes the original content, meta data, and any derived data we specified. It aggregates all the data in JSON and exports them as . ESM For my use case, I can use the aggregated data generated by Contentlayer to replace my previous manual process: I use the generated data to build the new page for an article. I use the generated data to render . the list of articles I use the generated data to create a new RSS feed. I use the new file structure to generate a new sitemap. All automatic! Contentlayer offers easy integration with Next.js. I’ll show you how in the next sections. Using MDX as Data Let’s first explore how to use MDX as a data point. MDX offers support with custom parsers. You can express the meta data like this: YAML frontmatter ---
title: 'Blog One🚀'
publishedAt: 'February 4, 2022'
description: 'Learn how to build a Next.js blog with MDX and Contentlayer!'
cover: '/optimized/articles/blog-one/hero.webp'
---

Hey There👋

Welcome to Blog One✨ Let's learn together! You can see the meta data in YAML syntax is inside the block, and the body of the content follows in MDX syntax. Compared to the where MDX files were treated as pages, the new MDX file contains only meta data and content. --- old setup The next thing we need to do is to generate the blog page that renders the meta data and the content with the layout from component. <Blog /> Integrating Contentlayer in Next.js Now that we updated the MDX files to contain only data and content, Let’s move them into the directory. data The new file structure looks like this: my-blog
├── public
├── components
│   └── Blog.tsx
├── pages
│   ├── blogs
│   │   └── [slug].tsx
│   └── index.tsx
└── data
    └──blogs
       ├── blog-one.mdx
       ├── blog-two.mdx
       └── blog-three.mdx Notice that we replaced the MDX files in directory with a . We'll use this page to statically generate the blog pages . pages/blogs dynamic route [slug].tsx later Configuring Contentlayer Contentlayer offers seamless integration with Next.js. To install the dependencies: yarn add contentlayer next-contentlayer Contentlayer reads the configuration from . Let's create one. contentlayer.config.ts touch contentlayer.config.ts Inside the , we need to add instructions to tell Contentlayer how to parse: contentlayer.config.ts : namespace name : input files filePathPattern : content body type for parsing bodyType : meta data fields fields : derived meta data fields computedFields contentlayer.config.ts import { defineDocumentType, makeSource } from 'contentlayer/source-files'
import readingTime from 'reading-time'

export const Blog = defineDocumentType(() => ({
  name: 'Blog',
  filePathPattern: 'blogs/*.mdx',
  bodyType: 'mdx',
  fields: {
    title: { type: 'string', required: true },
    publishedAt: { type: 'string', required: true },
    description: { type: 'string', required: true },
    cover: { type: 'string', required: true },
  },
  computedFields: {
    readingTime: { type: 'json', resolve: (doc) => readingTime(doc.body.raw) },
    slug: {
      type: 'string',
      resolve: (doc) => doc._raw.sourceFileName.replace(/\.mdx/, ''),
    },
  },
}))

export default makeSource({
  contentDirPath: 'data',
  documentTypes: [Blog],
  mdx: {
    remarkPlugins: [],
    rehypePlugins: [],
  },
}) In the , we can compute data like from the content body🤩. I'm using for calculating the reading time based on word count. The field is for generating the dynamic route later in the page. computedFields readingTime reading-time slug [slug].tsx Under the hood, Contentlayer uses to parse MDX and YAML frontmatter and extract the content and data. If you're interested in the magic behind it, you can read more about and . These are the libraries uses internally. mdx-bundler gray-matter remark-mdx-frontmatter mdx-bundler At the end of the configuration, will then look for files that match pattern under directory and generate the blog data in directory at your project root. makeSource blogs/*.mdx data .contentlayer Lastly, wrap your Next.js configuration with to integrate with Next.js's live-reload and build process. next-contentlayer next.config.js const { withContentlayer } = require('next-contentlayer')

module.exports = withContentlayer()({
  // ... your Next.js config
}) Using Contentlayer data for Static Site Generation We are ready to use the generated data from Contentlayer and build the static pages🤩 All we need to do is to use from to build the dynamic routes with and use to pass the blog data to the page. allBlogs .contentlayer/data getStaticPaths getStaticProps [slug].tsx pages/blogs/[slug].tsx import { useMDXComponent } from 'next-contentlayer/hooks'
import { allBlogs } from '.contentlayer/data'
import type { Blog } from '.contentlayer/types'
import BlogLayout from '../../../components/Blog'

type BlogProps = {
  blog: Blog
}

export default function Blog({ blog }: BlogProps) {
  const Component = useMDXComponent(post.body.code)

  return (
    <BlogLayout {...blog}>
      <Component />
    </BlogLayout>
  )
}

export async function getStaticPaths() {
  return {
    paths: allBlogs.map((blog) => ({ params: { slug: blog.slug } })),
    fallback: false,
  }
}

export async function getStaticProps({ params }) {
  const blog = allBlogs.find((blog) => blog.slug === params.slug)
  return { props: { blog } }
} After the project is built, you’ll see the blogs available at , , and ✨ /blogs/blog-one /blogs/blog-two /blogs/blog-three Bonus: remark & rehype Plugins There are a lot more we can do with MDX by leveraging remark and rehype plugins in the . contentlayer.config.ts is an awesome plugin ecosystem that transforms markdown. remark is another powerful plugin ecosystem that transforms HTML. rehype They are two separate ecosystems but we can convert remark to rehype and generate HTML markup. The transformation looks like this: MDX ----> remark AST ------> rehype AST --------> HTML
    parse            convert            stringify Contentlayer takes care of the flow. All we need to do is add the plugins to provide instruction for the transformations. I’m using the following plugins: to support . remark-gfm GitHub Flavored Markdown and to render heading links. rehype-slug rehype-autolink-headings to render syntax highlighting in code blocks. rehype-prism-plus to render code block titles. rehype-code-titles to provide accessibility to emojis. rehype-accessible-emojis contentlayer.config.ts + import remarkGfm from 'remark-gfm'
+ import rehypeSlug from 'rehype-slug'
+ import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+ import rehypeCodeTitles from 'rehype-code-titles'
+ import rehypePrism from 'rehype-prism-plus'
+ import { rehypeAccessibleEmojis } from 'rehype-accessible-emojis'

// ...

export default makeSource({
  mdx: {
-    remarkPlugins: [],
+    remarkPlugins: [remarkGfm],
-    rehypePlugins: [],
+    rehypePlugins: [
+      rehypeSlug,
+      rehypeCodeTitles,
+      rehypePrism,
+      rehypeAutolinkHeadings,
+      rehypeAccessibleEmojis,
    ],
  },
}) Contentlayer Applications There are more things we can do with the data. Application #1: RSS Feed I can now write a script to generate an RSS feed base on the data! allBlogs scripts/rss.mjs import { writeFileSync } from 'fs'
import RSS from 'rss'
import { allBlogs } from '.contentlayer/data'

const feed = new RSS({
  title: "My Blogs",
  feed_url: 'localhost:3000/rss.xml',
  site_url: 'localhost:3000',
})

allBlogs.map((blog) => ({
  title: blog.title,
  description: blog.description,
  url: `localhost:3000/blogs/${blog.slug}`
  date: blog.publishedAt,
})).forEach((item) => {
  feed.item(item)
})

writeFileSync('./public/rss.xml', feed.xml({ indent: true })) Application #2: XML Sitemap It’s easier to write a script for sitemap generation. All we need is the file structure in the and directories. data page scripts/sitemap.mjs import { writeFileSync } from 'fs'
import { globby } from 'globby'
import prettier from 'prettier'

const pages = await globby([
  'pages/*.tsx',
  'data/**/*.mdx',
  '!pages/_*.tsx',
])

const urlTags = pages
  .map((file) =>
    file
      .replace('pages', '')
      .replace('data/content', '')
      .replace('.tsx', '')
      .replace('.mdx', '')
  )
  .map((path) => (path === '/index' ? '/' : path))
  .map(
    (path) => `
      <url>
          <loc>localhost:3000${path}</loc>
      </url>
    `
  )
  .join('')

const sitemap = `
  <?xml version="1.0" encoding="UTF-8"?>
  <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
      ${urlTags}
  </urlset>
`

const prettierConfig = await prettier.resolveConfig('./prettierrc')
const formatted = prettier.format(sitemap, {
  ...prettierConfig,
  parser: 'html',
})

writeFileSync('public/sitemap.xml', formatted) Run both scripts after building the project and automatically generate a new RSS feed and sitemap. In , add: package.json "scripts": {
+    "sitemap": "node scripts/sitemap.mjs",
+    "rss": "node scripts/rss.mjs",
+    "postbuild": "yarn sitemap && yarn rss",
  }, Final Thoughts Building Static sites with Next.js becomes so effortless with MDX and Contentlayer. MDX combines with remark and rehype ecosystem enriches the possibility of building consistent pages with Markdown. Contentlayer makes data and content in MDX files available to consume in Next.js projects. If you’re exploring ways to build your own static sites, check out the libraries mentioned earlier. It not only reduces the time to market but also is a lot of fun to build!🦄 This article is originally posted on . Daw-Chih’s website

Build Faster Next.js Static Sites Using MDX And Contentlayer 

Build a Dynamic Photo Collection App With Django

Authors:
(1) Rui Cao, Singapore Management University;
(2) Ming Shan Hee, Singapore University of Design and Technology;
(3) Adriel Kuek, DSO National Laboratories;
(4) Wen-Haw Chong, Singapore Management University;
(5) Roy Ka-Wei Lee, Singapore University of Design and Technology
(6) Jing Jiang, Singapore Management University. Table of Links Abstract and Introduction Related Work Preliminary Proposed Method Experiment Conclusion and References Appendix ABSTRACT Hateful meme detection is a challenging multimodal task that requires comprehension of both vision and language, as well as cross-modal interactions. Recent studies have tried to fine-tune pre-trained vision-language models (PVLMs) for this task. However, with increasing model sizes, it becomes important to leverage powerful PVLMs more efficiently, rather than simply fine-tuning them. Recently, researchers have attempted to convert meme images into textual captions and prompt language models for predictions. This approach has shown good performance but suffers from noninformative image captions. Considering the two factors mentioned above, we propose a probing-based captioning approach to leverage PVLMs in a zero-shot visual question answering (VQA) manner. Specifically, we prompt a frozen PVLM by asking hateful contentrelated questions and use the answers as image captions (which we call Pro-Cap), so that the captions contain information critical for hateful content detection. The good performance of models with Pro-Cap on three benchmarks validates the effectiveness and generalization of the proposed method.[1] CCS CONCEPTS • Computing methodologies → Natural language processing; Computer vision representations. KEYWORDS memes, multimodal, semantic extraction ACM Reference Format: Rui Cao, Ming Shan Hee, Adriel Kuek, Wen-Haw Chong, Roy Ka-Wei Lee, and Jing Jiang. 2023. Pro Cap: Leveraging a Frozen Vision-Language Model for Hateful Meme Detection. In Proceedings of the 31st ACM International Conference on Multimedia (MM ’23), October 29-November 3, 2023, Ottawa, ON, Canada. ACM, New York, NY, USA, 11 pages. https://doi.org/10.1145/3581783.3612498 Disclaimer: This paper contains violence and discriminatory content that may be disturbing to some readers. 1 INTRODUCTION Memes, which combine images with short texts, are a popular form of communication in online social media. Internet memes are often intended to express humor or satire. However, they are increasingly being exploited to spread hateful content across online platforms. Hateful memes attack individuals or communities based on their identities such as race, gender, or religion [5, 8, 12, 27]. The propagation of hateful memes can lead to discord online and may potentially result in hate crimes. Therefore, it is urgent to develop accurate hateful meme detection methods. The task of hateful meme detection is challenging due to the multimodal nature of memes. Detection involves not only comprehending both the images and the texts but also understanding how these two modalities interact. Previous work [14, 28, 35, 36] learns cross-modal interactions from scratch using hateful meme detection datasets. However, it may be difficult for models to learn complicated multimodal interactions with the limited amount of data available from these datasets. With the development of Pretrained Vision-Language Models (PVLMs) such as VisualBERT [18] and ViLBERT [23], recent work leverage these powerful PVLMs to facilitate the hateful meme detection task. A common approach is to fine-tune PVLMs with task-specific data [9, 20, 26, 34, 37]. However, it is less feasible to fine-tune the larger models such as BLIP-2 [15] and Flamingo [1] on meme detection because there are billions of trainable parameters. Therefore, computationally feasible solutions other than direct fine-tuning are needed to leverage large PVLMs in facilitating hateful meme detection. Different from the approach above using PVLMs, PromptHate[2] is a recently proposed model that converts the multimodal meme detection task into a unimodal masked language modeling task. It first generates meme image captions with an off-the-shelf image caption generator, ClipCap [25]. By converting all input information into text, it can prompt a pre-trained language model along with two demonstrative examples to predict whether or not the input is hateful by leveraging the rich background knowledge in the language model. Although PromptHate achieves state-of-the-art performance, it is significantly affected by the quality of image captions, as shown in Table 1. Image captions that are merely generic descriptions of images may omit crucial details [14, 37], such as the race and gender of people, which are essential for hateful content detection. But with additional image tags, such as entities found in the images and demographic information about the people in the images, the same model can be significantly improved, as shown in Table 1. However, generating these additional image tags is laborious and costly. For instance, entity extraction is usually conducted with the Google Vision Web Entity Detection API [2], which is a paid service. Ideally, we would like to find a more affordable way to obtain entity and demographic information from the images that is critical for hateful content detection. Both above-mentioned approaches (i.e., one using PVLMs and the other converting the task to a unimodal task) have their pros and cons. In this paper, we combine the ideas from these two approaches and design a hateful meme detection method that leverages the power of a frozen PVLM to complement the unimodal approach of PromptHate. Specifically, we use a set of “probing” questions to query a PVLM (BLIP-2 [15] in our experiments) for information related to common vulnerable targets in hateful content. The answers obtained from the probing questions will be treated as image captions (denoted as Pro-Cap) and used as input to a trainable hateful meme detection model. Figure 1 illustrates the overall workflow of the method. We refer to the step of using probing questions to generate the captions as probing-based captioning. Our proposed method fills existing research gaps by: 1) Leverage a PVLM without any adaptation or fine-tuning, thereby reducing computational cost; 2) Instead of explicitly obtaining additional image tags with costly APIs, we utilize the frozen PVLM to generate captions that contain information useful for hateful meme detection. To the best of our knowledge, this is the first work that to leverage PVLMs in a zero-shot manner through question answering to assist in the hateful meme detection task. To further validate our method, we test the effect of the generated Pro-Cap on both PromptHate[2] and a BERT-based[4] hateful meme detection model. Based on the experimental results, we observe that PromptHate with Pro-Cap (denoted as Pro-CapPromptHate) significantly surpasses the original PromptHate without additional image tags (i.e., about 4, 6, and 3 percentage points of absolute performance improvement on FHM [12], MAMI [5], and HarM [28] respectively). ProCapPromptHate also achieves comparable results with PromptHate with additional image tags, indicating that probing-based captioning can be a more affordable way of obtaining image entities or demographic information. Case studies further show that Pro-Cap offers essential image details for hateful content detection, enhancing the explainability of models to some extent. Meanwhile, ProCapBERT clearly surpasses multimodal BERT-based models of similar sizes (i.e., about 7 percentage points of absolute improvement with VisualBERT on FHM [12]), proving the generalization of the probing-based captioning method. [1] Code is available at: https://github.com/Social-AI-Studio/Pro-Cap [2] https://cloud.google.com/vision/docs/detecting-web This paper is available on arxiv under CC 4.0 license. Authors: (1) Rui Cao, Singapore Management University; (2) Ming Shan Hee, Singapore University of Design and Technology; (3) Adriel Kuek, DSO National Laboratories; (4) Wen-Haw Chong, Singapore Management University; (5) Roy Ka-Wei Lee, Singapore University of Design and Technology (6) Jing Jiang, Singapore Management University. Authors: Authors: (1) Rui Cao, Singapore Management University; (2) Ming Shan Hee, Singapore University of Design and Technology; (3) Adriel Kuek, DSO National Laboratories; (4) Wen-Haw Chong, Singapore Management University; (5) Roy Ka-Wei Lee, Singapore University of Design and Technology (6) Jing Jiang, Singapore Management University. Table of Links Abstract and Introduction Abstract and Introduction Related Work Related Work Preliminary Preliminary Proposed Method Proposed Method Experiment Experiment Conclusion and References Conclusion and References Appendix Appendix ABSTRACT Hateful meme detection is a challenging multimodal task that requires comprehension of both vision and language, as well as cross-modal interactions. Recent studies have tried to fine-tune pre-trained vision-language models (PVLMs) for this task. However, with increasing model sizes, it becomes important to leverage powerful PVLMs more efficiently, rather than simply fine-tuning them. Recently, researchers have attempted to convert meme images into textual captions and prompt language models for predictions. This approach has shown good performance but suffers from noninformative image captions. Considering the two factors mentioned above, we propose a probing-based captioning approach to leverage PVLMs in a zero-shot visual question answering (VQA) manner. Specifically, we prompt a frozen PVLM by asking hateful contentrelated questions and use the answers as image captions (which we call Pro-Cap), so that the captions contain information critical for hateful content detection. The good performance of models with Pro-Cap on three benchmarks validates the effectiveness and generalization of the proposed method.[1] CCS CONCEPTS • Computing methodologies → Natural language processing; Computer vision representations. • Computing methodologies → Natural language processing; Computer vision representations. KEYWORDS memes, multimodal, semantic extraction ACM Reference Format: Rui Cao, Ming Shan Hee, Adriel Kuek, Wen-Haw Chong, Roy Ka-Wei Lee, and Jing Jiang. 2023. Pro Cap: Leveraging a Frozen Vision-Language Model for Hateful Meme Detection. In Proceedings of the 31st ACM International Conference on Multimedia (MM ’23), October 29-November 3, 2023, Ottawa, ON, Canada. ACM, New York, NY, USA, 11 pages. https://doi.org/10.1145/3581783.3612498 Disclaimer: This paper contains violence and discriminatory content that may be disturbing to some readers. Disclaimer: This paper contains violence and discriminatory content that may be disturbing to some readers. Disclaimer: This paper contains violence and discriminatory content that may be disturbing to some readers. 1 INTRODUCTION Memes, which combine images with short texts, are a popular form of communication in online social media. Internet memes are often intended to express humor or satire. However, they are increasingly being exploited to spread hateful content across online platforms. Hateful memes attack individuals or communities based on their identities such as race, gender, or religion [5, 8, 12, 27]. The propagation of hateful memes can lead to discord online and may potentially result in hate crimes. Therefore, it is urgent to develop accurate hateful meme detection methods. The task of hateful meme detection is challenging due to the multimodal nature of memes. Detection involves not only comprehending both the images and the texts but also understanding how these two modalities interact. Previous work [14, 28, 35, 36] learns cross-modal interactions from scratch using hateful meme detection datasets. However, it may be difficult for models to learn complicated multimodal interactions with the limited amount of data available from these datasets. With the development of Pretrained Vision-Language Models (PVLMs) such as VisualBERT [18] and ViLBERT [23], recent work leverage these powerful PVLMs to facilitate the hateful meme detection task. A common approach is to fine-tune PVLMs with task-specific data [9, 20, 26, 34, 37]. However, it is less feasible to fine-tune the larger models such as BLIP-2 [15] and Flamingo [1] on meme detection because there are billions of trainable parameters. Therefore, computationally feasible solutions other than direct fine-tuning are needed to leverage large PVLMs in facilitating hateful meme detection. Different from the approach above using PVLMs, PromptHate[2] is a recently proposed model that converts the multimodal meme detection task into a unimodal masked language modeling task. It first generates meme image captions with an off-the-shelf image caption generator, ClipCap [25]. By converting all input information into text, it can prompt a pre-trained language model along with two demonstrative examples to predict whether or not the input is hateful by leveraging the rich background knowledge in the language model. Although PromptHate achieves state-of-the-art performance, it is significantly affected by the quality of image captions, as shown in Table 1. Image captions that are merely generic descriptions of images may omit crucial details [14, 37], such as the race and gender of people, which are essential for hateful content detection. But with additional image tags, such as entities found in the images and demographic information about the people in the images, the same model can be significantly improved, as shown in Table 1. However, generating these additional image tags is laborious and costly. For instance, entity extraction is usually conducted with the Google Vision Web Entity Detection API [2], which is a paid service. Ideally, we would like to find a more affordable way to obtain entity and demographic information from the images that is critical for hateful content detection. Both above-mentioned approaches (i.e., one using PVLMs and the other converting the task to a unimodal task) have their pros and cons. In this paper, we combine the ideas from these two approaches and design a hateful meme detection method that leverages the power of a frozen PVLM to complement the unimodal approach of PromptHate. Specifically, we use a set of “probing” questions to query a PVLM (BLIP-2 [15] in our experiments) for information related to common vulnerable targets in hateful content. The answers obtained from the probing questions will be treated as image captions (denoted as Pro-Cap) and used as input to a trainable hateful meme detection model. Figure 1 illustrates the overall workflow of the method. We refer to the step of using probing questions to generate the captions as probing-based captioning. Our proposed method fills existing research gaps by: 1) Leverage a PVLM without any adaptation or fine-tuning, thereby reducing computational cost; 2) Instead of explicitly obtaining additional image tags with costly APIs, we utilize the frozen PVLM to generate captions that contain information useful for hateful meme detection. To the best of our knowledge, this is the first work that to leverage PVLMs in a zero-shot manner through question answering to assist in the hateful meme detection task. To further validate our method, we test the effect of the generated Pro-Cap on both PromptHate[2] and a BERT-based[4] hateful meme detection model. Based on the experimental results, we observe that PromptHate with Pro-Cap (denoted as Pro-CapPromptHate) significantly surpasses the original PromptHate without additional image tags (i.e., about 4, 6, and 3 percentage points of absolute performance improvement on FHM [12], MAMI [5], and HarM [28] respectively). ProCapPromptHate also achieves comparable results with PromptHate with additional image tags, indicating that probing-based captioning can be a more affordable way of obtaining image entities or demographic information. Case studies further show that Pro-Cap offers essential image details for hateful content detection, enhancing the explainability of models to some extent. Meanwhile, ProCapBERT clearly surpasses multimodal BERT-based models of similar sizes (i.e., about 7 percentage points of absolute improvement with VisualBERT on FHM [12]), proving the generalization of the probing-based captioning method. [1] Code is available at: https://github.com/Social-AI-Studio/Pro-Cap [2] https://cloud.google.com/vision/docs/detecting-web 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

Pro-Cap: Leveraging a Frozen Vision-Language Model for Hateful Meme Detection

প্রো-ক্যাপ: বিদ্বেষপূর্ণ মেম সনাক্তকরণের জন্য একটি হিমায়িত দৃষ্টি-ভাষা মডেল ব্যবহার করা

Pro-Cap: Nutzung eines Frozen Vision-Language-Modells zur Erkennung hasserfüllter Memes

Pro-Cap: Aprovechamiento de un modelo de visión-lenguaje congelado para la detección de memes de odio

Pro-Cap : exploiter un modèle de langage de vision figé pour la détection des mèmes haineux

प्रो-कैप: घृणास्पद मीम का पता लगाने के लिए फ्रोज़न विज़न-लैंग्वेज मॉडल का लाभ उठाना

Pro-Cap: 凍結された視覚言語モデルを活用して憎悪的なミームを検出する

Pro-Cap: 혐오스러운 밈 탐지를 위해 고정된 비전-언어 모델 활용

Pro-Cap: aproveitando um modelo de linguagem de visão congelada para detecção de memes odiosos

Pro-Cap: использование модели Frozen Vision-Language для обнаружения ненавистных мемов

Pro-Cap: Nefret Dolu Memlerin Tespiti için Donmuş Görüş-Dil Modelinden Yararlanmak

Pro-Cap: Tận dụng mô hình ngôn ngữ tầm nhìn đông lạnh để phát hiện meme đáng ghét

Pro-Cap：利用冻结视觉语言模型进行仇恨模因检测

Designed for developers familiar with Azure and generative AI, the guide walks you through the process of harnessing the power of the DALL-E model for image generation. Introduction The Microsoft team has recently launched an Open AI challenge, in which a developer can learn how to build Azure AI solutions and apps. Prerequisite Experience working with Azure and Azure portals. An understanding of generative AI. Experience in one high-level programming language like C# or Python Steps to Create Open AI Service on Azure with “Dall-E” model deployed. Day 1 — Azure Open AI Challenge Getting Started Considering Azure Open AI Service is running on the Azure portal and the DALL-E model is deployed successfully. Step 1: Create a Console Application To test image generation, create a console application in Visual Studio or Visual Studio Code. dotnet new console Step 2: Read the Configuration Read the configuration from the appsettings.json file IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
    IConfigurationRoot configuration = builder.Build();
    string? aoaiEndpoint = configuration["AzureOAIEndpoint"] ?? "";
    string? aoaiKey = configuration["AzureOAIKey"] ?? ""; Step 3: Generate Console Prompt Get the user prompt on the console ready for image generation Console.Clear();
    Console.WriteLine("Enter a prompt to request an image:");
    string prompt = Console.ReadLine() ?? ""; Step 4: Call the DALL-E model using HttpClient Finally, Call the model using the HTTP client, and retrieve the blob URL from the API response as shown below. using (var client = new HttpClient())
    {
        var contentType = new MediaTypeWithQualityHeaderValue("application/json");
        var api = "openai/deployments/test-dall-e-3/images/generations?api-version=2024-02-15-preview";
        client.BaseAddress = new Uri(aoaiEndpoint);
        client.DefaultRequestHeaders.Accept.Add(contentType);
        client.DefaultRequestHeaders.Add("api-key", aoaiKey);
        var data = new
        {
            prompt = prompt,
            n = 1,
            size = "1024x1024"
        };
    
        var jsonData = JsonSerializer.Serialize(data);
        var contentData = new StringContent(jsonData, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(api, contentData);
    
        // Get the revised prompt and image URL from the response
        var stringResponse = await response.Content.ReadAsStringAsync();
        JsonNode contentNode = JsonNode.Parse(stringResponse)!;
        JsonNode dataCollectionNode = contentNode!["data"];
        JsonNode dataNode = dataCollectionNode[0]!;
        JsonNode revisedPrompt = dataNode!["revised_prompt"];
        JsonNode url = dataNode!["url"];
        Console.WriteLine(revisedPrompt.ToJsonString());
        Console.WriteLine(url.ToJsonString().Replace(@"\u0026", "&"));
    
    } Test Run 1 Now, add the following prompt to the console window. aliens in Punjabi attire The console application will generate the following response and the user has to open the Blob URL in any browser. "A fascinating scene showing a group of extraterrestrial creatures donning traditional Punjabi attire. The aliens each have their own unique physical characteristics, yet their outfits are distinctively Punjabi. Imagine elaborate turbans, vibrant salwar kameez, and sparkling bangles. To put an interesting spin on the scene, some of the aliens are participating in traditional Punjabi activities like performing bhangra and carrying a jug of lassi. The background is a typical Punjabi village with interesting architectural features that seem to blend into an alien landscape."
    "<URL will be here>" Output Test Run 2 Now, add the following prompt to the console window. a cartoon character playing circket in the football field The console application will generate the following response and the user has to open the Blob URL in any browser. "A cartoon character with spiky blue hair and emerald green eyes, wearing a traditional cricket uniform consisting of a white shirt, trousers, and a red cricket cap. This character is striking a cricket ball with a willow bat in the middle of a vast, well-maintained football field. The field is vibrant green and has white line markings, with two goal posts at each end. The sky above is a cheerful cerulean with a few fluffy cumulus clouds scattered about."
    "<URL will be here>" Output Complete Code Please find below the complete code in the Program.cs file. using System.Net.Http.Headers;
    using System.Text.Json.Nodes;
    using System.Text.Json;
    using System.Text;
    using Microsoft.Extensions.Configuration;
    
    try
    {
        // Get config settings from AppSettings
        IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
        IConfigurationRoot configuration = builder.Build();
        string? aoaiEndpoint = configuration["AzureOAIEndpoint"] ?? "";
        string? aoaiKey = configuration["AzureOAIKey"] ?? "";
    
        // Get prompt for image to be generated
        Console.Clear();
        Console.WriteLine("Enter a prompt to request an image:");
        string prompt = Console.ReadLine() ?? "";
    
        // Call the DALL-E model
        using (var client = new HttpClient())
        {
            var contentType = new MediaTypeWithQualityHeaderValue("application/json");
            var api = "openai/deployments/test-dall-e-3/images/generations?api-version=2024-02-15-preview";
            client.BaseAddress = new Uri(aoaiEndpoint);
            client.DefaultRequestHeaders.Accept.Add(contentType);
            client.DefaultRequestHeaders.Add("api-key", aoaiKey);
            var data = new
            {
                prompt = prompt,
                n = 1,
                size = "1024x1024"
            };
    
            var jsonData = JsonSerializer.Serialize(data);
            var contentData = new StringContent(jsonData, Encoding.UTF8, "application/json");
            var response = await client.PostAsync(api, contentData);
    
            // Get the revised prompt and image URL from the response
            var stringResponse = await response.Content.ReadAsStringAsync();
            JsonNode contentNode = JsonNode.Parse(stringResponse)!;
            JsonNode dataCollectionNode = contentNode!["data"];
            JsonNode dataNode = dataCollectionNode[0]!;
            JsonNode revisedPrompt = dataNode!["revised_prompt"];
            JsonNode url = dataNode!["url"];
            Console.WriteLine(revisedPrompt.ToJsonString());
            Console.WriteLine(url.ToJsonString().Replace(@"\u0026", "&"));
    
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    } Complete Code on GitHub Make sure to give it a star on GitHub and provide feedback on how to improve the tool further..!! AzureOpenAI/samples/Azure.OpenAI.ImageGenerationExamples at main · ssukhpinder/AzureOpenAI C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev Also published here

Taking the Azure Open AI Challenge: Image Generation - Day 2

In nearly all of my recent explorations of Generative AI, I've come to realize how important prompts are. That hasn't necessarily translated me into writing better prompts all the time, but being aware of the problem is at least one step towards correcting it, right? One of the things that I thought would help me personally would be to have a tool to quickly compare and contrast different prompts. Obviously, I could just open up multiple tabs in a browser, but I really wanted something more direct and simplified for my purposes. With that in mind, let me share what I've built. Prompt Tester Prompt Tester is my incredibly imaginatively named tool to... um... test prompts. It begins with one prompt: The idea is that you enter your initial prompt, and then click one or more times to add more prompts. When ready, you can then just click "Generate Results": Before showing some example results, let me talk a bit about how it was built. The Code The backend is an simple Node.js server that handles throwing up the static HTML and responding to the front-end API requests. Once again, I thank Todd Sharp for sharing his initial code with me. Here's the boring simple handling portion: incredibly async function handler(req, res) {
	console.log('Entered handler.', req.method, req.url);

	if(req.method === 'GET' && req.url.indexOf('favicon.ico') === -1) {
		res.writeHead(200, { 'Content-Type':'text/html' });
		res.write(fs.readFileSync('./demo.html'));
		res.end();
	} else if(req.method === 'POST' && req.url === '/api') {

		let body = '';
		req.on('data', chunk => {
			body += chunk.toString();
		});

		req.on('end', async () => {
			body = JSON.parse(body);
			console.log('BODY:\n', JSON.stringify(body, null, '\t'));

			let result = await callGemini(body.prompt);
			res.writeHead(200, { 'Content-Type':'application/json' });
			res.write(JSON.stringify(result));
			res.end();

		});

	}

}

const server = http.createServer(handler);
server.listen(3000);
console.log('Listening on port 3000'); And the part which just passes the prompt off to Google's . In theory, this could be changed to ChatGPT or any other service. callGemini Gemini API const MODEL_NAME = "gemini-pro";
const API_KEY = process.env.GOOGLE_AI_KEY;

const genAI = new GoogleGenerativeAI(API_KEY);
const model = genAI.getGenerativeModel({ model: MODEL_NAME });

async function callGemini(text) {

	const generationConfig = {
		temperature: 0.9,
		topK: 1,
		topP: 1,
		maxOutputTokens: 2048,
	};

	const safetySettings = [
		{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,	threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	];

	const parts = [
    	{text},
  	];

	const result = await model.generateContent({
		contents: [{ role: "user", parts }],
		generationConfig,
		safetySettings,
	});

	try {

		if(result.response.promptFeedback && result.response.promptFeedback.blockReason) {

			return { error: `Blocked for ${result.response.promptFeedback.blockReason}` };
		}
		const response = result.response.candidates[0].content.parts[0].text;
		return { response };
	} catch(e) {
		// better handling
		return {
			error:e.message
		}
	}
	
} I'm proud to say that I'm now, finally, doing some basic error handling and trying to expose to the user (me) why a prompt was blocked. The front end is relatively simple. I used for the core CSS (again, thank you Todd) and some vanilla JavaScript to handle adding new prompts and making the calls. Here's the HTML (minus the inline CSS): Milligram <h1>Prompt Tester</h1>

<p>
This tool helps you see the result of multiple prompts at the same time. The idea is to use similar prompts with different phrasing 
to see how it impacts the result.
</p>

<div id="prompts">
</div>

<template id="promptRow">
<div class="row">
	<div class="column column-33"><textarea placeholder="Enter your prompt."></textarea></div>
	<div class="column column-67 result"></div>
</div>
<hr>
</template>


<div class="float-right">
<button id="addPrompt">Add Prompt</button> <button id="generateResults">Generate Results</button>
</div> And then the JavaScript. Notice I used above to handle the prompt layout. This is the first time I've used that tag, and it was relatively easy. <template> let $template, $prompts, $addPromptsBtn, $generateResultsBtn;
let promptCount = 0;

document.addEventListener('DOMContentLoaded', init, false);
async function init() {
	
	$addPromptsBtn = document.querySelector('#addPrompt');
	$addPromptsBtn.addEventListener('click',  addPrompt, false);
	$generateResultsBtn = document.querySelector('#generateResults')
	$generateResultsBtn.addEventListener('click',  generateResults, false);
	$template = document.querySelector('#promptRow');
	$prompts = document.querySelector('#prompts');

	addPrompt();
}

function addPrompt() {
	promptCount++;
	const newPrompt = $template.content.cloneNode(true);
	$prompts.append(newPrompt);
}

async function generateResults() {
	// disable add prompt and generate
	$addPromptsBtn.setAttribute('disabled', 'disabled');
	$generateResultsBtn.setAttribute('disabled', 'disabled');

	let $results = document.querySelectorAll('div.result');
	// clear any previous results
	$results.forEach(r => r.innerHTML = '');

	/*
	gather prompts from the inputs
	*/
	let prompts = [];
	let $fields = document.querySelectorAll('#prompts textarea');
	for(f of $fields) prompts.push(f.value);

	let promises = [];
	for(p of prompts) promises.push(getResult(p));
	let results = await Promise.all(promises);

	// assign results to result area for each, handle errors - later
	// there's a one to one correspondance between our array of results and the result div
	for(let i=0;i<results.length;i++) {
		if(results[i].response) $results[i].innerHTML = marked.parse(results[i].response);
		else if(results[i].error) $results[i].innerHTML = `<strong>Error with Prompt: </strong> ${results[i].error}`;
	}

	$addPromptsBtn.removeAttribute('disabled');
	$generateResultsBtn.removeAttribute('disabled');

}

async function getResult(p) {
	console.log('get result for',p);
	// quick return on empty prompt
	if(p.trim() === '') return { response:'<strong>Enter a prompt.</strong>' };
	let req = await fetch('/api', { method:'POST', body: JSON.stringify({prompt:p.trim()})});
	let result = await req.json();
	return result;
} I that's all pretty simple DOM manipulation and API calling, but definitely let me know in a comment below if something doesn't make sense. Notice I fire off all my API calls at once and wait for them to finish. think Promise.all Also, note I use the library. The results from Google typically have Markdown, and this helps render them nicely in my little web app. marked All of this isn't terribly interesting I think, but let's look at some testing. As I said, I the style of prompt was important. Having it presented directly to me in a tool went a of a long way to reinforcing that. knew heck Sample Result - Gravity Let's start with a simple idea - explaining gravity but for different age groups. Because of the large size of the results, I'm going to use a bit of CSS here to help keep things sane. Prompt: explain gravity to me but make it appropriate for a child in 1st grade Gravity is a superpower that our planet has! It's like an invisible force that makes everything on Earth stay on the ground. Imagine you have a ball in your hand. When you drop it, what happens? It falls down, right? That's because of gravity. Gravity pulls the ball towards the center of the Earth, and so it falls to the ground. Gravity is also what keeps us on the ground. It's what keeps our feet planted firmly on the Earth and prevents us from floating away! Gravity is a very important force. It keeps everything in place and helps things work the way they do. Without gravity, we would all be floating around in space, and things would be very chaotic! Here's a fun way to think about gravity: imagine that the Earth is a giant magnet, and everything on Earth is made of metal. The magnet pulls the metal objects towards it, and that's what keeps them on the ground. Gravity is a very important and interesting force. It's one of the things that makes our planet such a unique and special place to live! Prompt: explain gravity to me but make it appropriate for a child in 7th grade Imagine you're playing with a ball. You toss it up in the air, and it comes back down to you. This is because of gravity. Gravity is a force that pulls things toward each other. It's what keeps you on the ground and what makes things fall down. The amount of gravity between two objects depends on their mass. The more mass an object has, the stronger its gravity is. That's why things like planets and stars have more gravity than things like people and cars. Gravity is also what keeps the planets in orbit around the sun. The sun's gravity is much stronger than the Earth's, so it pulls the Earth towards it. This keeps the Earth moving in a circle around the sun. Gravity is a very important force in our universe. It keeps things in place and makes things move. Without gravity, the planets would fly off into space, and we would all float away. Here are some fun facts about gravity: Gravity is responsible for the tides. The moon's gravity pulls on Earth's oceans, causing them to rise and fall. Gravity is the reason why we have an atmosphere. Without gravity, the air would just float away into space. Gravity is what makes it possible for us to walk. When we walk, our feet push against the ground, and the ground pushes back. This is what propels us forward. Gravity is the reason why we don't float away into space. Earth's gravity pulls us towards its center, keeping us on the ground. Note the typo in the prompt below. Gemini handled it just fine. Prompt: explain gravity to me but make it appropriate for a college-aged student Gravity: The Force of Attraction Gravity is a fundamental force in the universe responsible for keeping celestial bodies, such as planets, moons, and stars, in motion. It is also what keeps us firmly planted to the ground and allows objects to fall when dropped. Newton's Law of Universal Gravitation: The law of universal gravitation states that every object in the universe attracts every other object with a force proportional to the product of their masses and inversely proportional to the square of the distance between them. Mathematically, it can be expressed as: F = Gm1m2/r^2 Where: F is the gravitational force between two objects. G is the gravitational constant (6.674 × 10^-11 N m^2/kg^2). m1 and m2 are the masses of the two objects. r is the distance between the centers of the two objects. Significance of Gravity: The gravitational pull of larger celestial bodies keeps smaller ones revolving around them. For example, Earth's gravity keeps the moon in orbit, while Sun's gravity keeps Earth and other planets in their respective orbits. Keeps Celestial Bodies in Orbit: Gravity between the Earth and the moon causes ocean tides. As the moon orbits Earth, its gravitational pull creates a bulge in the ocean's water on the side facing the moon. Another bulge forms on the opposite side of Earth due to the inertial forces. As the Earth rotates, these bulges move across the planet's surface, resulting in high and low tides. Responsible for Tides: Gravity pulls objects towards Earth's center, preventing them from floating away. This phenomenon allows us to walk, stand, and interact with our environment. Keeps Objects on Earth: Gravity plays a crucial role in the formation of stars and galaxies. The gravitational collapse of massive clouds of gas and dust leads to the creation of new stars. Similarly, the gravitational pull of galaxies keeps them bound together, preventing them from dispersing. Formation of Stars and Galaxies: Albert Einstein's general relativity theory provides a more comprehensive understanding of gravity. It explains that gravity is not a force but rather a curvature of spacetime caused by the presence of mass or energy. This curvature affects the motion of objects, causing them to follow curved paths rather than straight lines. Relativity Theory: In conclusion, gravity is a fundamental force responsible for keeping celestial bodies in motion, tides, and the behavior of objects on Earth. It is a complex phenomenon that has been studied extensively over the centuries, and it continues to fascinate scientists and researchers to this day. Sample Result - Pets For my second test, I started with a basic prompt and then a better version that asked for specific types of details: (Quick editorial note - the tabular data below is a bit messy, but was messy in the original output.) not Prompt: why are cats so much better than dogs? Cats and dogs are both popular pets, and there is no definitive answer to the question of which one is better. Both cats and dogs have their own unique set of advantages and disadvantages, and the best pet for you will depend on your individual needs and preferences. Some people prefer cats because they are generally more independent than dogs. Cats are typically happy to entertain themselves, and they don't need to be walked or taken outside for exercise. This can be a big advantage for people who live in apartments or who have busy schedules. Cats are also known for being clean and tidy animals. They groom themselves regularly, and they typically use the litter box without any problems. This can be a big advantage for people who don't want to deal with the mess and smell of a dog. Of course, there are also some disadvantages to having a cat. Cats can be more expensive than dogs, and they can be more difficult to train. Cats are also more likely to scratch furniture and other household items. Ultimately, the decision of whether to get a cat or a dog is a personal one. There is no right or wrong answer, and the best pet for you will depend on your individual needs and preferences. Here is a table summarizing the key differences between cats and dogs: Characteristic Cat Dog Independence More independent Less independent Exercise needs Does not need to be walked or taken outside Needs to be walked or taken outside Cleanliness Cleans itself regularly Needs to be bathed regularly Training Can be difficult to train Easier to train Scratching May scratch furniture and other household items Does not typically scratch furniture Cost More expensive Less expensive Prompt: why are cats so much better than dogs? explain with a bulleted list of reasons that cover emotional well being and financial aspects Emotional well-being: Independence: Cats are more independent than dogs, which can be a good thing for people who want a pet that doesn't require a lot of attention. Low maintenance: Cats are generally lower maintenance than dogs. They don't need to be walked or groomed as often, and they can be left alone for longer periods of time. Quiet: Cats are generally quieter than dogs, which can be ideal for people who live in apartments or have noise-sensitive neighbors. Therapeutic: Studies have shown that cats can have a calming effect on humans, and they can help to reduce stress and anxiety. Financial aspects: Lower cost: Cats are generally less expensive to own than dogs. They eat less food, they need fewer vet visits, and they don't require as much grooming. Easier to travel with: Cats are easier to travel with than dogs. They can be transported in a carrier, and they don't need to be walked or exercised while you're away. Longer lifespan: Cats have a longer lifespan than dogs, on average. This means that you can enjoy your cat's companionship for many years to come. Sample Result - Chain of Thought Prompting The following test came from an presentation from AWS re:Invent: . I found a lot of great advice from this session, including a good overview of Chain of Thought prompting, where the idea is you provide information about the steps used to solve a problem to help the GenAI engine better solve a prompt. excellent AWS re:Invent 2023 - Prompt engineering best practices for LLMs on Amazon Bedrock (AIM377) Now, the example given in that presentation went like so: Q: Roger has 5 tennis balls. he buys 2 more cans of tennis balls. Each 
can has 3 tennis balls. How many tennis balls does he have now?

A: The answer is 11.

Q. The cafeteria had 23 apples. If they used 20 to make lunch and 
bought 6 more, how many apples do they have? In the presentation, the model in use incorrectly returned 27. In my test, it worked correctly, but I absolutely saw issues with math back when I built my last November. generative AI blackjack advice demo As I said, Gemini handled it fine: But in Prompt Tester, I tried the suggested CoT prompt: A: The answer is 9. Q: Roger has 5 tennis balls. he buys 2 more cans of tennis balls. Each 
can has 3 tennis balls. How many tennis balls does he have now?

A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 
tennis balls. 5 + 6 = 11. The answer is 11.

Q. The cafeteria had 23 apples. If they used 20 to make lunch and 
bought 6 more, how many apples do they have? And the result was improved, showing how it got to the answer: A: The cafeteria had 23 apples. They used 20 apples for lunch, which 
means they have 3 apples left. They then bought 6 more apples, so 
they now have a total of 3 + 6 = 9 apples.

The answer is 9. The difference is pretty significant. The Code If this seems useful to you at all, feel free to grab the code from here: . As I mentioned, it shouldn't be that difficult to add or some such and use a different service. If you do, let me know! https://github.com/cfjedimaster/ai-testingzone/tree/main/prompt_tester callChatGPT

How to Test Multiple Variations of Generative AI Prompts

জেনারেটিভ এআই প্রম্পটগুলির একাধিক বৈচিত্র কীভাবে পরীক্ষা করবেন

So testen Sie mehrere Variationen generativer KI-Eingabeaufforderungen

Cómo probar múltiples variaciones de indicaciones de IA generativa

Comment tester plusieurs variantes d'invites d'IA générative

जेनरेटिव एआई प्रॉम्प्ट के एकाधिक विविधताओं का परीक्षण कैसे करें

生成 AI プロンプトの複数のバリエーションをテストする方法

Generative AI 프롬프트의 다양한 변형을 테스트하는 방법

Como testar múltiplas variações de prompts de IA generativos

Как протестировать несколько вариантов подсказок генеративного ИИ

Üretken Yapay Zeka İstemlerinin Çoklu Varyasyonlarını Test Etme

Cách kiểm tra nhiều biến thể của lời nhắc AI sáng tạo

如何测试生成式 AI 提示的多种变体

Way back in January (remember January), I wrote a blog post describing how to use . This worked by uploading the image to Google Gemini, asking for a short description, and using that description for a new filename. Recently, I was thinking about that demo and was curious how well it would work for video games. gen ai to improve image filenames As always, I did a few quick tests in . I did some quick Googling for various games and screenshots, and the results were pretty impressive. Here are three mostly modern examples: Google AI Studio And here's a first failure, identifying this as Final Fantasy 14, not 16. It did well for one old game, although, to be fair, the name is in the picture: really Although failed on this rather obscure one. It's Bard's Tale 2, not Betrayal at Krondor. Also, note it didn't follow my directions to answer with just the name of the game. I then tried a few race games. I was really curious about this as, with the high fidelity of modern racing games, it feels like it would be a difficult task. Surprisingly, it got them right: I then went old school and obscure, and it failed, but it was worth a shot. (The first person to identify it using reverse image search earns 200 Nerd Points.) super without So, all in all... it worked reasonably well. So, let's talk automation! Automating the Process Nearly two years ago, I blogged about to Dropbox. This made use of the fact that the Switch can post to Twitter, and you can use to scrape media from a Twitter account. As far as I know, that probably doesn't work since Twitter crapped the bed on developer access. While it work, the images I got had random names for images. copying Nintendo Switch screenshots Pipedream did The XBox can upload to OneDrive and actually does name the images, which is super helpful. In case you can't read it, the filename is . It's not only got the game in the screenshot but the date and time as well. For the purposes of this blog post, I'm going to ignore that, but in a real application, I'd probably just handle the XBox images with a bit of custom code, so no AI is needed. Diablo IV-2024_02_19-1514-24.png PlayStation is a bit more wonky and a bit surprising. As far as I can tell, you can share videos on YouTube, but screenshots can only be added to the PS app or copied to a USB drive. Again, surprising. Here's a screenshot showing how the images are named, and as you can see, nothing relevant is included. For the purpose of this, let's make some assumptions (nothing ever goes wrong with that, right?). We will assume that our screenshots all get stored in a Dropbox folder named, . SSIn I'm going to build a Pipedream workflow that will: Trigger on a new file added to SSIn. Download the image. Use Gemini AI to determine the game. Use the name as a new folder in Dropbox, under SSOut, So for example, /SSOut/Galaga Upload the image and auto-rename it based on the time. This lets us know when the screenshot was - well, not taken, but at least added to Dropbox. Let's break it down: Step One - The Trigger This part is relatively simple in Pipedream. I created a trigger for new files based on Dropbox action. I specified the path and told it to include a link so it could be downloaded. Step Two - Download the File The next step is another built-in Pipedream action, downloading a file. In this case, it gets downloaded to with the original filename. /tmp Step Three - Use AI to Determine the Game The next step is a Node.js step that essentially takes the code output from AI Studio and has it work with the file in : /tmp import fs from 'fs';
import {
  GoogleGenerativeAI,
  HarmCategory,
  HarmBlockThreshold,
} from "@google/generative-ai";

async function identifyPic(path, key) {
  const MODEL_NAME = "gemini-1.0-pro-vision-latest";
  const API_KEY = key;

  const genAI = new GoogleGenerativeAI(API_KEY);
  const model = genAI.getGenerativeModel({ model: MODEL_NAME });

  const generationConfig = {
    temperature: 0.4,
    topK: 32,
    topP: 1,
    maxOutputTokens: 4096,
  };

  const safetySettings = [
    {
      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
  ];

  const parts = [
    {text: "Can you identify what game this screenshot comes from? Just tell me the game.\n\n"},
    {
      inlineData: {
        mimeType: "image/png",
        data: Buffer.from(fs.readFileSync(path)).toString("base64")
      }
    },
  ];

  const result = await model.generateContent({
    contents: [{ role: "user", parts }],
    generationConfig,
    safetySettings,
  });

  return result.response.candidates[0].content.parts[0].text;
}

export default defineComponent({
  async run({ steps, $ }) {
    return await identifyPic(steps.download_file_to_tmp.$return_value[1], process.env.PALM_KEY);
  },
}) The only really important part here is the first argument to , the path. Note that the path is the result value from the download step. This definitely surprised me. identifyPic second Step Four - Create a Folder The next step was also a 'built-in,'’ creating the folder. Now, I should warn you. I'm pretty sure this step is going to throw an error if you run twice in the same game. The action's configuration lets you pick a new name if it already exists but doesn't have a "don't make it if it already exists" parameter. I didn't get a chance to test that, but if it an issue, I'd simply switch to the Pipedream feature that lets you hit any Dropbox API with the right credentials, check the Dropbox API docs, and see if it's possible there, or heck, just wrap in a . is try/catch Outside of that, note that I added a to the result from Google as it had a space in front. trim() Also note that sometimes Gemini will return a sentence, not just a game name. For example, "The game is X". I figure that will be pretty obvious in the output and a human can handle that. Step Five - Upload The final step is to upload the picture to the new output directory. To get the name to be date-based, I used a pretty long expression: Did it work? Sure did! I mean it's brittle as heck, but here's the output from a few runs. First, top-level folder: And here's the contents of the Valhalla one: The Code, and Everything Else All in all, I think this works "OK" to "Well", but it is not perfect. I definitely think a human could help, and in fact, one thing Pipedream makes easy is sending emails. You could easily add an email notification at the end where a person could see if something got misfiled. Anyway, this was fun, and if you want to use this yourself in Pipedream, you can find the workflow here: https://github.com/cfjedimaster/General-Pipedream-AI-Stuff/tree/production/identify-and-sort-screenshots-p_brCmQz3 Also published . here

Organizing Video Game Screenshots Using Generative AI

So far, most of my playing with Generative AI has been on the prompt side, with no real look at the various settings you can tweak in your calls. As I'm still very new to this, I'm trying my best to take things slowly. But every time I open and see the settings on the right, I keep nagging myself to take a deeper look. Google AI Studio You can also see the various settings options in the default code Studio spits out: const generationConfig = {
	temperature: 0.9,
	topK: 1,
	topP: 1,
	maxOutputTokens: 2048,
};

const safetySettings = [
	{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,	threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
]; I thought today I'd take a look at , as I had a rough idea of what it implied. Temperature, at a high level, refers to how 'varied' a particular generated response can be. As an example, if I were to say, "I like ____", then you could make a list of what the next word would be, rated by how likely it is: temperature very Cats (VERY LIKELY) Star Wars (LIKELY) Books (LIKELY) Vegetables (UNLIKELY) At the highest temperature value, there will be a of variety. At the lowest level, no variety. Now, from what I know, that does mean that every response will be the same. Just very similar. This post, , does a great job explaining temperature (and other settings). lot not "Creatively Deterministic: What are Temperature and Top_P in Generative AI?" While it's relatively easy in AI Studio to adjust the temperature setting you see above, what I really wanted was a tool to help me see multiple results at once. So, I built one. :) Temperature Testing Tool My tool begins with a simple prompt: This is pretty vanilla HTML, so I won't share the code here (I've got a link to everything down below). Upon hitting the button, that's where the magic begins. Here's the JavaScript: // Testing ranges for temperature
const tempRanges = [0, 0.3, 0.6, 1];

// How many times to test per temp.
const perTemp = 2;

let $status, $results;

document.addEventListener('DOMContentLoaded', init, false);
async function init() {
	document.querySelector('#submitBtn').addEventListener('click', handleSubmit, false);
	$status = document.querySelector('#status i');
	$results = document.querySelector('#results');
} I begin with some variable declarations and a listener for . The first two variable sections are the crucial ones. Temperature values go from 0 (focus on only the highest probable response) to 1 (be more creative), and I decided to test four values in that range. DOMContentLoaded For each range in the array of temperatures, I do two tests. My thinking was that two results would be enough to see the variance in one particular temperature value. Carrying on... async function handleSubmit(e) {
	e.preventDefault();
	$results.innerHTML = '';

	let prompt = document.querySelector('#prompt').value.trim();
	if(prompt === '') return;

	/*
	We are going to loop perTemp times for each tempRange. In order to not
	get stopped by Gemini for too many requests, and to provide feedback to the user, 
	I'll report after each tempRange
	*/
	for(temp of tempRanges) {
		$status.innerText = `Getting results for temperature ${temp}.`;
		let promises = [];
		for(let i=0; i<perTemp; i++) {
			promises.push(getResult(prompt, temp));
		}

		let results = await Promise.all(promises);
		let html = `<h2>Temperature ${temp}</h2>`;
		for(let i=0; i < results.length; i++) {
			html += `
<p>
Result #${i+1}:<br/>
${results[i]}
</p>`;
		}
		$results.innerHTML += html;
		console.log(results);
	}

	$status.innerText = ``;
	
}

async function getResult(prompt, temperature) {
	console.log(`Calling getResult with prompt ${prompt} and ${temperature}`);
	let body = {
		prompt, 
		temperature
	};
	let req = await fetch('/api', { method: 'POST', body: JSON.stringify(body)});
	return await req.json();
} In this code, I loop over the range of temperatures and then make my two sample calls. When done, I render it out to the screen. The last function simply passes my prompt and temperature to the backend API. I'll share a screenshot, but it's a wall of text. This is only a small portion: long The backend is a lightweight Node.js server that basically handles outputting my HTML and responding to the request by the client-side JavaScript. Let's take a look at that, specifically the portion handling the Google Gemini call: POST import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from '@google/generative-ai';

const MODEL_NAME = "gemini-pro";
const API_KEY = process.env.GOOGLE_AI_KEY;

const genAI = new GoogleGenerativeAI(API_KEY);
const model = genAI.getGenerativeModel({ model: MODEL_NAME });

async function callGemini(text, temperature) {

	const generationConfig = {
		temperature,
		topK: 1,
		topP: 1,
		maxOutputTokens: 2048,
	};

	const safetySettings = [
		{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,	threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	];

	const parts = [
    	{text},
  	];

	const result = await model.generateContent({
		contents: [{ role: "user", parts }],
		generationConfig,
		safetySettings,
	});

	const response = result.response.candidates[0].content.parts[0].text;
	
	return response;
} This is pretty much the exact code spit out by Studio but wrapped into a function where the prompt and temperature can be passed in. This function has error handling, and that absolutely bit me in the butt. I'm going to be taking a look at those errors, and how to handle them, in a future blog post. no So what did I find? Results Here are the results of using the prompt: "Tell me a story about cats." First, temperature 0. Result 1 Once upon a time, in a quaint little town nestled amidst rolling hills, there lived a mischievous cat named Mittens. Mittens was known throughout the neighborhood for her playful antics and her insatiable curiosity. One sunny afternoon, as Mittens was basking in the warmth of the sunbeam that streamed through the window, she noticed a peculiar sound coming from the kitchen. Intrigued, she hopped off the window sill and tiptoed towards the source of the noise. Upon entering the kitchen, Mittens discovered a group of kittens huddled around a bowl of milk. Their tiny paws were eagerly reaching for the sweet liquid, and their eyes sparkled with delight. Mittens, being the adventurous cat she was, couldn't resist joining in on the fun. With a playful leap, Mittens landed gracefully in the midst of the kittens. She purred loudly, her tail swishing back and forth as she rubbed against their soft fur. The kittens, initially startled by the sudden intrusion, soon warmed up to Mittens' friendly presence. Together, they formed a circle around the bowl of milk, their whiskers twitching as they lapped up the delicious treat. Mittens, being the eldest and most experienced cat, took it upon herself to teach the kittens proper table manners. She showed them how to take turns and how to avoid spilling the milk. As the kittens learned and grew, they developed a deep bond with Mittens. They looked up to her as their mentor and protector. Mittens, in turn, cherished her role as the leader of the pack. She spent her days playing with the kittens, teaching them valuable life lessons and keeping them safe from harm. Word of Mittens' extraordinary kindness and wisdom spread throughout the town. People would often bring their cats to her, seeking her advice and guidance. Mittens welcomed each and every cat with open paws, offering them comfort, support, and a sense of belonging. And so, Mittens became known as the "Guardian Cat" of the town. She was loved and respected by all, both humans and cats alike. Her legacy lived on for generations, inspiring countless cats to follow in her paw prints and spread joy and kindness wherever they went. Result 2 Once upon a time, in a quaint little town nestled amidst rolling hills, there lived a mischievous cat named Mittens. Mittens was known throughout the neighborhood for her playful antics and her insatiable curiosity. One sunny afternoon, as Mittens was basking in the warmth of the sunbeam that streamed through the window, she noticed a peculiar sound coming from the kitchen. Intrigued, she hopped off the window sill and tiptoed towards the source of the noise. Upon entering the kitchen, Mittens discovered a group of kittens huddled around a bowl of milk. Their tiny paws were eagerly lapping up the delicious liquid, their whiskers quivering with delight. Mittens, unable to resist the temptation, joined the kittens and began to partake in the feast. As they drank, Mittens couldn't help but notice that one of the kittens was smaller and weaker than the others. It struggled to keep up with its siblings, and its eyes held a look of longing. Mittens, being the compassionate cat that she was, decided to help the little kitten. With a gentle nudge, Mittens pushed the other kittens aside and made room for the weaker one. She then curled her tail around the kitten, providing it with warmth and comfort. The little kitten, grateful for Mittens' kindness, nuzzled against her fur and began to purr softly. As the kittens continued to drink their milk, Mittens couldn't help but feel a sense of fulfillment. She had not only satisfied her own hunger but had also brought joy and comfort to a fellow creature. From that day forward, Mittens became known as the neighborhood's guardian angel. She would often be seen playing with the kittens, teaching them how to climb trees and chase butterflies. She would also bring them food and shelter when they were in need. The kittens, in turn, adored Mittens and would follow her everywhere she went. They would purr and rub against her legs, showing their affection and gratitude. And so, Mittens lived a long and happy life, surrounded by the love and companionship of her feline friends. She taught the town's residents the importance of kindness and compassion, and her legacy lived on long after she was gone. Notice that both start off the same and then diverge. To save on space, I'll skip to temperature 1 next. Result 1 Once upon a time, in a bustling city called Willow Brook, there lived a calico cat named Mittens. Mittens had a reputation for being a fearless explorer, always curious and eager for adventure. One day, Mittens embarked on her biggest expedition yet. She had heard rumors of a secret garden hidden deep within the city park, and she was determined to find it. When nightfall came, Mittens began her adventure, carefully sneaking out of her home and into the park. The park was silent, illuminated only by the soft glow of the moon. As she tiptoed through the winding paths, a faint scent of flowers carried by the wind caught her attention. Mittens followed the scent until she stumbled upon a large tree. Its branches were laden with bountiful blooms, and a gentle breeze sent petals raining down on her. Suddenly, a soft voice whispered, "Welcome, little traveler." Mittens looked around, her eyes widening in astonishment. Sitting on a branch was a beautiful cat; its fur shimmered like the night sky. "I am Esmerelda," the cat said, "and you are Mittens, the brave calico." Mittens was amazed. She had heard stories about Esmerelda, a magical cat said to hold the secret to unlocking the hidden garden. "Yes, Mittens," Esmerelda continued, "you have found the Enchanted Garden. But to enter, you must pass three challenges." Without hesitation, Mittens agreed. Her first challenge was to find a golden key hidden within the roots of an oak tree. With her sharp claws and determined spirit, Mittens discovered the key, its surface glowing brightly. Next, Esmerelda asked Mittens to gather dewdrops from the heart of a moonflower blossom. As Mittens gracefully leaped and climbed the tall stems, she carefully collected the sparkling dew in a tiny seashell. Finally, Mittens' last challenge was to sing a song that would make the trees sway and the flowers bloom. As Mittens lifted her voice, her melodious' tune enchanted the garden, which sprang to life with vibrant colors and dazzling lights. Esmeralda smiled, "Well done, little traveler. You have passed the challenges." With a gentle paw, Esmerelda touched the large oak tree, causing it to slowly open like a door, revealing an awe-inspiring paradise. Inside the Enchanted Garden, Mittens found lush meadows, sparkling fountains, and exotic creatures playing among the trees. It was a place of wonder and joy as if every storybook she had ever heard had come true. Mittens spent the entire night exploring the magical realm, amazed by its beauty. As dawn broke, she turned to Esmerelda and said, " Thank you for sharing this incredible place with me. Esmerelda purred softly. "You are welcome, Mittens. As long as you believe in magic, the garden will always be here for you to explore." From that day forward, Mittens became the guardian of the Enchanted Garden, a place where she could always find solace, friendship, and a sense of belonging among the natural beauty of Willow Brook. And so, the legend of the brave calico and the Enchanting Garden lived on, brought to life of the belief in magic and the wonders that can be found when one dares to explore beyond the ordinary. Result 2 Once upon a time, in a small and charming town called Willow Creek, nestled amidst rolling hills and blooming meadows, there lived two extraordinary cats. One was a sleek and graceful Siamese named Luna, whose shimmering white fur and piercing blue eyes radiated elegance and mystique. Her every movement exuded nimbleness, gliding through the streets of Willow Creek with an air of regal composure. Meet the second cat, a tabby by the name of Max, a playful and mischievous soul adorned with a coat of orange and black stripes. His sparkling green eyes twinkled with a mischievous glint; ears always perked, ever alert to the adventures that awaited him. His playful antics had become a legend among the townspeople, who were often greeted by his friendly antics and joyful meows. The companionship between Luna and Max was a sight to behold. They were inseparable, roaming the cobblestone streets together, their playful pursuits leading them to alleyways and secret paths known only to them. Their friendship was a true testament to the unwavering spirit and unbreakable bond between cats. During the day, they would bask lazily in the warm sunlight that bathed the town square, absorbing the melody of children playing and the laughter of friends sharing stories. At night, under the velvet sky adorned with shimmering stars, they would chase elusive fireflies and embark on daring expeditions, exploring the town's hidden nooks and crannies, their soft paw steps barely disturbing the tranquil silence. Many a local came to rely on the presence of Luna and Max, knowing that their playful chases and affectionate purrs brought an unexplainable joy and warmth to the heart. The elderly, feeling isolated, found solace in their presence, witnessing a simple yet profound beauty in their interactions. Children were captivated by their antics, watching in delight as they climbed trees or chased each other through the flowerbeds. One day, a traveling circus arrived in Willow Creek, filled with fanfare and vibrant colors. Luna and Max, captivated by the excitement, couldn't resist exploring the wonders this circus held. As they ventured into the largest tent, they were greeted with the mesmerising spectacle of trained cats, performing incredible feats of agility and balance. Inspired by their newfound passion, Luna and Max made a daring decision - they ran away to join the circus! They honed their skills tirelessly, practicing their balancing acts and performing stunning leaps. Their dedication and unwavering friendship caught the attention of the ringmaster, who recognized their talent and potential. Finally, the moment arrived when Luna and Max took center stage, their hearts pounding with excitement and anticipation. The audience, holding their breath in anticipation, witnessed an extraordinary performance, a mesmerizing ballet of agility and grace. Luna's elegant poise and Max's playful energy combined to create a symphony of motion that left the spectators awe-inspired. News of Luna and Max's incredible talents spread like wildfire, and they became stars of the circus, sharing their joy and laughter with audiences of all ages. Their unwavering friendship remained the heart of their performances, a symbol of the magical bond between cats that touched the hearts of all who witnessed their amazing journey. And so, Luna and Max, once ordinary cats roaming the streets of Willow Creek, found their destined path in the spotlight of the circus ring, leaving behind a legacy of a friendship that defied the ordinary and inspired the extraordinary in others. As you can tell, even if you only skimmed it, these are much more varied. I found having all these variations on screen at once, from the same prompt, a easy way to help me understand the impact of temperature. If you want to try this yourself, you can grab the bits here: real https://github.com/cfjedimaster/ai-testingzone/tree/main/temp_tester Download the code, the required bits, and set an environment variable for your Google API key. Run the script ( ) and it will open up a web server on port 3000. Lastly, just open that up with your browser. npm i node script.js As always, let me know what you think. I've got some ideas for other tools like this as a way of learning generative AI! Also published . here

Testing Generative AI Temperature Settings with Some Cat Stories

ASP.NET Core is an open-source framework for building modern web applications. NUnit, on the other hand, is a unit-testing framework for C# developers. In this article, I’ll explain how you can use NUnit in testing to ensure that you have coverage on your web applications! ASP.NET Core Testing is a crucial step in software development as it ensures the reliability and quality of code while reducing debugging time and cost. This article touches on the benefits of testing with NUnit and will provide a step-by-step guide on how to implement unit testing in ASP.NET Core to improve your code quality. Let’s dive in! Understanding ASP.NET Core Testing ASP.NET Core is a widely used open-source framework for building web applications, and like any software, it can have issues that need to be addressed. One way to ensure that your application is reliable and meets the user’s needs is to perform rigorous testing. In this section, I will explain the basics of ASP.NET Core testing, the benefits of using NUnit for testing, and how to create an NUnit project to test an ASP.NET Core application. What is Testing in ASP.NET Core? ASP.NET Core testing is the process by which developers test an ASP.NET Core application to ensure that it works as intended. Testing can help to determine issues that may exist in both the front-end and back-end code. ASP.NET Core testing can be done using various testing frameworks, but in this article, we will focus on NUnit. It’s important to acknowledge that we have multiple different testing types available to us, regardless of what framework we’re using. With that said, many people talk about “unit” tests but there are “functional” or “integration” tests as well. I treat “unit” tests as tests that are much more isolated and require mocking out dependencies. In contrast, I use “functional” or “integration” tests to cover much more broad areas of a system. What’s the “best” way to test? The answer, in my opinion, is a mix across the spectrum of what’s available. Prioritize the styles of testing that give you the best levels of confidence in your code. Check out this video on testing approaches for more of my perspective on this: https://youtu.be/iBkSSuQBJx0?embedable=true Benefits of Testing with NUnit NUnit is an open-source unit testing framework for Microsoft .NET that is widely used in the development community. Some benefits of testing with NUnit include: Improved code quality – Automated testing with NUnit ensures that code is working as intended and helps catch errors earlier in the development process. Simplified debugging – By testing with NUnit, developers can quickly identify and isolate issues, which makes debugging much more manageable. Consistent functionality – Running NUnit tests assures developers that changes to the code do not impact the existing functionality of the application. Creating an ASP.NET Core Project for Testing To start unit testing in ASP.NET Core applications with NUnit, you need to have a project to test. You can either create a new project explicitly for testing or use an existing project. A good practice is to keep your test project separate from your production project—this way, any changes you make will only affect the test project. To explain this more clearly – you want to separate what you are using for supporting your tests from the code that you want to ship to production. In the same way that when you download an app to your phone you’re not getting all of the testing code from the app developer, when you deploy a web application you don’t want to deploy all of the test code with it. By separating out your deployable product code from your test code, you have the flexibility to have a dedicated test environment separate from your production environment! Setting up an NUnit Project Setting up an NUnit project is relatively simple and straightforward—there are just a few things to keep in mind. You need to make sure you have the correct NuGet packages installed, and you need to create a class file specifically for your unit tests. Once you’ve set up your NUnit project, you can start writing tests for your application. Let’s make sure you get the packages you need: NUnit – This is the testing framework itself. You’ll need this to be able to mark tests and use assertion logic in your tests! Microsoft.NET.Test.Sdk – If you’re running tests from Visual Studio, you’ll need to ensure you have the .NET test SDK included as well. Without this and JUST having NUnit, you’ll be able to mark your tests but they won’t get picked up to be able to run! NUnit3TestAdapter – Finally, you’ll need this test adapter to run the NUnit tests from inside the Visual Studio test explorer. With these Nuget packages added to your test project, you’re on your way to creating reliable and high-quality software! Next up, we’ll focus on creating the tests themselves. Writing Basic NUnit Tests in CSharp Now that we have a basic understanding of ASP.NET Core testing and how to set up an NUnit project, let’s dive into writing NUnit tests for an ASP.NET Core application. Writing Your First NUnit Test Before we get into the web side of things, the first step in writing NUnit tests is to write a simple test that validates that a method returns the expected output. Let’s say we have a method called on a class called that adds two numbers together. To write a test for this method, we would write the following code: Add Calculator using NUnit.Framework;

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_TwoNumbers_ReturnsSum()
    {
        // Arrange
        Calculator calculator = new Calculator();
        int x = 2;
        int y = 3;

        // Act
        int sum = calculator.Add(x, y);

        // Assert
        Assert.AreEqual(5, sum);
    }
} This code defines a test class, which contains the individual tests. The test method is decorated with the attribute, which tells NUnit that this method is a test. The method has three parts: [Test] Add_TwoNumbers_ReturnsSum Arrange section initializes the variables Act section performs the operation we want to test Assert section compares the actual result to the expected result This is a common format to follow for readable tests. And at this point, we’ve seen the basic setup for marking a test method and defining how we can assert conditions! Using Assertions to Validate Test Results Assertions are a fundamental part of NUnit tests — and all testing frameworks, for that matter. They provide a way for tests to perform comparisons between expected and actual values. The assertion part of a test should draw your attention to what’s truly being validated, and not just exercised. Remember, it’s one thing for a line of code to be executed, but it’s another thing for us to validate that the line of code we executed is doing what we expect! There are several types of assertions available in NUnit, including: – Tests if two values are equal. Assert.AreEqual(expected, actual) – Tests if a condition is true. Assert.IsTrue(condition) – Tests if a condition is false. Assert.IsFalse(condition) – Tests if an object is null. Assert.IsNull(object) – Tests if an object is not null. Assert.IsNotNull(object) These assertions can be used in the Assert section of a test method, as shown in the previous example. Testing Web APIs with NUnit in ASP.NET Core Testing web APIs is an essential part of ensuring that the functionality of an ASP.NET Core application works as intended. To write tests for web APIs, we can use the class provided by the namespace in C#. Here is an example of how to test a basic GET request using NUnit: HttpClient System.Net.Http using NUnit.Framework;
using System.Net.Http;
using System.Threading.Tasks;

[TestFixture]
public class MyApiTests
{
    [Test]
    public async Task Get_EndpointReturnsSuccessAndCorrectContentType()
    {
        // Arrange
        HttpClient client = new HttpClient();
        string url = "https://example.com/api/values";

        // Act
        HttpResponseMessage response = await client.GetAsync(url);
        string responseContent = await response.Content.ReadAsStringAsync();

        // Assert
        response.EnsureSuccessStatusCode();
        Assert.AreEqual("application/json; charset=utf-8",
            response.Content.Headers.ContentType.ToString());
    }
} In this example, we use an object to execute the GET request. The test checks if the response is successful and has the correct content type. HttpClient What’s the big problem with this though? It’s hitting a URL out on the Internet! Even if you change it to localhost or 127.0.0.1, you still need to find a way to manage the lifecycle of the application that you want to test! WebApplicationFactory with NUnit in ASP.NET Core To solve this, we can use a ! I recommend you as an additional primer to spinning up a web app to test. is agnostic to the testing framework you choose (xUNit, NUnit, or whatever else) so you can use it with what you have seen in this article so far. WebApplicationFactory check out this article on using WebApplicationFactory WebApplicationFactory To jump into a concrete code example, let’s see the following: using System.Net.Http;
using System.Threading.Tasks;

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;

using NUnit.Framework;

[TestFixture]
public class MyApiTests
{
    [Test]
    public async Task Get_EndpointReturnsSuccessAndCorrectContentType()
    {
        // Arrange
        var factory = new WebApplicationFactory<Program>().WithWebHostBuilder(builder =>
        {
            builder.UseEnvironment("Testing");
        });
        var client = factory.CreateClient();
        string url = "https://example.com/api/values";

        // Act
        HttpResponseMessage response = await client.GetAsync(url);
        string responseContent = await response.Content.ReadAsStringAsync();

        // Assert
        response.EnsureSuccessStatusCode();
        Assert.AreEqual("application/json; charset=utf-8",
            response.Content.Headers.ContentType.ToString());
    }
} Please note that the type parameter included here in the is because of using minimal APIs in a web project that we want to test. And if you’re using the minimal API approach, you may need to put this at the end of your program.cs file in your web application to publicly expose your class to your test project, or look into to expose this internal class to your test project: <Program> WebApplicationFactory Program InternalsVisibleTo https://youtu.be/TjsM3oVg5_w?embedable=true Benefits of NUnit in ASP.NET Core Tests Unit testing with NUnit in ASP.NET Core can provide a range of benefits that help create high-quality software. In this section, we will discuss how using NUnit for testing can improve your code’s reliability and quality, as well as speed up the debugging process. Increased Code Reliability and Quality NUnit tests are automated, which means that they can run quickly and easily. Running tests regularly can help you catch errors and spot issues early on in the development lifecycle, allowing for prompt and effective solutions. By running tests regularly with NUnit, teams can be confident that their code is working as it should, and it provides relevant data about the quality of the code. Automatic testing can also ensure that there are no regression bugs that would otherwise go unnoticed. Faster and Easier Debugging Debugging software can be a challenging task for many developers. By running NUnit tests, you can isolate bugs early on in the development cycle and fix them as quickly as possible. NUnit makes use of the “Arrange-Act-Assert” pattern, which allows developers to identify the problem if a test fails. This pattern is particularly useful in allowing developers to isolate errors and produce effective debug reports. Ensuring Consistent Functionality Through Code Changes The functionality of an application can change when code is added or modified. Testing with Nunit in ASP.NET Core allows you to run tests regularly and ensure that any changes to the code don’t impact existing functionality. This process is necessary to ensure consistent functionality across the development lifecycle of any project — and using functional/integration test coverage on ASP.NET Core web APIs can be incredibly powerful for helping build this confidence. NUnit testing can provide a wide range of benefits to developers looking to create high-quality software. By relying on NUnit test-driven development, you can: Improve the reliability and quality of your code Reduce the time and effort needed to debug Help ensure consistent functionality throughout the development cycle Wrapping Up NUnit in ASP.NET Core Learning how to use NUnit in ASP.NET Core is a valuable skill for any C# developer creating web APIs. Not only does it increase the reliability and quality of your code, but it also ensures consistent functionality through code changes. Additionally, debugging becomes faster and easier, saving time and resources. Catching issues now is *WAY* better than hearing from your customer. By leveraging NUnit in ASP.NET Core, you can catch bugs early on, preventing them from becoming larger issues down the line. As a result, you and your development team can produce higher-quality software in less time. I highly recommend incorporating NUnit testing into your work with ASP.NET Core — and ! if not NUnit then at least consider xUnit With a willingness to experiment with different testing approaches, your team can take its testing capabilities to the next level! Mix and match your types of testing coverage to greatly increase your level of confidence in your changes. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here.

Getting Started With NUnit in ASP.NET Core

Last week, I had the honor of presenting one at . This was my first presentation on generative AI, and I got to share what I thought was an interesting use case - helping with the writing process. TheJam.dev Now, to be clear, I don't mean using GenAI to write blog posts, that would be a horrible idea. (IMO!) Instead, I looked at how it could help with some of the process. Let me back up a bit and give some background. I've been a fan of for many years now. He's an author who writes in the military/sci-fi/etc genre and has some pretty fascinating ideas. I initially discovered him via his "Axis of Time" trilogy which dealt with the idea of a modern international naval fleet being sent back in time to 1942. John Birmingham Now, that by itself is cool, however, I loved that he didn't just focus on the military aspect but spent a lot of time talking about the culture clash between the "uptimers" (folks from the future) and the contemporaries. I suppose you could say it was a bit like Tom Clancy but not just focused on the action. I'd pretty much recommend any of his books, and if you've read him already, let me know in a comment below. As a follower of his work, I subscribed to his Patreon, and it's been really interesting. He shares drafts of chapters from upcoming works, but more importantly, he also talks about his process quite a bit. As a writer myself, I find this really fascinating. Recently, he was talking about his own use of GenAI and discussed how he's using it from more of a 'framework' perspective. I.e., how to bring in a character's motive at the right time, and how to set up plot points. This is still 'creative' work, but more ... I don't know. Management of the work? As I said though, I thought it was really interesting, and it got me thinking. How could I use GenAI on my blog as a way to help with the writing process? Here's what I came up with. As a quick aside, everything I discuss below makes use of Google's and , but would certainly be useful elsewhere. Gemini API Eleventy Suggesting Titles The first demo I built involved helping me come up with titles for blog posts. Now, I typically don't struggle with this, but I was curious if GenAI could perhaps suggest alternatives for titles. better I began by testing out a prompt: gemi Given the following title for a blog post, share three suggestions that may improve the title and drive traffic to the post: "SOME TITLE". Present your answer in JSON form. The top level key of the JSON result should be "suggestions" and each suggestion should use the key "title" for the suggested title and "reasoning" for the reasoning. You'll notice that I specifically ask for three suggestions and say I want to help drive more traffic. Now, I'll be honest. That feels a bit gross and spammy. I don't necessarily want clickbait titles. That being said, I wanted to see some other ideas for my titles. That prompt seemed to work well with a few tests in , so I jumped into code. I took the code Google exported, and then wrote a bit of code to: AI Studio Let me pass a filename in via the command line. Parse the front matter to get the title. Then call the GenAI endpoint. Here's the entire script: #!/usr/bin/env node

/*
Given an input MD file, grab the title, and ask Google's AI APIs to offer suggestions. 
*/

const fs = require('fs');
const fm = require('front-matter');
require('dotenv').config({path:__dirname + '/.env'});

const {
  GoogleGenerativeAI,
  HarmCategory,
  HarmBlockThreshold,
} = require("@google/generative-ai");

const MODEL_NAME = "gemini-pro";
const API_KEY = process.env.GOOGLE_AI_KEY;

async function runGenerate(title) {
  const genAI = new GoogleGenerativeAI(API_KEY);
  const model = genAI.getGenerativeModel({ model: MODEL_NAME });

  const generationConfig = {
    temperature: 0.9,
    topK: 1,
    topP: 1,
    maxOutputTokens: 2048,
  };

  const safetySettings = [
    {
      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
  ];

  const parts = [
    {text: `Given the following title for a blog post, share three suggestions that may improve the title and drive traffic to the post:  \"${title}\". 
    Present your answer in JSON form. The top level key of the JSON result should be "suggestions" and each suggestion should use the key "title" for the suggested title and "reasoning" for the reasoning.
    
    The returned JSON should look like the following sample:

    [
      { 
        title: "First suggested title", 
        reasoning: "This is the reason for the suggestion."
      }
    ]
   
    `},
  ];

  const result = await model.generateContent({
    contents: [{ role: "user", parts }],
    generationConfig,
    safetySettings,
  });

  const response = result.response;
  // remove backticks and parse. I'm seeing ```json sometimes too
  // console.log('DEBUG', response.text());
  return JSON.parse(response.text().replace(/```/mg, '').replace(/```json/mg,''));
}

(async () => {
  if(process.argv.length === 2) {
    console.log('Usage: titlesuggestions.js <<path to md>>');
    process.exit(1);
  } 

  const mdPath = process.argv[2];
  if(!fs.existsSync(mdPath)) {
    console.log(`Unable to find ${mdPath}.`);
    process.exit(1);
  }

  const contents = fs.readFileSync(mdPath,'utf-8');
  let title  = fm(contents).attributes.title;
  console.log(`\nGenerating suggestions for: ${title}`);
  console.log('------------------------------------------------------------------------');

  let suggestions = (await runGenerate(title)).suggestions;
  //console.log(suggestions);
  suggestions.forEach(s => {
    console.log(`Suggested Title: ${s['title']}\n\nReasoning: ${s['reasoning']}\n`);
    console.log('------------------------------------------------------------------------');
  });
})(); And how does it work? This blog post is titled: "Using Generative AI as Your Content Assistant" Here's what Gemini suggested: Suggested Title: The Power of Generative AI: Your New Content Assistant

Reasoning: This title emphasizes the strength and potential of generative AI as a content creation tool, capturing the reader's attention and making them curious about the possibilities it offers.

------------------------------------------------------------------------
Suggested Title: Unlock Your Content Creation Potential with Generative AI

Reasoning: This title suggests that generative AI can unlock new levels of productivity and creativity in content creation, attracting readers who are looking for ways to enhance their content strategy.

------------------------------------------------------------------------
Suggested Title: Revolutionize Your Content Creation: Meet Your Generative AI Assistant

Reasoning: This title highlights the transformative potential of generative AI in content creation, appealing to readers who are eager to adopt cutting-edge technologies to streamline their workflow. Yeah... I think that's pretty cool. However, none of these really feel like "my" voice here. I absolutely see some merit in the suggestions, and it gives me something to think about, but obviously, I left the original title as is. Writing the Description (Summary) For my next demo, I looked at a part of my writing process I really don't enjoy, writing the one-sentence value used in my front matter. This string ends up going into my tag and isn't used anywhere else. description <meta name="description"> I thought this would be an excellent use of GenAI's summarization feature. I began with a prompt like so: Given the following blog post, write a one sentence summary to use as the description And then thought about what content I'd send. My blog posts typically have a lot of code samples, and I figured that would end up being noise. So my logic became: Let me pass a filename in via the command line. Parse the front matter to get the title (just for output to me purposes). Get the content of the blog post. 'Clean' it up. Then, call the GenAI endpoint. Most of this is just a modified version of the first example, but let's take a look at the cleanup aspect: function cleanup(str) {
	str = str.replace(/```(.*?)```/sg, '');
	str = str.replace(/---(.*?)---/sg, '');
	str = str.replace(/\n{3,}/g, '\n');
	return str.trim();
} This is passed the entire contents of the blog post, so I removed the front matter and code samples. I then replaced multiple blank lines as well. Here's the entire script: #!/usr/bin/env node

/*
Given an input MD file, grab the text, scrub code, and ask for a summary.
*/

const fs = require('fs');
const fm = require('front-matter');
require('dotenv').config({path:__dirname + '/.env'});

const {
  GoogleGenerativeAI,
  HarmCategory,
  HarmBlockThreshold,
} = require("@google/generative-ai");

const MODEL_NAME = "gemini-pro";
const API_KEY = process.env.GOOGLE_AI_KEY;

async function runGenerate(text) {
  const genAI = new GoogleGenerativeAI(API_KEY);
  const model = genAI.getGenerativeModel({ model: MODEL_NAME });

  const generationConfig = {
    temperature: 0.9,
    topK: 1,
    topP: 1,
    maxOutputTokens: 2048,
  };

  const safetySettings = [
    {
      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
  ];

  const parts = [
    {text: `Given the following blog post, write a one sentence summary to use as the description:\n${text}
    `},
  ];

  const result = await model.generateContent({
    contents: [{ role: "user", parts }],
    generationConfig,
    safetySettings,
  });

  return result.response.candidates[0].content.parts[0].text;
  
}

/*
I'm responsible for 'cleaning' up the text before sending to Google. For now, I'll just remove code blocks,
but in the future I may remove images too. Also remove double blank lines. Oh, also remove FM.
*/
function cleanup(str) {
	str = str.replace(/```(.*?)```/sg, '');
	str = str.replace(/---(.*?)---/sg, '');
	str = str.replace(/\n{3,}/g, '\n');
	return str.trim();
}

(async () => {
	if(process.argv.length === 2) {
		console.log('Usage: summarysuggestions.j <<path to md>>');
		process.exit(1);
	} 

	const mdPath = process.argv[2];
	if(!fs.existsSync(mdPath)) {
		console.log(`Unable to find ${mdPath}.`);
		process.exit(1);
	}

	let contents = fs.readFileSync(mdPath,'utf-8');
	let title  = fm(contents).attributes.title;

	// Make it nicer!
	contents = cleanup(contents);

	console.log(`\nGenerating summary suggestion for: ${title}`);
	console.log('------------------------------------------------------------------------');

  	let suggestion = (await runGenerate(title));
  	console.log(suggestion);
})(); And here's what it shows for a post from a few days ago, : "Using Generative AI to Improve Image Filenames" This post explores how Generative AI can be used to enhance image filenames, making them more descriptive, accurate, and consistent. I got to say, that's pretty spot on! And I'm not so worried about the 'voice' for that. I went ahead and used it for post (after I was done), and got (and used) - this: this Enhance your content creation process by utilizing generative AI as your virtual writing assistant. Watch the Movie If this interests you but you would love to see me ramble on while looking at a LEGO Death Star, you can watch the presentation below: https://www.youtube.com/watch?v=7_TfWfcjlpg&embedable=true Both of my scripts shown above are in my repo and may be found in the scripts directory here: https://github.com/cfjedimaster/raymondcamden2023/tree/main/scripts Let me know what you think in a comment below!

How to Use Generative AI as Your Content Assistant

আপনার সামগ্রী সহকারী হিসাবে জেনারেটিভ এআই কীভাবে ব্যবহার করবেন

So verwenden Sie generative KI als Ihren Inhaltsassistenten

Cómo utilizar la IA generativa como asistente de contenido

Comment utiliser l'IA générative comme assistant de contenu

अपने कंटेंट असिस्टेंट के रूप में जेनरेटिव एआई का उपयोग कैसे करें

Generative AI をコンテンツ アシスタントとして使用する方法

생성 AI를 콘텐츠 도우미로 사용하는 방법

Como usar IA generativa como seu assistente de conteúdo

Как использовать генеративный искусственный интеллект в качестве помощника по контенту

Üretken Yapay Zekayı İçerik Asistanınız Olarak Kullanma

Cách sử dụng AI sáng tạo làm trợ lý nội dung của bạn

如何使用生成式人工智能作为您的内容助手

Last night, I had an interesting thought. Many times I work with images that have vague filenames. For example, . Given that there are many APIs out there that can look at an image and provide a summary, what if we could use that to provide a better file name based on the content of the image? Here's what I was able to find. screenshot_1_24_12_23.jpg As always, I began by prototyping in . I apologize for stating this in basically every post on the topic, but I really want to stress how useful that is for development. Google AI Studio I used a very simple prompt: Write a one sentence short summary of this image. The sentence 
should be no more than five words. And then did a quick test: If it's a bit hard to read in the screenshot, the result was: A Mardi Gras king cake. Which is absolutely perfect. So, I took the code from this prompt and whipped up the following script: import fs from 'fs/promises';
import 'dotenv/config';
import slugify from '@sindresorhus/slugify';

import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from '@google/generative-ai';

const MODEL_NAME = "gemini-pro-vision";
const API_KEY = process.env.GOOGLE_AI_KEY;

const SOURCE = './source/';
const OUTPUT = './output/';


async function getImageSummary(path) {
  const genAI = new GoogleGenerativeAI(API_KEY);
  const model = genAI.getGenerativeModel({ model: MODEL_NAME });

  const generationConfig = {
    temperature: 0.4,
    topK: 32,
    topP: 1,
    maxOutputTokens: 4096,
  };

  const safetySettings = [
    {
      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
    {
      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    },
  ];

  // ToDo potentially - make mimeType actually check the image type
  const parts = [
    {text: "Write a one sentence short summary of this image. The sentence should be no more than five words.\n\n"},
    {
      inlineData: {
        mimeType: "image/jpeg",
        data: Buffer.from(await fs.readFile(path)).toString("base64")
      }
    },
    {text: "\n"},
  ];

  const result = await model.generateContent({
    contents: [{ role: "user", parts }],
    generationConfig,
    safetySettings,
  });

  // This assumes a good response. Never assume.
  return result.response.candidates[0].content.parts[0].text.trim();
}


const files = await fs.readdir(SOURCE);
for(let file of files) {
	console.log(`Processing ${file}`);
	let result = await getImageSummary(SOURCE + file);
	// again, assumes jpg
	let newname = OUTPUT + slugify(result) + '.jpg';
	console.log(`Copying to ${newname}`);
	await fs.copyFile(SOURCE + file, newname);
}

console.log('Done'); The main part is the function which is a modified version of the code AI Studio output. As you can see, I do kinda assume only, which isn't great, and I don't handle errors at all, but for a quick test, it's fine. getImageSummary .jpg After the function, I basically list the files from a source directory, get the summary, and use the excellent package to translate the sentence into a slug for use in renaming. @sindresorhus/slugify Now, one thing to keep in mind is that if you run this script multiple times, you will get multiple results with slightly different summaries. You could wipe the output directory before running perhaps. So, how well did it work? Sample Images I tested with these five images. Below each image, you can see their original filename and how they were renamed. 20240107_120237.jpg to an-nfl-game-between-the-saints-and-the-falcons.jpg 20240108_152420.jpg to cat-interrupts-work-day.jpg 20240113_193655.jpg to a-small-cake-with-yellow-frosting.jpg 20240120_170218.jpg to cat-sits-in-a-box.jpg 20240122_184642.jpg to a-mardi-gras-king-cake.jpg Honestly, these feel perfect. I will say the "cat-interrupts-work-day" one is... perhaps a bit more funny than practical. I think that would be a fair criticism, but in general, this worked well. incredibly If you want the full source code with the images as well, you can grab it here: https://github.com/cfjedimaster/ai-testingzone/tree/main/rename_images Let me know what you think in the comments below.

How to Use Generative AI to Improve Image Filenames

Testing is an essential part of that involves verifying the functionality and performance of an application to ensure it meets the intended purpose. In ASP.NET Core, effective testing can help identify and prevent potential issues before they arise in production environments. software development In this article, I’ll guide you through working with in . WebApplicationFactory ASP.NET Core The is a powerful tool that provides a simplified way to set up and execute integration and unit tests for ASP.NET Core applications. By leveraging the WebApplicationFactory, you can better automate your testing process and achieve consistent testing results. Win-win! WebApplicationFactory Throughout the article, I’ll provide examples of how to use WebApplicationFactory to create coded tests. If you’re ready to improve your testing with ASP.NET Core, let’s jump in! Overview of WebApplicationFactory WebApplicationFactory is a class in the namespace that provides a way to create a TestServer instance to host an ASP.NET Core application during testing. It is a powerful tool that simplifies and streamlines the testing process for ASP.NET Core developers. Microsoft.AspNetCore.Mvc.Testing One of the main advantages of using is that it can help test controllers that interact with the rest of the web application. creates an in-memory TestServer instance of the web application being tested, providing an environment to test HTTP requests and responses. The in-memory TestServer instance is set up and configured in the same way as a production instance of the web application. This means that is helpful for integration tests that call multiple APIs and require testing of the interaction of different parts in the web application. WebApplicationFactory WebApplicationFactory WebApplicationFactory also has advantages when writing tests isolating parts of your system. It’s possible to test a single function directly without interacting with other parts of the system, such as databases, authentication systems, etc. This makes targeted testing quicker and easier. WebApplicationFactory is simple to use and works entirely within C#. Creating a factory is straightforward. A base class is created with configurations, which is used to build the host from these configurations and finally can be instantiated. The is then used to interact with the in-memory TestServer. WebApplicationFactory WebApplicationFactory HttpClient HttpClient Writing Unit Tests with WebApplicationFactory Unit testing is key for software development, particularly in an environment where testing is continuous. These types of tests are lightweight and fast. In ASP.NET Core, unit testing is important to ensure that individual components work as expected. When it comes to ASP.NET Core testing with , writing unit tests is easy. provides a standardized way to build integration tests, making it easy to write and maintain tests. WebApplicationFactory WebApplicationFactory Setting Up Dependencies To demonstrate the process of writing unit tests with WebApplicationFactory, let’s take an example of a simple test that checks if a controller action returns the correct response. To do this, a test project should be created and the package added to the project. The upcoming code examples assume . Microsoft.AspNetCore.Mvc.Testing that xUnit is being used as the testing framework To test an HTTP endpoint with WebApplicationFactory, a simple test can be written to ensure that the response coming back from our endpoint matches a particular string. Take into account that we should think of issues like the status code, the response’s content, performance, and the feedback to the user if a failure occurs. Using HttpClient with WebApplicationFactory We’ll use an to send HTTP requests and read HTTP responses from a specific endpoint. It’s a key part of testing with since it provides a means to interact with the testing server. HttpClient WebApplicationFactory To use with , the method must be called from an instance of the factory. This method creates a new client that can be used to send HTTP requests to the in-memory TestServer instance created by . HttpClient WebApplicationFactory CreateClient() WebApplicationFactory An example of using with is provided below: HttpClient WebApplicationFactory public class TestFixture : WebApplicationFactory<Startup>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.UseEnvironment("Testing");
        base.ConfigureWebHost(builder);
    }
}

public class SampleControllerTests : IClassFixture<TestFixture>
{
    private readonly HttpClient _client;

    public SampleControllerTests(TestFixture factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task SampleController_ReturnsOkResult()
    {
        // Arrange
        var request = new HttpRequestMessage(new HttpMethod("GET"), "/api/sample");

        // Act
        var response = await _client.SendAsync(request);

        // Assert
        response.EnsureSuccessStatusCode(); // Status Code 200-299
    }
} In the example above, we use with to test a specific endpoint. Here, a class inherits from WebApplicationFactory and creates a new instance of class by specifying it with the type parameter. Then, the method is called to return an object, which we then use to send an HTTP GET request to a specific endpoint. Finally, we ensure that the status code of the response was a 2xx Success status code. HttpClient WebApplicationFactory TestFixture Startup CreateClient() HttpClient Integration Testing with WebApplicationFactory and ensure that they work together as expected. In ASP.NET Core, integration testing is particularly important since the framework provides a wide range of tools and components that need to work together seamlessly. The more moving pieces, the more important different types of coverage are! Integration testing is used to test the interactions between different parts of an application For integration tests in ASP.NET Core, the class creates an in-memory TestServer instance that simulates a production environment and allows you to send requests to the application through the HTTP.Verb methods (i.e GET, POST, DELETE, etc). The tests can be used to evaluate if APIs and database interactions are done correctly, and it allows testing the overall function of the application. WebApplicationFactory An example of writing an integration test with would be to test the interaction between multiple APIs and the database. In this example, we test if a register endpoint accepts new users and their credentials are stored correctly in the database. WebApplicationFactory public class RegisterTests : IClassFixture<WebApplicationFactory<Startup>>
{
    private readonly HttpClient _client;

    public RegisterTests(WebApplicationFactory<Startup> factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task Register_ReturnsSuccessResult()
    {
        // Arrange
        var user = new User() { Email = "[email protected]", Password = "testpassword" };
        var payload = JsonConvert.SerializeObject(user);
        var content = new StringContent(payload, Encoding.UTF8, "application/json");

        // Act
        var response = await _client.PostAsync("/api/register", content);

        // Assert
        response.EnsureSuccessStatusCode();
        var responseAsString = await response.Content.ReadAsStringAsync();
        Assert.Contains("Success", responseAsString);
    }
} In the example above, we create a new instance of the class, then call the method to get an instance of that interacts with the TestServer instance. We test the registration endpoint and verify whether the response returns a success status code. WebApplicationFactory Startup CreateClient() HttpClient Best Practices for Integration Testing with WebApplicationFactory Here are some best practices for integration testing with : WebApplicationFactory Use a clean slate for the database: Before running integration tests, make sure to delete any existing test data from the database. This ensures that tests are independent and repeatable. Use realistic data: Tests should use realistic data that simulates the real-world use of the application. Test all critical APIs: Tests should cover all critical APIs in the application, including those related to authentication and authorization. Mock external dependencies: When possible, external dependencies should be mocked to isolate the tests and minimize interference. Otherwise, you can leverage a tool like Testcontainers! Test edge cases: Edge cases should be tested to ensure that the application can handle unusual inputs and conditions. Run tests frequently: Tests should be run frequently during the development process to catch issues early and reduce the cost of fixing them. If you have CI/CD, hook these tests up! Integration testing with can be a key part of ensuring your ASP.NET Core development goes smoothly. As a C# developer, using can simplify the process while allowing for increased efficiency and improved code quality. WebApplicationFactory WebApplicationFactory Mocking Dependencies in Tests with WebApplicationFactory Mocking dependencies in testing is a technique that isolates the code being tested from external dependencies, such as databases or web APIs. This helps simplify tests and allows developers to test individual components independently. Mocking dependencies is especially important in integration testing, where tests often rely on several different components. Mocking allows developers to isolate the component being tested and verify that it works as intended. In ASP.NET Core development, provides a way to mock dependencies in tests. The class can be overridden to create a new instance of the class that can be used in the tests. WebApplicationFactory WebApplicationFactory<TStartup> HttpClient Here’s an example of how to use to mock a dependency in an ASP.NET Core application: WebApplicationFactory public class SampleServiceTests : IClassFixture<WebApplicationFactory<Startup>>
{
    private readonly HttpClient _client;

    public SampleServiceTests(WebApplicationFactory<Startup> factory)
    {
        _client = factory
            .WithWebHostBuilder(builder =>
            {
                builder.ConfigureTestServices(services =>
                {
                    services.AddTransient<ISampleDependency, MockSampleDependency>();
                });
            })
            .CreateClient();
    }

    [Fact]
    public async Task Sample_Service_Calls_Dependency()
    {
        // Arrange
        var request = new HttpRequestMessage(new HttpMethod("GET"), "/api/sample");

        // Act
        var response = await _client.SendAsync(request);

        // Assert
        response.EnsureSuccessStatusCode();
    }
} In the example above, we override an instance of an implementation with a mocked version using the method inside the class. Then, we create a new instance of that includes the mocked dependency. Finally, it is used to send the HTTP GET request to the required endpoint. ISampleDependency ConfigureTestServices WebApplicationFactory HttpClient Using the WebApplicationFactory.CreateClient Method provides a simple way to mock dependencies in tests using the method. creates a new instance of that can be used to communicate with the in-memory TestServer instance created by . We can layer in the Moq nuget package to assist us here! WebApplicationFactory CreateClient CreateClient HttpClient WebApplicationFactory Here’s an example of how to use to mock a dependency in an ASP.NET Core application: WebApplicationFactory.CreateClient public class SampleControllerTests : IClassFixture<WebApplicationFactory<Startup>>
{
    private readonly HttpClient _client;

    public SampleControllerTests(WebApplicationFactory<Startup> factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task Sample_Controller_Dependency_Mock()
    {
        // Arrange
        var mockDependency = new Mock<IDependency>();
        mockDependency.Setup(m => m.GetResult()).Returns("Mocked result");

        // Act
        var response = await _client.GetAsync("/api/sample");

        // Assert
        response.EnsureSuccessStatusCode();
        var responseContent = await response.Content.ReadAsStringAsync();
        Assert.Contains("Mocked result", responseContent);
    }
} In the example above, a new instance of is created using , and a mocked dependency is injected into the test by overriding the implementation of the interface. The test verifies that the endpoint returns the expected response with the overridden implementation. HttpClient WebApplicationFactory.CreateClient IDependency Wrapping Up WebApplicationFactory in ASP.NET Core Testing is an important part of software development (or at least you should make that the case!), especially in ASP.NET Core. Without proper testing, code can be susceptible to bugs, security issues, and unintended consequences. The in ASP.NET Core is a great tool because of its convenience, flexibility, and ease of use. WebApplicationFactory Using the for testing helps you to write effective unit tests and integration tests, including those that test HTTP endpoints. It also allows you to mock dependencies in your applications for more focused testing. I covered how to create a instance, write unit tests and integration tests using , and mock dependencies with as well! WebApplicationFactory WebApplicationFactory WebApplicationFactory Remember to consider best practices and remain pragmatic when testing ASP.NET Core applications with . Context is key and every situation will be different. WebApplicationFactory Also published here.

Using the WebApplicationFactory in ASP.NET Core for Testing

When creating systems, developers are faced with common problems that they use in many of their applications. In this article, I will touch on one of these problems and show how I solve it. Request Id Most modern systems are built on microservice architecture. This means that a company can have many services, each of which is horizontally scalable and most likely has several instances. Thus, a request from a client may pass through many parts of the application before receiving a response. As a result, developers have a natural need to track the entire chain of actions occurring with the client’s request. To do this, a single Request Id comes to their aid. Request id serves the following purposes: Quickly search for logs related to a specific user query. Especially useful when finding a bug To trace services. It is useful to know which of the system services processes requests slowly Typically, the Request Id is generated by the ingress controller of your system and then passed into all requests through headers. Let's imagine that we are creating one of the backend systems. Our task is to read the Request Id from the request header and send it in the request header to the next system; we also need to use it in the logs and send it to the tracer, in general, it should be easily accessible from any class (May the DI be with you). Let's start implementation. To start, we need a class in which we will store our Request Id. public class SessionData
{
   private string _requestId = Guid.NewGuid().ToString();

   public string RequestId
   {
       get => _requestId;

       set
       {
           if (!string.IsNullOrEmpty(value))
               _requestId = value;
       }
   }
} Here, by default, we fill in the RequestId; this is necessary if we have an application without an API, but with background jobs. That is when we are the initiators of the request. We also ensure that RequestId is never empty. Next, we need to populate this class and ensure that this instance is used throughout the entire request processing time. And here, DI will come to our aid. We will simply add it as a Score to our service collection, then we will receive a new class with every request to our service. services.AddScoped<SessionData>(); Now, we need to read the Request Id from the header. For this, we will use Middleware. public class RequestIdMiddleware
{
   private readonly RequestDelegate _next;

   public RequestIdMiddleware(RequestDelegate next)
   {
       _next = next;
   }

   public async Task InvokeAsync(HttpContext context, SessionData sessionData)
   {
       sessionData.RequestId = context.Request.Headers["X-Request-Id"];
       await _next(context);
   }
} Fine. Now, let's connect our middleware: app.UseMiddleware<RequestIdMiddleware>(); To test the work, I will write a simple controller that will return our Request Id and call a service method that will print the Request Id. [ApiController]
[Route("request_id")]
public class RequestIdController: Controller
{
   private readonly SessionData _sessionData;
   private readonly RequestIdService _requestIdService;

   public RequestIdController(
       SessionData sessionData,
       RequestIdService requestIdService)
   {
       _sessionData = sessionData;
       _requestIdService = requestIdService;
   }

   [HttpGet]
   public ActionResult<string> Get()
   {
       _requestIdService.PrintRequestId();
       return _sessionData.RequestId;
   }
} And here is our service. Don't forget to add it to the IServiceCollection: public class RequestIdService
{
   private readonly SessionData _sessionData;
   public RequestIdService(SessionData sessionData)
   {
       _sessionData = sessionData;
   }
   public void PrintRequestId()
   {
       Console.WriteLine($"RequestIdService request_id: {_sessionData.RequestId}");
   }
} When calling a service with header X-Request-Id = SomeId. Our RequestId SomeId is returned to us + the line RequestIdService request_id: SomeId is displayed in the console. Super. Now, let’s add it to the header when calling another service. To send messages, I created a helper class HttpSendHelper. public class HttpSendHelper
{
   private readonly HttpClient _httpClient;
   private readonly SessionData _sessionData;

   public HttpSendHelper(
       HttpClient httpClient,
       SessionData sessionData)
   {
       _httpClient = httpClient;
       _sessionData = sessionData;
   }

   public async Task<string> GetRequestAsync(string url, CancellationToken cancellationToken)
   {
       using var request = new HttpRequestMessage(HttpMethod.Get, url);
       request.Headers.Add("X-Request-Id", _sessionData.RequestId);

       var response = await _httpClient.SendAsync(request, cancellationToken);
       string stringResult = await response.Content.ReadAsStringAsync(cancellationToken);

       return stringResult;
   }
} Then I wrote a service that calls the method of our previously written controller. Let's not forget to add it to the IServiceCollection. public class ExternalApiService
{
   private readonly HttpSendHelper _httpSendHelper;

   public ExternalApiService(HttpSendHelper httpSendHelper)
   {
       _httpSendHelper = httpSendHelper;
   }

   public Task<string> GetRequestIdAsync(CancellationToken cancellationToken)
   {
       return _httpSendHelper.GetRequestAsync("http://localhost:5000/request_id", cancellationToken);
   }
} Let's add another method to our controller: [HttpGet("external")]
public Task<string> GetExternal(CancellationToken cancellationToken)
{
   return _externalApiService.GetRequestIdAsync(cancellationToken);
} Now, we need to run our application twice. And call a new method.

How to Work With Request Id in .NET Applications

Trivia games provide an engaging and educational experience where you can learn new facts and expand your knowledge across various subjects. Nowadays, Trivia quiz mobile and web applications are the most common go-to areas for such an activity. How about playing a trivia game on WhatsApp? In this tutorial guide, you will learn how to create a trivia quiz application using Twilio for WhatsApp, ASP.NET Core, and ( ). The aim of this tutorial is to create a trivia game application that allows users to play and answer multiple-choice questions using WhatsApp. You will leverage to store and retrieve user progress, track score and maintain game state. The Trivia API licensed under CC BY-NC 4.0 sessions in ASP.NET Core To fetch these questions, you will be using The Trivia API, a REST API, that makes it easy for developers to build quiz apps by providing multiple-choice trivia questions. To learn more about the Trivia API, please visit the__ __. Trivia API documentation Prerequisites To complete this tutorial, you will need: An OS that supports .NET (Windows/macOS/Linux) .NET 7 SDK A code editor or IDE (Recommended: , with the , or ) Visual Studio Visual Studio Code C# plugin JetBrains Rider ngrok CLI A free or paid Twilio Account (If you don't have one, you can ) try Twilio for free Experience with C# and ASP.NET Core . The source code for this tutorial can be found on GitHub Set up a new ASP.NET Core project To get started, using your shell terminal in a preferred working directory, run the following commands to create a new web API project: dotnet new webapi -n TwilioWhatsAppTriviaApp --no-openapi The second command in the snippet above will create a new web API project with the specified name and without OpenAPI (Swagger) support. If you want to use Swagger in the project, just omit in the command above. --no-openapi Change into the project directory by running this command: cd TwilioWhatsAppTriviaApp Install the NuGet package: Twilio Helper library for ASP.NET Core dotnet add package Twilio.AspNet.Core This library simplifies working with Twilio webhooks and APIs in an ASP.NET Core application. Open the project using your preferred IDE. In the folder, remove the boilerplate template controller file, , and also remove the in the project directory. Controllers WeatherForecastController.cs WeatherForcast.cs Build and run your project to ensure everything you have done so far works well using the following commands: dotnet build
dotnet run After successfully running the project, take note of any of the localhost URLs that appear in the debugging console. You can use any of these URLs to set up a publicly accessible local web server using ngrok. Implement Sessions Sessions are one of the several ways of storing a user’s data in an ASP.NET Core application. This is essential when you want to retain user data between requests because by default, the HTTP protocol is stateless - that means data is not preserved. Add the in-memory session provider by modifying , as shown in the following code: Program.cs var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromSeconds(40);
    options.Cookie.IsEssential = true;
});

var app = builder.Build();

app.UseSession();

app.MapControllers();

app.Run(); registers the distributed memory cache service. This service provides an in-memory cache that can be used to store and retrieve data across multiple requests or sessions. AddDistributedMemoryCache() registers the session services, enabling the application to maintain session state. The parameter allows you to configure various session-related options. is used to set the duration of inactivity after which a session will be considered idle. In this case, it is set to 40 seconds. ensures that the session’s state remains functional and even in scenarios where cookie rejection is enabled. AddSession() options IdleTimeout Cookie.IsEssential Session support is enabled by adding the middleware to the application pipeline, that is, your application gains access to a session object that can be used to store and retrieve data. UseSession Create the Models Create a new folder, in your project directory. Add two model class files, and with properties as shown in the following code samples: Models TriviaApiResponse.cs Question.cs using Newtonsoft.Json;

namespace TwilioWhatsAppTriviaApp.Models;

public class TriviaApiResponse
{
    [JsonProperty("category")]
    public string Category { get; set; }

    [JsonProperty("correctAnswer")]
    public string CorrectAnswer { get; set; }

    [JsonProperty("incorrectAnswers")]
    public List<string> IncorrectAnswers { get; set; }

    [JsonProperty("question")]
    public string Question { get; set; }

    [JsonProperty("type")]
    public string? Type { get; set; }

    [JsonProperty("difficulty")]
    public string Difficulty { get; set; }
} namespace TwilioWhatsAppTriviaApp.Models;

public class Question
{
    public string QuestionText { get; set; }
    public List<(string option, bool isCorrect)> Options { get; set; }
} The model includes properties that represent the fields of The Trivia API response. The attribute ensures that each property is correctly populated with the corresponding JSON data. TriviaApiResponse JsonProperty For a streamlined way to handle trivia questions, the class comes to the rescue. This class encapsulates the necessary information for a trivia question, including the question text and a list of options. Each option is represented by a tuple containing the option text and a boolean value indicating whether it is the correct option. Question Add the Trivia Service Class Create a folder in your project directory and add a new class file named . Modify its contents, as shown in the following code: Services TriviaService.cs using Newtonsoft.Json;
using TwilioWhatsAppTriviaApp.Models;

namespace TwilioWhatsAppTriviaApp.Services;

public class TriviaService
{
    private const string TheTriviaApiUrl = @"https://the-trivia-api.com/api/questions?limit=3";
    private HttpClient httpClient;

    public TriviaService(HttpClient httpClient)
    {
        this.httpClient = httpClient;
    }

    public async Task<IEnumerable<TriviaApiResponse>> GetTrivia()
    {
        var response = await httpClient.GetAsync(TheTriviaApiUrl);
        var triviaJson = await response.Content.ReadAsStringAsync();
        var trivia = JsonConvert.DeserializeObject<IEnumerable<TriviaApiResponse>>(triviaJson);

        return trivia;
    }

    public List<Question> ConvertTriviaToQuestions(IEnumerable<TriviaApiResponse> questions)
    {
        List<Question> newQuestions = new();

        foreach (var question in questions)
        {
            var options = new List<(string option, bool isCorrect)>()
            {
                (question.CorrectAnswer, true),
                (question.IncorrectAnswers[0], false),
                (question.IncorrectAnswers[1], false),
                (question.IncorrectAnswers[2], false)
            };

            // Shuffle the options randomly
            Random random = new();
            options = options.OrderBy(_ => random.Next()).ToList();

            newQuestions.Add(new Question { QuestionText = question.Question, Options = options });
        }

        return newQuestions;
    }
} The class contains two methods: and . The method sends the HTTP GET request to The Trivia API with a query parameter, , that specifies that only 3 questions should be returned. Without the limit parameter, the API returns 10 questions by default. TriviaService GetTrivia ConvertTriviaToQuestions GetTrivia limit=3 The method converts the response from the API into an organized manner. The method also shuffles all question options randomly, so that a single option won’t be the answer to all questions. ConvertTriviaToQuestions To register and the HTTP client in your application's Dependency Injection (DI) container, modify as shown in the following code: TriviaService Program.cs using TwilioWhatsAppTriviaApp.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromSeconds(40);
    options.Cookie.IsEssential = true;
});
builder.Services.AddHttpClient();
builder.Services.AddScoped<TriviaService>();

var app = builder.Build();

app.UseSession();

app.MapControllers();

app.Run(); Create the Trivia Controller Add an empty API controller class in a file named to the folder and modify its content as shown in the following code: TriviaController.cs Controllers using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Twilio.AspNet.Core;
using Twilio.TwiML;
using Twilio.TwiML.Messaging;
using TwilioWhatsAppTriviaApp.Models;
using TwilioWhatsAppTriviaApp.Services;

namespace WhatsappTrivia.Controllers;

[Route("[controller]")]
[ApiController]
public class TriviaController : TwilioController
{
    private const string SessionKeyIsGameOn = "IsGameOn";
    private const string SessionKeyScore = "Score";
    private const string SessionKeyCurrentQuestionIndex = "CurrentQuestionIndex";
    private const string SessionKeyTotalQuestions = "TotalQuestions";
    private const string SessionKeyQuestions = "Questions";

    private static readonly string[] StartCommands = { "START", "S" };
    private static readonly string[] OptionValues = { "A", "B", "C", "D" };

    private readonly TriviaService triviaService;

    public TriviaController(TriviaService triviaService)
    {
        this.triviaService = triviaService;
    }

    [HttpPost]
    public async Task<IActionResult> Index()
    {
        var response = new MessagingResponse();
        var form = await Request.ReadFormAsync();
        var body = form["Body"].ToString().ToUpper().Trim();

        await HttpContext.Session.LoadAsync();
        var isGameOn = Convert.ToBoolean(HttpContext.Session.GetString(SessionKeyIsGameOn));
        int currentQuestionIndex = HttpContext.Session.GetInt32(SessionKeyCurrentQuestionIndex) ?? 0;
        int totalQuestions = HttpContext.Session.GetInt32(SessionKeyTotalQuestions) ?? 0;

        if (StartCommands.Contains(body) && !isGameOn)
        {
            await StartGame();
            HttpContext.Session.SetString(SessionKeyIsGameOn, "true");
            response.Message(PresentQuestionWithOptions(currentQuestionIndex));
            return TwiML(response);
        }

        if (OptionValues.Contains(body) && isGameOn)
        {
            var result = ProcessUserAnswer(body, currentQuestionIndex);
            response.Message(result);

            currentQuestionIndex++;

            if (currentQuestionIndex <= totalQuestions - 1)
            {
                HttpContext.Session.SetInt32(SessionKeyCurrentQuestionIndex, currentQuestionIndex);
                response.Append(new Message(PresentQuestionWithOptions(currentQuestionIndex)));
            }
            else
            {
                response.Append(new Message(EndTrivia()));
            }

            return TwiML(response);
        }

        response.Message(!isGameOn ? "*Hello! Send 'Start' or 'S' to play game*" : "*Invalid Input! Send a correct option 'A', 'B', 'C' or 'D'*");

        return TwiML(response);
    }

    private async Task StartGame()
    {
        if (HttpContext.Session.GetString(SessionKeyQuestions) != null)
        {
            HttpContext.Session.Remove(SessionKeyQuestions);
        }

        var trivia = await this.triviaService.GetTrivia();
        var questions = this.triviaService.ConvertTriviaToQuestions(trivia);

        AddNewQuestionsToSession(questions);
        HttpContext.Session.SetInt32(SessionKeyTotalQuestions, questions.Count);
    }

    private string ProcessUserAnswer(string userAnswer, int questionIndex)
    {
        bool optionIsCorrect = false;
        int score = HttpContext.Session.GetInt32(SessionKeyScore) ?? 0;
        var question = RetrieveQuestionFromSession(questionIndex);

        switch (userAnswer)
        {
            case "A":
                optionIsCorrect = question.Options[0].isCorrect;
                break;
            case "B":
                optionIsCorrect = question.Options[1].isCorrect;
                break;
            case "C":
                optionIsCorrect = question.Options[2].isCorrect;
                break;
            case "D":
                optionIsCorrect = question.Options[3].isCorrect;
                break;
        }

        if (optionIsCorrect)
        {
            score++;
            HttpContext.Session.SetInt32(SessionKeyScore, score);
        }

        return optionIsCorrect 
            ? "_Correct ✅_" 
            : $"_Incorrect ❌ Correct answer is {question.Options.Find(o => o.isCorrect).option.TrimEnd()}_";
    }

    private string PresentQuestionWithOptions(int questionIndex)
    {
        var question = RetrieveQuestionFromSession(questionIndex);
        return $"""
                {questionIndex + 1}. {question.QuestionText}
                {OptionValues[0]}. {question.Options[0].option}
                {OptionValues[1]}. {question.Options[1].option}
                {OptionValues[2]}. {question.Options[2].option}
                {OptionValues[3]}. {question.Options[3].option}
                """;
    }

    private void AddNewQuestionsToSession(List<Question> questions) =>
        HttpContext.Session.SetString(SessionKeyQuestions, JsonConvert.SerializeObject(questions));

    private Question RetrieveQuestionFromSession(int questionIndex)
    {
        var questionsFromSession = HttpContext.Session.GetString(SessionKeyQuestions);
        return JsonConvert.DeserializeObject<List<Question>>(questionsFromSession)[questionIndex];
    }

    private string EndTrivia()
    {
        var score = HttpContext.Session.GetInt32(SessionKeyScore) ?? 0;
        var totalQuestions = HttpContext.Session.GetInt32(SessionKeyTotalQuestions) ?? 0;

        var userResult = $"""
                Thanks for playing! 😊
                You answered {score} out of {totalQuestions} questions correctly.
                
                To play again, send 'Start' or 'S'
                """;

        HttpContext.Session.Clear();
        return userResult;
    }
} This controller class is responsible for handling incoming messages, managing session state, and generating responses. It inherits from the class provided by the Twilio.AspNet.Core library, which gives you access to the method. You can use this method to respond with . The class uses methods to interact with the session. The valid inputs are elements in the and read-only arrays. The body of the incoming message is compared with these elements to ensure that the user sent a proper input, if not, a message will be sent to the user prompting them to make the right input based on the game's current state. Other fields with the “SessionKey” prefix are used to define private constant strings for session keys in the program. TwilioController TwiML TwiML, which is the Twilio Markup Language TriviaController HttpContext.Session StartCommands OptionValues The method is the main action method that handles incoming HTTP POST requests from WhatsApp via the route. It loads the session data using and retrieves data regarding the game state from the session using the and methods. Index /Trivia HttpContext.Session.LoadAsync() HttpContext.Session.GetString() HttpContext.Session.GetInt32() The use of underscores (_) and asterisks (*) at the beginning and end of certain strings is to achieve italic and bold text formatting respectively in rendered WhatsApp messages. Each helper method in the performs a specific task that supports the main functionality of the class. TriviaController method initializes the game by retrieving trivia questions, converting them into a format suitable for the game, and storing them in the session. StartGame method processes the user's answer to a question and determines if it is correct or not. ProcessUserAnswer method is responsible for formatting and presenting a question along with its options. PresentQuestionWithOptions method stores a list of questions in the session. It converts the questions to JSON format and saves the JSON string in the session. AddNewQuestionsToSession method retrieves a question from the session using the question index. RetrieveQuestionFromSession method generates a message to end the trivia game. This method also removes session data related to the game. Based on the configuration of session service in , this happens automatically when the session is idle for 40 seconds. EndTrivia Program.cs Test the Application To test the application, you need to set up Twilio Sandbox for WhatsApp, make your application endpoint publicly accessible and add the endpoint URL in the Sandbox configuration as a webhook. Setup Twilio Sandbox for WhatsApp Go to the , navigate to . Twilio Console Message > Try it out > Send a WhatsApp Message Follow the instructions on the page to connect to the sandbox, by sending a WhatsApp message from your device to the Twilio number provided in order to create a successful connection with the WhatsApp sandbox. Similarly, other individuals who wish to test your app with their respective numbers will need to follow the same procedure. Expose your webhook using ngrok for testing Now, open a shell terminal and run the following command to start ngrok and expose your local ASP.NET Core app by replacing with the full URL of your localhost you copied initially: <localhost-url> ngrok http <localhost-url> ngrok will generate a public URL that forwards requests to your local ASP.NET app. Look for the forwarding URL labelled in the ngrok terminal window and copy it. Forwarding Go back to the Twilio Try WhatsApp page, click on , and change the endpoint url with the URL generated by ngrok plus the route and ensure the method is set to POST. Then click Save to save the new sandbox configuration. Sandbox Settings When a message comes in forwarding /Trivia Project Demo Run your ASP.NET Core project using the following command: dotnet run Now, test your application by sending a message in the initial conversation with the Twilio Sandbox number. Conclusion By leveraging the power of the Twilio platform and WhatsApp, you have created an immersive trivia game experience for users to enjoy. You have also learned how to save and retrieve data from sessions. There are several ways this project can be improved upon. You can further improve this project by adding timer, handling exceptions, allowing users to choose difficulty and applying the chosen difficulty as a query parameter via The Trivia API URL (e.g ). Additionally, you can explore the possibility of creating a solution that allows users to fill out surveys via WhatsApp. https://the-trivia-api.com/api/questions?difficulty=hard

Build a Trivia Quiz WhatsApp Bot With Twilio and ASP.NET Core

Twilio এবং ASP.NET কোর দিয়ে একটি ট্রিভিয়া কুইজ WhatsApp বট তৈরি করুন

Erstellen Sie mit Twilio und ASP.NET Core einen Quiz-WhatsApp-Bot

Cree un bot de WhatsApp de prueba de trivia con Twilio y ASP.NET Core

Créez un bot WhatsApp Trivia Quiz avec Twilio et ASP.NET Core

ट्विलियो और ASP.NET कोर के साथ एक ट्रिविया क्विज़ व्हाट्सएप बॉट बनाएं

Twilio と ASP.NET Core を使用してトリビア クイズ WhatsApp ボットを構築する

Twilio 및 ASP.NET Core를 사용하여 상식 퀴즈 WhatsApp Bot 구축

Crie um bot de perguntas e respostas para WhatsApp com Twilio e ASP.NET Core

Создайте бота WhatsApp для викторины с помощью Twilio и ASP.NET Core

Twilio ve ASP.NET Core ile Trivia Quiz WhatsApp Botu Oluşturun

Xây dựng Bot WhatsApp Quiz Trivia với Twilio và ASP.NET Core

使用 Twilio 和 ASP.NET Core 构建问答测验 WhatsApp 机器人

We’re going to explore how to create an end-to-end dynamic Web API project using Dapper for data access. Dapper is a lightweight Object-Relational Mapping (ORM) library that simplifies database access by allowing us to write dynamic queries and map the results to .NET objects. Our goal is to build a simple Web API that performs CRUD (Create, Read, Update, Delete) operations on a "Tasks" table in a SQL Server Compact Edition database. C# SQL Prerequisites Before we begin, make sure you have the following: Visual Studio (or any C# development environment) installed. SQL Server Compact Edition (SQL CE) installed. Setting Up the Project Let's start by setting up the project and installing the required NuGet packages. Follow these steps: Create a new C# Console Application project in Visual Studio. Install the following NuGet packages: Dapper: Install-Package Dapper Newtonsoft.Json: Install-Package Newtonsoft.Json Microsoft.AspNet.WebApi.Core: Install-Package Microsoft.AspNet.WebApi.Core Building the Web API Step 1: Create the Class TasksController In the project, create a new C# class named that inherits from . This class will handle HTTP requests for tasks. TasksController ApiController using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlServerCe;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Dapper;
using Newtonsoft.Json.Linq;

public class TasksController : ApiController
{
    // Database connection string
    static string _connString = ConfigurationManager.ConnectionStrings["Database1"].ConnectionString;

    // Web API methods for CRUD operations
    // ...
} Step 2: Implement the GET Methods Let's implement the and methods to retrieve tasks from the database. GetAll Get public async Task<IEnumerable<dynamic>> GetAll()
{
    using (var connection = new SqlCeConnection(_connString))
    {
        await connection.OpenAsync();

        IEnumerable<dynamic> tasks = await connection.QueryAsync<dynamic>("select Id as id, Title as title, Description as description, CreatedDate as createdDate from Tasks;");
        return tasks;
    }
}

public async Task<dynamic> Get(int id)
{
    using (var connection = new SqlCeConnection(_connString))
    {
        await connection.OpenAsync();

        IEnumerable<dynamic> tasks = await connection.QueryAsync<dynamic>("select Id as id, Title as title, Description as description, CreatedDate as createdDate from Tasks where Id = @id;", new { id = id });
        if (!tasks.Any())
            throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Task not found"));
        
        return tasks.First();
    }
} Step 3: Implement the POST Method Next, let's create the method to add a new task to the database. Post public async Task<HttpResponseMessage> Post(JObject value)
{
    dynamic data = value;
    IEnumerable<int> result;
    using (var connection = new SqlCeConnection(_connString))
    {
        await connection.OpenAsync();

        connection.Execute(
            "insert into Tasks (Title, Description, CreatedDate) values (@title, @description, @createdDate);",
            new
            {
                title = (string)data.title,
                description = (string)data.description,
                createdDate = DateTime.Parse((string)data.createdDate)
            }
        );

        result = await connection.QueryAsync<int>("select max(Id) as id from Tasks;");
    }

    int id = result.First();
    data.id = id;
    var response = Request.CreateResponse(HttpStatusCode.Created, (JObject)data);
    response.Headers.Location = new Uri(Url.Link("DefaultApi", new { controller = "Tasks", id = id }));
    return response;
} Step 4: Register Routes in WebApiConfig In the class, register the Web API routes: WebApiConfig public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
    }
} Executing the Web API Now that we have built the Web API, it's time to execute it and perform some API calls. We will use the HttpClient class to simulate HTTP requests. Step 1: Create the Class Program In the class, we will execute the Web API using HttpClient: Program using System;
using System.Configuration;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using Dapper;
using Newtonsoft.Json.Linq;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Nito.AsyncEx.AsyncContext.Run(() => MainAsync(args));
        }

        static async Task MainAsync(string[] args)
        {
            // ... HttpClient code goes here ...
        }
    }

    // ... WebApiConfig and TasksController classes go here ...
} Step 2: Performing HTTP Requests Now, let's perform some HTTP requests to test our API: static async Task MainAsync(string[] args)
{
    var config = new HttpConfiguration();
    WebApiConfig.Register(config);
    using (var server = new HttpServer(config))
    using (var client = new HttpClient(server))
    {
        // Set the base address for the HttpClient
        client.BaseAddress = new Uri("http://localhost/");

        // Create a CancellationTokenSource
        var cts = new CancellationTokenSource();

        // Sample JSON data for the POST request
        var json = @"{""title"":""Task"",""description"":""The task"",""createdDate"":""" + DateTime.UtcNow.ToString() + "\"}";

        // Create a POST request to add a new task
        var postRequest = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
        {
            Content = new StringContent(json, Encoding.UTF8, "application/json")
        };

        // Send the POST request
        var postResponse = await client.SendAsync(postRequest, cts.Token);
        Trace.Assert(postResponse.StatusCode == HttpStatusCode.Created);

        // Get the location of the newly created task
        var location = postResponse.Headers.Location.AbsoluteUri;

        // Create a GET request to retrieve the task
        var getResponse = await client.GetAsync(location);
        Trace.Assert(getResponse.StatusCode == HttpStatusCode.OK);

        // Deserialize the response body into a JObject
        var getBody = await getResponse.Content.ReadAsAsync<JObject>();
        dynamic data = getBody;
        Trace.Assert((string)data.title == "Task");
    }

    Console.WriteLine("Press any key to quit.");
    Console.ReadLine();
} Conclusion In this tutorial, we have built an end-to-end dynamic C# Web API project using Dapper for data access. We implemented CRUD operations to manage tasks in a SQL Server Compact Edition database. Dapper provided a straightforward way to interact with the database and map the results to dynamic objects. You can use this project as a foundation for creating more complex Web APIs with additional features. Remember to handle error cases and add security measures as per your application's requirements. I hope this article was helpful in understanding how to create a dynamic Web API using Dapper and C#.

Building an End-to-End Dynamic C# Web API with Dapper for Data Access

289 Stories To Learn About Typescript

Let's learn about via these 98 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Nextjs /Learn Repo 1. Top 15 React Interview Questions & Answers You Need To Know in 2022 In this article, we'll go over some of the most common React interview questions and how to answer them. 2. How We Built This: A Platform for Crowdsourced Design Patterns Built with Next, Apollo and MongoDB and deployed with GitHub Actions and Docker. 3. 7 Easy Steps to Set Up Google Analytics on Your Next.JS Website A guide to help you set up Google Analytics 4 on your Next.js website. 4. The 7 Best React Component Libraries for 2022 In this article, I will be sharing with you 7 awesome React UI libraries that you should check out. 5. Next.js and File Downloads: Three Ways to Restrict Access to a File Let's see exactly how we can protect files in next.js and allow certain users only to download them. Click to read the article... 6. Nextjs User Login Authentication in 5 Simple Steps Using Auth0 In this post we are going to discuss, how you can set up a user Login authentication using Auth0 in Next.js projects. 7. Creating a Todo App with NextJs & Firebase Hey devs, welcome to this tutorial; we will build a real-time Todo App with React, NextJs + Firebase. 8. Why I Switched To Tailwind For Writing CSS TailwindCSS is a highly customizable, low-level CSS framework. Here are my reasons why I decided to switch from normal CSS to Tailwind CSS for my work. 9. Why It's Your Destiny To Become A Full-Stack JavaScript Developer I've never met a true, passionate web developer who isn't a multi-dimensional specialist interested in a wide variety of topics related to their job. 10. How To Use Debounce in Next.js Understanding Debounce in Next.js 11. TemplatesKart: Is this the Best Chakra UI Component Library? Responsive chakra ui components, templates and projects. Production-ready hand crafted chakra Components and templates. Deliver your projects faster. 12. Hiding Your API Credentials Client Side Using a Proxy Server in React When you're writing client-side code to make API requests, you might need a Proxy Server to hide your API Credentials. Let's see how to do this for React apps. 13. 50+ GitHub Repositories Every Front-End Developer Needs 50+ Github Repositories Every Front-end Developer Needs 14. Building a Visual Serverless NodeJS API with MongoDB and Lolo Create a visual Serverless CRUD API with all MongoDB CRUD operations in a few minutes by stealing my work. Keep it maintainable by using several nodes. 15. Implement a Dynamic Breadcrumb in React/NextJS 16. Secure Your Next.js Apps with Jscrambler In this article, we’ll look at how you can integrate Jscrambler into your Next.js app development workflow. 17. Qwik vs Next.js: Speed Comparison A benchmark comparison and analysis between Qwik and Next.js 13. 18. How to Use mdx-bundler with Next.js A short post on how to get started with mdx-bundler in Next.js 19. Using Next.js + Playwright + GitHub Actions to Make a To-Do App A comprehensive Todo app with APIs and E2E tests with GitHub Actions enabled. 20. Alternatives to Create React App I see a lot of discussion around CRA being outdated and we should replace it with Vite. This blog discusses CRA's problems and alternatives we can use. 21. Ethereum ️❤️ JavaScript: Cheatsheet Bunch of code snippets solving most common problems every Web3 developer needs. 22. The Evolution of Our Tech Stack: Lessons, Optimizations, And Outlooks How to build a tech stack if you run an early-stage startup. 23. How to Use Zero Knowledge Dapp Boilerplate Learn how to build zero knowledge dapps, using zero knowledge proofs boilerplate. Build age verification dapp using zero knowledge proofs. 24. How to Create a Simple Object Detector with NextJs A simple tutorial for beginners to create an object detector with NextJs. 25. Using ChatGPT as an Educational Chatbot in a Next.js Frontend: A Guide Let’s try our hand at building just such a frontend integration — a chat helper that can use OpenAI to answer a potential student’s questions... 26. Build Faster Next.js Static Sites Using MDX And Contentlayer Publishing static content becomes so effortless with Next.js, MDX, and Contentlayer. This article will show you how easy it is to implement that system. 27. An Intro to Middleware in NextJS 12 NextJS 12 was announced yesterday at the NextJS Conf and they announced a new feature called middleware which allows one to modify the response to a request. 28. What is Next.JS and How to Debug it Next.JS allows the developers to create Server-side, Client-side or Static websites. Unlike the other frameworks, the rendering in Next JS is per page. That means, the "about" page can be static, while the "home" page can be server-side. 29. The New Next.js and SWR Clients: What You Need to Know So that's it, we are now using SWR as our default data fetching library, giving you all the benefits, like optimistic updates while consuming WunderGraph APIs. 30. Level Up Your Front-End Game with These 8 Side-Project Ideas 🥇 Over the span of a year, I created 8 web app and game clones. I decided to share them, so the community can get some inspiration to build as well. 31. Why localStorage Still Crashes Your Website in 2023 How to deal with the Browser SecurityError: The operation is insecure or localStorage is not defined. 32. Create React App is Dead! Here are Some Alternatives CRA may be "dead", but there are many alternative tools available for building React applications that offer superior performance and faster development times. 33. 5 Reasons to Convert from React to Next.js React itself is a great solution already. But why are there many guides on "How to convert React to Next.js"? Let's find out why and when Next.js is better. 34. Next.js Internationalization (i18n) Tutorial How to set up a multi-language Next.js project with built-in support for internationalized routing and react-intl library. 35. Choosing Between React, Gatsby, Next.js For Your Frontend React, Gatsby, Next.js. Which of the three should you choose for your frontend web development and what should you understand before you make the decision? 36. Build a Production Ready Restaurant Website with Next.js 12 and Cosmic How you can use Next.js and Cosmic to create special web pages such as restaurant websites that include restaurant menus that have many images and animations. 37. April Infrastructure Shift Brings May Time On Story Page Lift Hacker Noon Product Update: Overview of What We Deployed in April 2020 38. How I Built an Online Radio with Soundcloud and NextJS 39. Supercharge Your SEO Game: Powered By getStaticProps This is mainly useful for websites that use React/NextJS with a CMS (Content Management System) integration. No matter, whether it's WordPress, Contentful, Prismic or any other CMS. This concept is highly relevant for companies that require non-engineers to update the content easily. Whether, it's a change in the content, A/B testing or conversion-rate-optimization related. There are many reasons why the content of a website gets updated quite often throughout the year. 40. Using Next.js to Effectively Format a Page and Structure Its SEO Organizing your Next.js application and using its components. 41. Building a Better Experience for Courseware Management Courseware as Code is a revolutionary approach to streamlining the production of courseware. 42. Casing Can Break Netlify Functions: Here's How It may not be apparent when you're working on it locally, but quirks such as this one on Netlify can throw a wrench into your application deployed in prod. 43. Implementing i18n in Next.js: A Guide to Non-Route-Based Localization Next.js: A Guide to Non-Route-Based Localization 44. Docker Image Optimization - Lean Docker Images for Next.JS Using multi-stage builds to optimize production Docker image for faster deployment. 45. Using Webiny Headless CMS With Starter Kits for Gatsby, NextJS You can spin up a Webiny instance on your own cloud infrastructure in minutes, and use one of our 1-click starters to get build a frontend quickly. 46. Why Learn Any Other Programming Language When You Can Learn Typescript? Use TypeScript in all your projects and all use cases without any limitation. You can now do frontend, backend, infrastructure and machine learning in one progr 47. Real Feedback On My Portfolio That May Help You Improve Yours Some months ago I posted an article about how I built my first personal portfolio. The feedback was pretty awesome and I got some great ideas. 48. Save time by Generating Sitemaps Dynamically in NextJS generate sitemap for next.js under 1 minute 49. Sending an Invoice and Adding a Payment Reminder in Next.js with Courier API How to send invoices and add a payment reminder in Next.js with Courier API. Utilizes React and JavaScript to build services in Node.JS. 50. An Overview of our PH Launch for AskMakers v2.0 Oh…I am so sleepy…because I launched AskMakers 2.0 on Product Hunt and I have been monitoring it almost without sleeping😪 51. An Overview of Next.js Router These tips and tricks for you on the Next.js router help you make your DX better and code cleaner 52. Using Next.js 13’s Bleeding-Edge Features for Data Fetching The app directory, Streaming, Suspense, and hybrid Server and Client Components were demystified — with a little help from GraphQL + WunderGraph. 53. Isomorphic TypeScript APIs are a Gamechanger, Blurring the Line Between Client & Server Full-Stack development just reached a whole new level of productivity. Isomorphic TypeScript APIs, as I call them, blur the lines between client and server. 54. 5 reasons to consider Next.js for your next projects Next.js is a framework built on React that gives frontend developers the flexibility of creating modern and scalable apps 55. What Makes Next.js so Good? 56. These Full-stack Projects Are a Must for Your 2020 Portfolio 🤯 Procrastination, we've all dealed with it. But today because of this blog post you will find five full-stack projects you can add to your portfolio before the end of 2020! 57. Next.js vs React: Who Wins the Battle? There are two popular options for creating web applications with React: Next.js and React Router. Both have their pros and cons, but which one. 58. Setting Up Google Analytics 4 in a Next.js Project Google Analytics is a web analytics service that tracks and reports several types of website traffic. 59. What Does "Serverless" Mean? In the simplest terms, a serverless system is a way to build an application without having to manage the infrastructure. It reduces administration & maintenance 60. Gatsby.js vs. Next.js: The Best React Framework and Its Use Cases Gatsby.js vs. Next.js: Gatsby.js is better for static websites, while Next.js is better for dynamic or hybrid multi-user websites. 61. Making A Browser Console Log Wait Until Page Reloads [A How-To Guide] Ever wanted to create a browser console log that persists after a page reloads? Sure, that isn’t a problem if you enable the “preserve log” option in your developer console, but hear me out. 62. How to Build a Github User Finder App With Next.js & Tailwind CSS In this project, we are going to build GitHub user Search App using Github API. We will design the UI of the app using Tailwind CSS with Next.js as a framework. 63. Taking Advantage of React to Improve User Experience In this article, we'll discuss some tips on how to create a great user experience with React. 64. A Guide to Composing and Integrating APIs Together With React/Next.js, the fundamental problem you’re solving is that of turning some notion of ‘state’ into DOM, with a focus on composability 65. How to Upload Source Maps to Sentry with Next.js Troubleshooting with source maps uploading to Sentry with Next.js 66. How I Built a Warehouse Management App Called Cardus A web app that allows users to create and manage their warehouse of items. 67. Building a GraphQL eCommerce App from Scratch How to Build a GraphQL eCommerce App from Scratch 68. The 9 Mistakes JavaScript Developers Make the Most In this article, we'll take a look at some of the most common JavaScript mistakes and how to avoid them. 69. Why You Must Use Next.js to Get the Benefits of React 70. Embed an In-browser Code Preview into Your React Application with Sandpack Sandpack is a react library that helps you to add a live, in-browser coding environment to your react application easily. 71. Create a Gradient Border With TailwindCSS and React This blog post is a small tutorial in which I show you how you can create a gradient border blog card using Tailwind CSS. 72. VS Code Tutorial: How To Set Up A React.js Project With Next.js Express.js framework provides inbuild APIs which are very useful to build fast and scalable applications efficiently with React.js. 73. Next.JS vs. React: What Should You Use? React is a tool for building a front end. Next.js serves the same purpose. However, both instruments offer a slightly different set of features. 74. TwNFT - Mint your tweets as NFTs easily and for free In this post, I introduce TwNFT, an application that lets you mint your tweets as NFTs easily and for free and explain how it works and how I made it. 75. An Essential Guide to Feature Toggles Using Next.JS and React This post will show you how to build the Feature Toggle mechanism in your Next.JS application. We are going to use Next.JS, React, and TypeScript 76. Hacker Noon Product Update Q1 2020 Welcome to code, where the metrics are made up and the points don’t matter. I’m not #1. I just commit more often. 😛 77. Why I Ditched Wordpress to Save My Music Release and What I Did After I’m a Chapman Stick player turned web developer. I’ve had a Wordpress site for my Electronic Prog-Rock music project since 2014, much before I started my career as a web developer in 2017. Since becoming a developer, I’ve wanted to rebuild the website but, a combination of time, lack of design chops, and a bit of ignorance of how to migrate all the plugin tools Wordpress provides delayed my project. 78. How I Built a Vendor Stall for Small Businesses to Sell Goods Online in Three Weekends You can build an enterprise-grade app with low-level knowledge thanks to the myriad of robust services covering every aspect of a web product’s needs. In this article, I explore how I built an app over a couple of weekends in lockdown with not a lot of work. 79. Connecting React 17, TypeScript, Tailwind CSS, NextJS Into Developers Friendly Application NextJS is becoming a de facto framework for modern web development. In this article we will build a starter repo that you can use for every new project. 80. Understanding the Complexities of Next.js v13 Next.js v13 was released by Vercel at the Next.js conference in October 2022, bringing many new features and improvements. 81. Next vs Gatsby: Comparing Their Approach to Handling Data Next.js and Gatsby are modern front-end frameworks based on React. 82. How We Built the Story Licensing App using Next.js, Algolia and Cosmic JS We recently built the Story Licensing application using some of the most powerful development tools available. By offloading the non-core development functionality onto available API services, we were able to build this application faster than I ever could have imagined. I’m excited to share with you how we did it. 83. Dev without Ops - Why we are building The Vercel for Backend It was a great feeling to see my first website live on the internet. 84. A Step-by-Step Guide to Authenticating Users in Your DApp with 'Sign in with Ethereum' Connecting Your Decentralized Application (Dapp) with a Backend: A Step-by-Step Guide. 85. How to Set Up Authentication With AWS Amplify in Next Authentication is a way for applications to confirm user identity before granting permission or entry to a website. 86. Predicting The State of Front End Development: 2021 Edition Where is front-end development heading in 2021? Jay Freestone examines trends and technologies that will shape web development this year. 87. Tutorial For Supabase And Next.js Fans On How To Build A Slack Clone Creating a Slack clone with Supabase and Next.js 88. Next.js Vs. Gatsby: What Is The Best Choice In 2021 Next.js and Gatsby - what their strengths and weaknesses are and which one is the better choice 89. Automatic Image Optimization: Next.js 10 New Standards for 2020 Vercel has recently announced the latest version of its React-based web framework- Next.js 10. 90. Authentication in Web Apps: Connecting Auth0, ASP.NET Core and Nuxt.js User authentication and authorization can be difficult and time consuming. Getting it wrong can also have disastrous consequences, such as malicious users accessing and stealing personal or sensitive information from your app. 91. How To Create A User Portal On Airtable With Sync Inc And React In this tutorial, you’ll see how to build a scalable, secure, and flexible client portal on Airtable using Sync Inc, Cotter, and Next.js. 92. An Essential Guide to Rendering your Website Back in the day, rendering a website was simple. You needed a web server that served HTML files. Those were static sites. Then developers started using databases and authentication. To achieve that, they needed to manipulate the HTML file before serving it. 93. The Exciting Journey Of Creating My First Portfolio📂🎉 For the last few months, I've been working on a personal portfolio. I've always believed that a separate portfolio is important for any dev since it connects you to future opportunities and it helps you to grow your network. 94. How To Score A Perfect 100 Google Lighthouse Score in Chrome Dev Tools This is How I Built My Portfolio Site and personal blog using React and NextJS, and how it achieved a Perfect Lighthouse Score. I rundown all the fudamental iss 95. Fetch the Right Data With Next.js and  React SSR A frontend developer should be able to define what data is needed for a given page 96. Next.js: Firebase Authentication and Middleware for API Routes Recently I made a small web app that requires user accounts. I learned quite a bit about setting up authentication with Firebase on the client-side and using it on the server-side to protected API routes with a middleware pattern similar to Express.js. This post is a recap of what I learned based on this project for future reference. You can find the code for this project on GitHub here. 97. How to Build a Powerful Status Page With Great Performance and Design This tutorial shows how a lightweight and performant time-series database coupled with queued status checks and a simple UI are best for robust applications. 98. Move over Next.js and Webpack 🤯 Simple Streaming SSR React with Styled-Components and Parcel Thank you for checking out the 98 most read stories about Nextjs on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

98 Stories To Learn About Nextjs

Today, I faced the following challenge at my internship: to modify/implement a splash screen and an icon for the project I am working on. However, I preferred to do it natively so as not to be dependent on third-party libraries. I set aside some time to do the spike (study) on how it works, where I would have to make changes, and what it would apply to. After doing the spike, I understood that I would have to do it separately for iOS and Android. Let's talk about iOS first! Note: This tutorial was created with the application built using create-react-app. iOS Firstly, we need to remember that to work with Apple's environment, we need a macOS. Now that the project is already created, let's go to the 'ios' folder and open it in . Xcode After that, we go to the folder with the name of our project, following the fictitious example below: Now, we will go to the 'Images' file, where we will have the size options. Just drag the corresponding images for each dimension and also one to be the app icon to use in the splash screen (if you don't know how to format your images to meet the standards, at the end of the article, we will have a brief tutorial on how to do it). At this point, we have already finished configuring the icons, and now we move on to the splash screen. For this step, I will use a solid background and an image in the center as an example, but you can edit it as your design created (or as you imagined lol). Firstly, we will open the in Xcode. In this file, we will navigate in the following order: . 'LaunchScreen' file 'View Controller Scene' → 'View Controller' → 'View' In this field, we have the safe area, which is nothing more than the useful space on the screen. By default, it already comes with the name you gave to the app when you created it and a footer 'Powered by React Native'. In this case, we will delete the footer and the app name. After that, we will click on the '+' in the upper right corner and go to the 'Image View' option and drag it to the application, align it in the middle, and adjust the responsiveness. Now that we have adjusted everything, just close Xcode and build your application. Your app will be all configured (Note: if you had already run it on your phone or emulator before, remember to delete the app so that the icon changes are applied)! Android Now let's move on to the Android configuration. For this, we will need icons in various sizes as well as a round version of the icons (without background). Also, please note that if you don't have these sizes, we have a step-by-step guide at the end of the post on how to configure this. A bit different from what we did on iOS, I chose not to use Android Studio here and instead modify the code directly because I didn't find its formatting menu very interesting! With the images already saved on your device, we will open the application folder in the file manager → android → app → src → main → res. Inside the "res" folder, we have the "drawable" folder and other folders. "mipmap-suffix" The "drawable" folder is where we will configure our splash and have the main icon, while the "mipmap" folders are responsible for the different icon sizes and round icons. The first thing we will do is replace the icon files with ours. I recommend using the same names as the ones already there so you don't have to modify native code yet, as shown below: Now that we have made changes throughout our application, we will move on to the native part! Inside the drawable folder, we have the file "rn_edit_text_material.xml" and we will make some configurations in it. To make it less verbose for you to write, I will leave the configurations that I used for you to simply copy and paste into your code along with an explanation of each change: We added the tag to direct the project schemas, and inside it we passed what we want to use. <layer-list> In this case, I used the tag to set the background color (we will configure it in the next step), and the last tag with the prefix to set the dimensions, which image to use, and its positioning on the device screen. <item android: drawable="@color/primary" /> item android: <?xml version="1.0" encoding="utf-8"?>

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">   
  
  <item android:drawable="@color/primary" />
  <item android:width="100dp" android:height="100dp" android:drawable="@drawable/icon" android:gravity="center" />
</layer-list> Now we will configure our backgroundColor, for that we will navigate to the "res" folder and create a file called "colors.xml" inside the "values" folder. We will add the code below, which contains a tag with our background color tag, already with the same name we gave in the previous step. <resources> <?xml version="1.0" encoding="utf-8" ?>
<resources>
  <color name="primary">#f2f2f2</color>
</resources> "styles.xml" is a file within the "values" folder, where we'll edit the following line that comes as a default when creating the app: <item name="android:editTextBackground">@drawable/rn_edit_text_material</item> to this code: <item name="android:windowBackground">
  @drawable/rn_edit_text_material
</item>
<item name="android:statusBarColor">
  @color/primary
</item> In the code snippet mentioned above, we set which window the background belongs to at the      top, and at the bottom, we set the color (previously defined). Great job! Your Android app             should be all set with the new splash screen and icons. Don't forget to test it thoroughly               before publishing it to the app store. Good luck with your app! Creating icons in desired sizes. To create our icons in the exact sizes, we will use 2 tools, the first one is called #Figma ( ) and the second one is a website called #ApeTools ( ). In ApeTools, we upload our image and it formats it in the iOS or Android standard size. In Figma, we will upload our Android images and add a borderRadius to them to make them rounded. https://www.figma.com/ https://apetools.webprofusion.com/#/tools/imagegorilla ApeTools: To use it, we will click on the "choose file" option, select the Logo and then select the Android and iOS base, after that just click on and the site will automatically render our icons. Kapow! Figma: Note: This step is only for configuring the Android icon. We will open the website or the #Figma application, upload the images that we want to round and in the right-hand menu, in the curve option, we will put '100' to get a perfect circle (in the example below I did it with only one image for illustration, but it should be done in all images of the "@mipmap" and I also used a larger borderRadius because my sample image was too large). My information: Linkedin ( ) https://www.linkedin.com/in/caslujpg/ Github ( ) https://github.com/caslujpg Email ( ) caslujpg@gmail.com If this article helped you and you want to buy me a coffee: PayPal ( ) https://www.paypal.com/donate/?hosted_button_id=ETNDVF9LP8NB8 ( 7639b894-6a88-4d43-9c39-6af265462f34 ) Pix(Brazil)

How to Add Icons and Splash Screen in React Native (Without Library)

Cómo agregar iconos y pantalla de bienvenida en React Native (sin biblioteca)

Comment ajouter des icônes et un écran de démarrage dans React Native (sans bibliothèque)

रिएक्टिव नेटिव (लाइब्रेरी के बिना) में आइकन और स्प्लैश स्क्रीन कैसे जोड़ें

React Native (ライブラリなし) でアイコンとスプラッシュ スクリーンを追加する方法

Como adicionar ícones e tela inicial no React Native (sem biblioteca)

Cách thêm biểu tượng và màn hình giật gân trong React Native (Không có thư viện)

如何在 React Native 中添加图标和启动画面（无库）

HTTP/3 is the latest HTTP protocol version designed to improve web application performance and security. Built on top of the QUIC protocol, HTTP/3 provides faster and more secure communication between the client and the server. Learning Objectives How to enable HTTP/3 in .NET 6 How can it enhance web application’s performance Getting Started Step 1: Installing Required Packages The first step is to install the required packages to enable HTTP/3 in the .NET 6 application. Using the Package Manager Console with the following command: Install-Package Microsoft.AspNetCore.Server.Kestrel.Transport.Experimental.Quic Step 2: Configuring Kestrel to Use QUIC The next step is configuring Kestrel, the web server included with .NET 6, to use QUIC. It can be done by modifying the configuration file of the application. var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel((context, options) =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
#pragma warning disable CA2252 // This API requires opting into preview features
        listenOptions.Protocols = HttpProtocols.Http3;
#pragma warning restore CA2252 // This API requires opting into preview features
        listenOptions.UseHttps();
    });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run(); The above code configures Kestrel to listen on port 5001 using the HTTP/3 protocol. Step 3: Testing the Application HttpClient has been updated to include support for HTTP/3, but it needs to be configured with a runtime flag. Include the following in the .csproj file to allow HTTP/3 <ItemGroup>
  <RuntimeHostConfigurationOption Include="System.Net.SocketsHttpHandler.Http3Support" Value="true" />
</ItemGroup> HTTP/3 needs to be specified as the version for the request: // See https://aka.ms/new-console-template for more information
using System.Net;

var client = new HttpClient();
client.DefaultRequestVersion = HttpVersion.Version30;
client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;

var resp = await client.GetAsync("https://localhost:5001/");
var body = await resp.Content.ReadAsStringAsync(); Backward Compatibility HTTP/3 is built on top of the QUIC protocol, which is only widely supported by some devices and networks. Therefore, it’s essential to have backward compatibility with previous versions of the HTTP protocol, such as HTTP/2 and HTTP/1.1, and to ensure that web applications can still be accessed by users using older browsers, operating systems, or networks that do not support HTTP/3. It can be done by modifying the application's configuration file as follows. builder.WebHost.ConfigureKestrel((context, options) =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
#pragma warning disable CA2252 // This API requires opting into preview features
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
#pragma warning restore CA2252 // This API requires opting into preview features
        listenOptions.UseHttps();
    });
}); Moreover, backward compatibility ensures that a broader audience can access web applications, including users with older devices and networks. It increases the reach of web applications and provides a better user experience for users with limited access to newer technologies. Conclusion In conclusion, enabling HTTP/3 in your .NET 6 application is a straightforward process that can significantly improve your web application’s performance and security. Leveraging HTTP/3 provides a better user experience to your customers with faster loading times, reduced latency, and improved reliability. References HTTP/3 support in .NET6 Also published here.

Upgrade Your Web Development Game with HTTP/3 in .Net 6

Stories, News & Mentions about CONTENTWARE

Contentware’s Stories on HackerNoon