DEV Community: Baruch Odem

ElasticSearch get the first time that item is shown

Baruch Odem — Wed, 04 Aug 2021 12:41:02 +0000

ElasticSearch get the first time that item is shown

Aug 4 '21 Comments: 8 Answers: 0

In my case, I'm doing an action each time (PullRequest) and saving the action results in ElasticSearch.

I want to build a query that will help me to get the results changes in every action.

For example, the data can represent this case:

PR sortable ID	Results	Change
1

…

Open Full Question

How to setup auto semantic-release

Baruch Odem — Tue, 27 Jul 2021 05:42:21 +0000

Semantic Versioning

Semantic Versioning (AKA SemVer) is a convention for package versions. Since it is the most used convention (AFAIK, I don't know about others...), it is well documented and widely used around the open-source, so I'm not going to describe it. You can read more here.

Semantic Release

Semantic Release is a tool to implement SemVer automatically in a project.

Fully automated version management and package publishing
from Semantic Release docs.

In this post, I want to share with you the process of adding and configuring the semantic-release tool, because I had to collect the information from multiple sources, even from the source code of the tool.

Let's start.

Prerequisites

In this post, I assume you have

a NodeJS project (with a package.json file)
in a Github repository
with basic knowledge in Github Actions
and fearlessly use CLI and read its output

Command Line

The semantic-release feels like a great tool, and it does a lot of things by default, and does them right.

The first thing you want to do is to run the tool, just like that. Don't worry, it will identify that you're not in a CI environment, and it will automatically run on dry mode.

In your project folder, run npx semantic-release, it will print some beautifully organized output. Read that output.

First of all, it failed because of missing tokens, follow the links inside the errors to create the tokens.

It will not create a version (dry run), and you expect one of the next messages:

There is no previous release, the next release version is 1.0.0

If you never published a release before (and release means git tag), semantic-release will create a default version 1.0.0 in any way.

configured to only publish from master

The whole line:

This test run was triggered on the branch foo, while semantic-release is configured to only publish from master, therefore a new version won’t be published.

We will see the semantic-release is triggering a version when pushing to specific branches. If you're not in the master branch, the semantic-release will not process your git history to create a version.

There are no relevant changes, so no new version is released.

Maybe you see messages about Analyzing commit because you committed some changes since your last version, but eventually, the semantic-release didn't find a commit message in a pattern to create a new release.

We will touch on the commit messages pattern later.

Published release 1.1.0 on default channel

OK, but it did nothing because, with dry-run mode, all the actions were skipped, this is just a completion message.

Commit Format

We ran the semantic-release tool with the default configurations. Before any other configuration adjustment, the most important thing you may ask is, why is semantic-release analyzing my commits but There are no relevant changes?

That is because semantic-release uses commit message format to decide if and what version should be bumped.

Try to commit with the message perf(pencil): remove graphiteWidth option and see if now it's deciding to bump your version.

Configuration

I saw the default commit format (Angular Conventions) and I felt it will add overhead and will be less readable, and it is not worth the time I'm saving with automatic releasing. I wanted to change the commit format.

To do that, we need to configure the semantic-release, and since any configuration section will override the default configuration we used so far, I think the best idea is first to configure the default configuration explicitly, and then start to adjust it.

The default configuration for the relevant sections (in release.config.js format) is:

module.exports = {
  branches: [
    "+([0-9])?(.{+([0-9]),x}).x",
    "master",
    "next",
    "next-major",
    {
      name: "beta",
      prerelease: true,
    },
    {
      name: "alpha",
      prerelease: true,
    },
  ],
  plugins: [
    "@semantic-release/commit-analyzer",
    "@semantic-release/release-notes-generator",
    "@semantic-release/npm",
    "@semantic-release/github",
  ],
};

Branch Configuration

The first configuration I wanted to change is the branches. For me and for now, I just need to trigger the release on the master branch, you can see how simple is the, just branches: ['master'] instead of the current config.

So far so good?

You have that configuration, you may push and start using automatic release. What else?

For me, I wanted to take it few steps forward, to

Use more convenient and readable commit messages.
Set the commit message just before finishing the PR, and not on each commit.
Manage a CHANGELOG file.
Bonus: Tweet about the new version

Let's continue.

Custom Commit Message Convention

The default plugin @semantic-release/commit-analyzer is responsible to analyze the commit message, and it is configured by two settings:

The convention (preset)
The rules (releaseRules)
(Other options: parserOpts)

I decided to follow the ESLint convention:

# Format:

Tag: Short description (fixes #1234)

# Examples:

Build: Update Travis to only test Node 0.10 (refs #734)
Fix: Semi rule incorrectly flagging extra semicolon (fixes #840)
Upgrade: Esprima to 1.2, switch to using comment attachment (fixes #730)

This format is better, right?

To use this format, we first need to select eslint as our parser, but surprise! It is not coming with all its default available tags (the Build, Fix, Upgrade and more), and instead, the @semantic-release/commit-analyzer will handle only a four tags:

{tag: 'Breaking', release: 'major'},
{tag: 'Fix', release: 'patch'},
{tag: 'Update', release: 'minor'},
{tag: 'New', release: 'minor'},

You can keep it with this default, or if you want to add more tags, you can add your custom object to replace the default one.

For me, the plugins are now:

plugins: [
  [
    "@semantic-release/commit-analyzer",
    {
      preset: "eslint",
    },
  ],
  [
    "@semantic-release/release-notes-generator",
    {
      preset: "eslint",
    },
  ],
  "@semantic-release/npm",
  "@semantic-release/github",
];

Note that I had to update the @semantic-release/release-notes-generator settings since it is also analyzing the commits to generate the release notes.

And finally, I documented the default tags in my repo, just to easily find them if I forgot.

Conventional PullRequest title

For now, you expect the contributors to use the conventional commit messages (and you may use commitlint). But you don't have to force it.

First of all, you can keep it optional, and if you want to trigger a new release, make sure that one of the commits in a PR is in the convention.

In my repos, I'm using two conventions, side by side:

Merge Commit

If the Pull Request contains more than one change (and of course, in multiple commits), although it is not best practice, you know, a small repo without contributors... Anyway, in that case, I'm looking at the commits to see if there are conventional commits there, and if so, I'm merging the PR, and the commits will be in the master branch and will trigger the release.

Squash Commits

If the PR is only about one change, we don't have the commits to be conventional. Instead, we can change the pull request title to be conventional, and squash the pull request to be only one commit in master. In Github, by default, the pull request title becomes to be the commit message in squash merge.

To help me to remember that, I created a Github Actions workflow to validate the pull request title and comment on the PR if the title does not match my convention.

name: PR Title

on:
  pull_request:
    types: [opened, edited, synchronize, reopened]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: deepakputhraya/action-pr-title@3864bebc79c5f829d25dd42d3c6579d040b0ef16
        name: Validate PR Title
        continue-on-error: true
        with:
          regex: '\w+:( [\w\.,]+)+( \(\w+ #\d+\))?' # Regex the title should match.
          allowed_prefixes: 'Breaking,Fix,Update,New' # title should start with the given prefix
          # disallowed_prefixes: 'feat/,hotfix' # title should not start with the given prefix
          prefix_case_sensitive: true # title prefix are case insensitive
          # min_length: 5 # Min length of the title
          max_length: 50 # Max length of the title
          github_token: ${{ secrets.GITHUB_TOKEN }} # Default: ${{ github.token }}
      - uses: mshick/add-pr-comment@07f690343c25a94e24a8acb70d03c86b701ae322
        name: Comment on PR
        if: ${{ failure() }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          message: |
          Please fix the title of this PR.

          Examples:

          ```
{% endraw %}

          Breaking: I broke something
          Fix: fix (fixes #1234)
          Update: some packages updates (refs #123)
          New: Added a new feature
{% raw %}

          ```

          See more in `/docs/RELEASE.md`.

I compared a lot of optional actions to do this validation and comment, and I'm not sure I selected the best. Please share with me your suggestions.

Manage a CHANGELOG file

There is a practice to manage a file with all the release notes, for all the versions, listed on it.

Unfortunately, I can't think about a beautiful way to update the CHANGELOG without adding another commit after the release.

To generate the CHANGELOG and commit it, we will add two (obvious) plugins to semantic-release: @semantic-release/changelog and @semantic-release/git.

plugins: [
  ...
  [
   "@semantic-release/changelog",
   {
    "changelogFile": "CHANGELOG.md"
   }
  ],
  [
   "@semantic-release/git",
   {
    "assets": ["CHANGELOG.md"],
    "message": "${nextRelease.version} CHANGELOG [skip ci]\n\n${nextRelease.notes}"
   }
  ]
  '@semantic-release/npm',
  '@semantic-release/github'
]

Please note the plugins are running sequentially, and you have to put the changelog plugin before the git plugin.

This configuration will first update the CHANGELOG.md file in the local folder, and after that will commit it with a custom message, includes the [skip ci], to mark this commit as out of release process.

Bonus: Tweet about a new release

Now you have a fully working process to automate your release, and more than that, I hope you got enough information to continue to adjust the process to your needs.

One more thing I'm doing is to tweet about new releases, to implement, follow the instructions in ethomson/send-tweet-action.

If you want to get the new version number (or any other value) from semantic-release, you need to put it in Environment Variables, and you can do it with @semantic-release/exec:

plugins: [
  ...[
    "@semantic-release/exec",
    {
      successCmd: 'echo"SEMVER_VERSION=${nextRelease.version}" > $GITHUB_ENV',
    },
  ],
];

Last words

While writing this post to document my process, I finally found another blog post that already documented it, you are welcome to use both :-).

Thanks to my teammate Leonid Weinberg who review the article to correct language errors.

I implemented the process in this repo:

baruchiro / use-route-as-state

Use React Router route and query string as component state

use-route-as-state

Use React Router route and query string as component state

Warning

Deprecation Warning: This package does not support react-router v6 (see issue #172).

Install

npm install --save use-route-as-state

Usage

You can see a live demo, including code, here.

// URL: /:param?query=
import * as React from "react";
import { useRouteParams, useQueryString } from "use-route-as-state";

const Example = () => {
  const [{ param }, setRouteParams] = useRouteParams();
  const [{ query }, setQueryParams] = useQueryString();

  return (
    <div>
      <input
        value={param}
        onChange={({ target }) => setRouteParams({ param: target.value })}
      />
      <input
        value={query}
        onChange={({ target }) => setQueryString({ query: target

…

View on GitHub

And these are my configuration files:

How to sync component state with React Router

Baruch Odem — Mon, 07 Sep 2020 11:01:34 +0000

Use Case

You have a webpage showing your data, and an input component that controls the filtering of that data.

For example, you have a simple list of students, and a search box that filters the list as you type.

You want, of course, to make the value of the input reactive, in order to change the subset of the data whenever the value changes.

But you also want the user to be able to share a link to the current status of the page at any time.

In our example, you want the contents of the search box to be represented in the URL as well, as Query String, for example.

Let's see how to make the `value` from one component to be reactive to both component state and Router, with clean code.

The Simple (but complicated) Way

We will start with the direct way. We need to get the data from the route, and update the route on change:

We have a few APIs (hooks) to get the data from the Router. For this post I chose to use URL Params with useParams for simpler code samples, although in a real app, Query String make more sense for this kind of use case.

Note that to use URL Params you have to declare the params in the Router path prop, something like /:param1/:param2?.

Get the data from the `route`

When the component mounts, we need to read the URL Params, in case the user gets to our component from a link that should affect the state:

const SearchBox = () => {
    const { param1 } = useParams()
    const [search, setSearch] = useState(param1)
}

But this is not enough, since route changes often don't reload the page (which is good). If there is no page reload, the state won’t change because the component is already mounted.

We need to define the URL Param change as an effect:

const SearchBox = () => {
    const { param1 } = useParams()
    const [search, setSearch] = useState()

    useEffect(() => setSearch(param1), [param1])
}

✔️ Getting the data from the route is done - the state is synced with the route (but the route is not synced with the state).

Update the route on change

Now we can update the search state with setSearch, but we want to keep the URL up to date with the latest search, in order to allow the user to copy the URL at any time.

The only way (that I know) to change the URL with React Router is with the history API:

const SearchBox = () => {
  // Code from previous examples

  return (
    <div>
      <input
        type="text"
        value={search}
        onChange={(e) => history.replace("/" + e.target.value)}
      />
      <SearchList search={search} />
    </div>
  );
};

✔️ Update the route on change is done - change the route instead of the state, and the state will get updated from the useEffect hook.

Interim conclusions

It is working very well in our simple example (even better than I thought!)
To use the route as our state, we used four hooks (useParams, useState, useHistory and useEffect) instead of one hook to get the state and a method to update it.
We will need more and more code if we want to use Query Params or if we want the history.replace function call to be more generic with the path argument.

Actually, the solution seems very simple at this point.

Spoiler- I created a package that implements this solution.
I must share that I wonder if I would have created this package if I had written the article earlier, and understood that the solution is simple and required.
In any case, I felt a lack of idea-sharing of this solution, so I think it is worth writing the post and creating the package.

We need to hide all this logic in a custom hook.

Organize the code

Let's move all the code to a dedicated function:

const useCustomParams = () => {
  const { param1 } = useParams();
  const [search, setSearch] = useState();

  const history = useHistory();

  useEffect(() => setSearch(param1), [param1]);

  const replace = (newParam) => history.replace("/" + newParam);

  return [search, replace];
};

You don't really need the state here, because you have a closed flow from useParams to the component, then with history back to the useParams.
But you will need it for the Query String case.

All that is left is not to be dependent on the path or specific URL Param:

const useCustomParams = () => {
  const { params, path } = useRouteMatch();

  const history = useHistory();

  const updateParams = (updatedParams) => {
    Object.assign(params, updatedParams);
    history.push(generatePath(path, params));
  };
  return [params, updateParams];
};

I don't know the specific path or params, I just take, update and push them again.

After going through this process myself, and seeing that there was a lack of information on this subject, I created an npm package called use-route-as-state that implements the solution described in the article.

You are welcome to use and contribute!

Thanks to @brafdlog for linguistic editing and suggestions.

Final Project - Hardware Recommendation

Baruch Odem — Thu, 21 May 2020 13:45:49 +0000

This document requires proofreading in English, thank you!

Hardware Recommendation

I am a programmer, but for the family and friends I also help with computer repair. Over the time I collected more and more used hardware components such as Memory sticks and HDDs, and when I took care of a friend or family laptop, I also added it a used component (if it was suitable).

Also, as the Hardware Champion, I was also asked to recommend which new computer to buy.

So I had two problems:

As the number of the used hardware grows, how can I know if I have a component to upgrade a specific laptop?
Can I trust my suggestions for new computers, if I don't track on the market updates, and if I don't know what are the Designer user needs?

These two questions lead me to try to implement a recommendation system for computer upgrading or buying.

Spoiler: I didn't finish the system, but if someone wants to build one, I will be happy to join!

I started to define the project with the Lean Canvas Model, I'm really suggesting you take this pattern seriously. We all know how many ideas and startup didn't even start, and not talking about finishing because we think our idea is huge, but we don't have actually measurement tools to validate that. So please use the Lean Canvas Model to stay focused and adjust your project in any step!

The main problems that the project will solve are:

Peoples want to upgrade their computer or buy a new one, but they didn't know which hardware component effect on which parameter!

For example, someone can think that the new processor will help the computer to run faster, but he has an HDD disk, so the computer will still to be slowly.
Peoples want to buy a computer for their needs, but they didn't know what their needs are!

For example, a student wants to buy a computer for learning Architecture. He knows which software he will be going to use, but he won't know if he needs a good processor or a lot of memory.

In the Lean Canvas Model there are more three steps, and the central one is the Unique Value Proposition, but I will skip on them to the Solution:

Collect Hardware Information from users and give them an upgrade recommendation, collect the Hardware Information to your recommendation system.
Create an informative survey and generate an answer by calculating the user requirement, user personal details, and output from the recommendation system.

Note that even the main goal of the 1st is to collect the data, you have to give a value to the user, otherwise, he will not give you any data.

Link to Code

Landing Page

baruchiro / HWRecommendation-WebAPI

Server Side Web API for all API requests

baruchiro / HWRecommendation-local

Desktop script to fetch system information and get hardware recommendation

How I built it

As I said, I didn't complete the system, so there is no complete software architecture map here, so you've earned it, otherwise, it was boring.

In this project I took the opportunity to try two new technologies from Microsoft. C# is my native language, and I actually love the new Microsoft (I think anyone who insists on staying prejudiced loses).

The two new technologies are Microsoft Bot Framework and ML.NET ("New", as of the end of 2018)

I've learned and dealt with a lot of things since then, so I can't remember all the details.
During the development period, I wanted to write an article about my experiences with these new systems, but in those days I had hard writing in English. (Even now my English is not good, but at least it's not hard for me to write :-))

Microsoft Bot Framework

This system felt good. In those days, I started to love the idea of API, the idea of writing a system to expose the data and action, and then write any type of interfaces (CLI, web app, bots) to interact with the API.

The Bot Framework is based on ASP.NET, so it is just another controller that you can add to your existing ASP.NET Web API (At the time it seemed right to me. Now I understand that it has no meaning).

The Bot Framework wants to be an endpoint from all the bot systems (Telegram, Facebook, etc), and it was such a comfortable system. It has also an "Emulator", you can try your bot easily with a local tool, so it was excellent.

Unfortunately, I missed the opportunity to offer improvements. I solved some problems and invented 2-3 patterns to reuse code and solve some other annoying design problems, but as I said, in those days it was harder for me to speak English.

At least I've contributed some code for testing:

Add AssertReplyContain #1922

baruchiro posted on May 21, 2019

View on GitHub

Edit: Funny thing! I didn't remember if and where I wrote my conclusions from the Bot Framework experience, but when I edited this DEV.to profile I found a draft about that!
I don't know if it is still relevant, if so, I will love to get help posting it.

Bot Framework .NET design decisions

Baruch Odem ・ May 21 ・ 5 min read

#botframework #netcore #aspnet

ML.NET

In contrast to the Bot Framework with the potential to improve, the ML.NET was very disappointing.

I played with ML with python before, and compared to the dynamization in python, C# was disturbed. What is one of the big changes between python and C#? Right! the Typing System.

In ML, before you doing your magic, or even before you give the algorithm or the library to do its magic, you have to transform and clean your data. This is the real work on ML, at least from my point of view as a developer who has just experimented.

If you writing in python, do any transform you want, and get the transformed data when you want to, the transformed data will be different type from the input (for example, you transformed strings to numbers), and python don't do a type validation if it not have to, so print your data and see it state every step you want!

But in ML.NET... Oh, it was horrible!

First of all, I built a whole system to flatten complex objects and convert then to a very short list of types that can be input to the ML.NET, I think it was in this file.

Then, I started to transform my data. There was a good pattern of "pipeline", you connect one pipeline to another to stream the information from one transformation to another. But you always have to be aware of the type of the current state of the data!. If I remember correctly, the pipelines connected each other with a kind of limitation about the expected output and input type.

Even if I don't remember correctly, for sure you want to see how the data looks like after some transformations, to validate you are on the right way. So gues what? You need a type!

Yes! If you want to see how the data looks like after all your transformation, before the real algorithm transformation, you have to represent the expected output with Class. You find yourself trying to do all the transformations in your head, in order to represent the expected output in a Class, all this to get a snapshot of the transformed data, after you did all this in your head, and absolutely missed some edge cases.

This is the stage that broke me.

And my issue is still opened:

Support dynamic types when working with IDataView #3829

baruchiro posted on Jun 05, 2019

Issue

I want to read my data from the .csv file. I think it may be done without strongly-typing my objects. In C#, we have two potential abilities: Anonymous Types and Dynamic Types.

I tried to check how the existing code could be adapted, but I could not fully understand the code.

View on GitHub

And these are my other issues.

Additional Thoughts / Feelings / Stories

Github Student Pack

I used Github Sdutent Pack to easily freely use Azure. In the Microsoft ecosystem, you can easily create an end-to-end development environment, so I developed in my local Visual Studio, then, from the Visual Studio I configured the CI/CD pipelines in Azure DevOps, and from there, I published to Azure without testing my time in configuring a cloud systems.

So when my class friends had to display everything on their laptops, include demo and let peoples to all wait for their laptop to be available, I just had to give them QR Code to experiment on their own.
In other words, I was in production.

Today

Now, as I write this article, I go back to that period (just a year ago), and I realize that I would have done things completely differently.

In the last few months I learned so much new things and architectures, so there are some things I would have done otherwise.

Doing one thing

In Agile world, we need to always give a value. Sure, you need some infrastructure to start giving a value, but the thout about my project is that I had a hidden propose in this project. I wanted to index all my hardware components.

Remember my goals at the beginning of the post? Is that part of the goal?

No.

If you trying to do multiple things at once, you disperse and you have nothing left.

Microservices

From above:

So it is just another controller that you can add to your existing ASP.NET Web API

If you creating a one project for all your needs, you can't change things easly.

After realizing that ML.NET can't give me what I need, I thought to use python, but the cost of integrating the python code to my project was expensive. (I still used python for the preparation transformations).

If you working with Microservices, you have a contract and way to communicate between the services, and since each service need to do one thing, if the service not meet your needs, you can easily implement another one, in another technology, that will replace the existed.

Each service is small and independent, so it's cheap to replace it.

Bot Framework .NET design decisions

Baruch Odem — Thu, 21 May 2020 13:13:01 +0000

Hi, this post was written a long ago, and it waited for review, because my English is not so good.
So it not posted at all.
Now I found it as a draft, and I posted a new post, so I also releasing this post, and maybe it is not relevant anymore, so please tell me if you think it is deprecated.

Final Project - Hardware Recommendation

Baruch Odem ・ May 21 '20

#octograd2020 #githubsdp #botframework #mlnet

Prerequisites

Knowledge of ASP.NET Core project structure.
Knowledge of developing with Bot Framework in C#.

Intro

In my final project at the college, I write a bot with Microsoft Bot Framework on ASP.NET Core.

I think Microsoft has a lot of good things and lots of pretty things that are open source. The Bot Framework is a very good idea, but something is not baked there.

In order to write a well-designed code, and avoid from duplicated code, I had to make some decisions that seemed not to have been included in the original documentation.

apology

This post can seem obvious to you. The problem is that it's been a while since I touched the code, and by the time I remember the more serious things, I had to start from somewhere.

Plug & Play

In C#, the most used way to implement a bot with Bot Framework is to add it as middleware in ASP.NET Core app, and that's my case.

Looking forward, if we want to use that bot in a different place, We will receive his logic, but also his WebAPI infrastructure. So if now we think about the option of publishing our bot as nuget, for integrate it with more then one project, we may think about writing the bot only, in a project of its own.

The project

The first step- writing the bot in its own project, is very straight. A bot is just a class that implements the IBot interface, with one method:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Bot.Builder
{
    public interface IBot
    {
        Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken));
    }
}

Of course, all the states and accessors (ConversationState, IStatePropertyAccessor<T>) will be in the Bot project.

The rule of thumb is that things that the bot needs only for its logic, and are independent of the environment in which it runs, should be in its project. (Except when you want your bot to be more configurable, but that is not the subject of this post). But things that depend on the environment in which the bot runs, such as things that belong to the Console Application against things that are relevant to the Web API, or a file system, a database, etc., will be injected into the bot from the outside.

How?

The extension method(s)

We will create an Extension Method for the to extend the functionality of ASP.NET, but leave the implementation in our project.

The bot definition is made by code like the following code:

services.AddBot<RecommendationBot>(options =>
{
    var secretKey = configuration.GetSection("botFileSecret")?.Value;
    var botFilePath = configuration.GetSection("botFilePath")?.Value;

    // Loads .bot configuration file and adds a singleton that your Bot can access through dependency injection.
    var botConfig = BotConfiguration.Load(botFilePath ?? @"Echo.bot", secretKey);
    services.AddSingleton(sp =>
                    botConfig ??
                    throw new InvalidOperationException(
                        $"The .bot configuration file could not be loaded. ({botFilePath ?? @"Echo.bot"})"));

    // Retrieve current endpoint.
    var environment = env.IsProduction() ? "production" : "development";
    var service = botConfig.Services.FirstOrDefault(s => s.Type == "endpoint" && s.Name == environment);
    if (!(service is EndpointService endpointService))
    {
    throw new InvalidOperationException("The .bot file does not contain an endpoint.");
    }

    options.CredentialProvider =
    new SimpleCredentialProvider(endpointService.AppId, endpointService.AppPassword);

    // Creates a logger for the application to use.
    ILogger logger = new LoggerFactory().CreateLogger<RecommendationBot>();

    // Catches any errors that occur during a conversation turn and logs them.
    options.OnTurnError = async (context, exception) =>
    {
    logger.LogError($"Exception caught : {exception}");
    await context.SendActivityAsync("Sorry, it looks like something went wrong.");
    };
});

services.AddSingleton<IStorage>(new MemoryStorage());
services.AddSingleton<StateManager>();

(At the time of writing, version 4.3 was released. In this version, the configuration is simpler and based on Dependency Injection.)

In a regular project, the services variable is the variable obtained as a parameter in the function public void ConfigureServices(IServiceCollection services) in the Startup class. But since we don't want all of this code to be in the Startup class, which is a class of the project that uses the bot, we can easily create an Extension Method for the IServiceCollection object, within the bot project:

public static class BotRegistrationExtension
{
    public static void AddOurBot(this IServiceCollection services, IConfiguration configuration, IHostingEnvironment env)
    {
        services.AddBot<RecommendationBot>(options =>
        {
            // Code from above
        });

        services.AddSingleton<IStorage>(new MemoryStorage());
        services.AddSingleton<StateManager>();
    }
}

Now, adding and removing the bot in the code will be very simple, all we need to do is call this function in one place in the Startup.ConfigureServices:

services.AddOurBot(Configuration, _environment);

Shared interfaces

Now, we've seen how to completely separate the bot from the project that uses it. In this way, we can provide the bot as Nuget Package, and hide all the implementation, so that the programmer only needs to call the Extension Method that we have set up to add the bot to its ASP.NET project.

But what about the components that the robot needs to communicate with the infrastructure? We said earlier that there are things that depend on the project that runs the bot, so they will not be defined in the bot project.

Assume the bot needs to save data in a database.

You can probably guess the way of implementation, since this is not a special case of the bot, but rather a correct form of programming.

We will create an interface in the bot project, which will define the necessary methods, such as Save and Load.

Now, we can require the user to provide us with interface implementation while calling our Extension Method. We will do this by adding a parameter to the function, or by defining the function as a generic function:

// For provide an implementation as an argument
public static void AddOurBot(this IServiceCollection services, IConfiguration configuration, IHostingEnvironment env, IDbContext dbContext)
{
    // The code from above
    services.AddScoped(typeof(IDbContext), provider => dbContext);
}

public static void AddOurBot<T>(this IServiceCollection services, IConfiguration configuration, IHostingEnvironment env)
    where T : class, IDbContext
{
    // The code from above
    services.AddScoped(typeof(IDbContext), typeof(T));
}

Summary

I've shown a simple case in the Bot Framework that should be implemented more correctly.
This example can be taken for any other project.
In the following posts I will present things about the objects in the Bot Framework, such as Waterfall and Prompt, about their problems in terms of software design, and how I dealt with them.
You are welcome to ask, comment, correct and ask for more posts.

Thanks!

Looking for reviewer for post about Microsoft Bot Framework

Baruch Odem — Mon, 06 May 2019 15:47:55 +0000

Looking for someone to review my post about Microsoft Bot Framework before I publish it.

I Computer Science Student in Israel, Ask Me Anything!

Baruch Odem — Thu, 02 May 2019 15:44:53 +0000

DEV Community: Baruch Odem

ElasticSearch get the first time that item is shown

ElasticSearch get the first time that item is shown

How to setup auto semantic-release

Semantic Versioning

Semantic Release

Prerequisites

Command Line

Commit Format

Configuration

Branch Configuration

So far so good?

Custom Commit Message Convention

Conventional PullRequest title

Merge Commit

Squash Commits

Manage a CHANGELOG file

Bonus: Tweet about a new release

Last words

baruchiro / use-route-as-state

Use React Router route and query string as component state

use-route-as-state

Install

Usage

How to sync component state with React Router

Use Case

Let's see how to make the value from one component to be reactive to both component state and Router, with clean code.

The Simple (but complicated) Way

Get the data from the route

Update the route on change

Interim conclusions

Organize the code

Final Project - Hardware Recommendation

Hardware Recommendation

Link to Code

baruchiro / HWRecommendation-WebAPI

Server Side Web API for all API requests

baruchiro / HWRecommendation-local

Desktop script to fetch system information and get hardware recommendation

How I built it

Microsoft Bot Framework

Add AssertReplyContain #1922

Bot Framework .NET design decisions

Baruch Odem ・ May 21 ・ 5 min read

ML.NET

Support dynamic types when working with IDataView #3829

Issue

Additional Thoughts / Feelings / Stories

Github Student Pack

Today

Doing one thing

Microservices

Bot Framework .NET design decisions

Final Project - Hardware Recommendation

Baruch Odem ・ May 21 '20

Prerequisites

Intro

apology

Plug & Play

The project

The extension method(s)

Shared interfaces

Summary

Looking for reviewer for post about Microsoft Bot Framework

I Computer Science Student in Israel, Ask Me Anything!

Let's see how to make the `value` from one component to be reactive to both component state and Router, with clean code.

Get the data from the `route`