INHUBBER is a B2B SaaS contract lifecycle management platform enabling full control over the performance-based contracts

INHUBBER

Learn to enhance your maintainability with generics and custom interfaces in C#. Discover a better approach on Day 29 of our 30-Day .NET Challenge. Introduction Developers often tend to add unnecessary boxing in the code which can hamper application performance. The article demonstrates both inefficient and efficient approaches to avoid the issue. Learning Objectives What is Boxing
Why non-generic interface approach is inefficient
A recommended approach using generics Prerequisites for Developers Basic understanding of C# programming language. 30 Day .Net Challenge Getting Started What is Boxing? Boxing is the process of converting a value type into an object type. In other words, it means the allocation of objects on a heap rather than a stack. Therefore, a performance overhead because of increased memory usage and the need for garbage collection. Why non-generic interface approach is inefficient In the following scenario, each time a value is assigned to values, it undergoes boxing which can make your application suffer from performance pressure. public interface INumber
    {
        object Value { get; set; }
    }
    
    public class Number : INumber
    {
        public object Value { get; set; }
    } A recommended approach using generics Please find below the refactored version of the previous code snippet using generics which allows type safety without the need for boxing. public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T> // Utilize generics to avoid boxing
    {
        public T Value { get; set; }
    } How to use Generics in practice var intNumber = new Number<int> { Value = 123 };
    var floatNumber = new Number<float> { Value = 123.45f }; Complete Code Create another class named GenericCustomInterfaces and add the following code snippet public static class GenericCustomInterfaces
    {
      static List<INumber<int>> intNumbers = new List<INumber<int>>();
      static List<INumber<double>> doubleNumbers = new List<INumber<double>>();
    
      public static void Example()
      {
          // Populate the list with integers
          for (int i = 0; i < 10; i++)
          {
              intNumbers.Add(new Number<int>(i));
          }
    
          // Populate the list with doubles
          for (double d = 0.5; d < 10.0; d += 1.0)
          {
              doubleNumbers.Add(new Number<double>(d));
          }
    
          // Process and display integer numbers
          Console.WriteLine("Integer Numbers:");
          foreach (var num in intNumbers)
          {
              Console.WriteLine(num.Value);
          }
    
          // Process and display double numbers
          Console.WriteLine("\nDouble Numbers:");
          foreach (var num in doubleNumbers)
          {
              Console.WriteLine(num.Value);
          }
      }
    } Add the interface and its class implementation as follows public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T>
    {
        public T Value { get; set; }
        public Number(T value)
        {
            Value = value;
        }
    } Execute from the main method as follows #region Day 29: Generics & Custom Interfaces
    static string ExecuteDay29()
    {
        GenericCustomInterfaces.Example();
    
        return "Executed Day 29 successfully..!!";
    }
    
    #endregion Console Output Integer Numbers:
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    Double Numbers:
    0.5
    1.5
    2.5
    3.5
    4.5
    5.5
    6.5
    7.5
    8.5
    9.5 Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to
Visit our other platforms: GitHub
More content at C# Programming Learn to enhance your maintainability with generics and custom interfaces in C# . Discover a better approach on Day 29 of our 30-Day .NET Challenge. C# Introduction Developers often tend to add unnecessary boxing in the code which can hamper application performance. The article demonstrates both inefficient and efficient approaches to avoid the issue. Learning Objectives What is Boxing Why non-generic interface approach is inefficient A recommended approach using generics What is Boxing Why non-generic interface approach is inefficient A recommended approach using generics Prerequisites for Developers Basic understanding of C# programming language. Basic understanding of C# programming language. 30 Day .Net Challenge 30 Day .Net Challenge 30 Day .Net Challenge Getting Started What is Boxing? Boxing is the process of converting a value type into an object type. In other words, it means the allocation of objects on a heap rather than a stack. Therefore, a performance overhead because of increased memory usage and the need for garbage collection. Why non-generic interface approach is inefficient In the following scenario, each time a value is assigned to values, it undergoes boxing which can make your application suffer from performance pressure. public interface INumber
    {
        object Value { get; set; }
    }
    
    public class Number : INumber
    {
        public object Value { get; set; }
    } public interface INumber
    {
        object Value { get; set; }
    }
    
    public class Number : INumber
    {
        public object Value { get; set; }
    } A recommended approach using generics Please find below the refactored version of the previous code snippet using generics which allows type safety without the need for boxing. public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T> // Utilize generics to avoid boxing
    {
        public T Value { get; set; }
    } public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T> // Utilize generics to avoid boxing
    {
        public T Value { get; set; }
    } How to use Generics in practice var intNumber = new Number<int> { Value = 123 };
    var floatNumber = new Number<float> { Value = 123.45f }; var intNumber = new Number<int> { Value = 123 };
    var floatNumber = new Number<float> { Value = 123.45f }; Complete Code Create another class named GenericCustomInterfaces and add the following code snippet public static class GenericCustomInterfaces
    {
      static List<INumber<int>> intNumbers = new List<INumber<int>>();
      static List<INumber<double>> doubleNumbers = new List<INumber<double>>();
    
      public static void Example()
      {
          // Populate the list with integers
          for (int i = 0; i < 10; i++)
          {
              intNumbers.Add(new Number<int>(i));
          }
    
          // Populate the list with doubles
          for (double d = 0.5; d < 10.0; d += 1.0)
          {
              doubleNumbers.Add(new Number<double>(d));
          }
    
          // Process and display integer numbers
          Console.WriteLine("Integer Numbers:");
          foreach (var num in intNumbers)
          {
              Console.WriteLine(num.Value);
          }
    
          // Process and display double numbers
          Console.WriteLine("\nDouble Numbers:");
          foreach (var num in doubleNumbers)
          {
              Console.WriteLine(num.Value);
          }
      }
    } public static class GenericCustomInterfaces
    {
      static List<INumber<int>> intNumbers = new List<INumber<int>>();
      static List<INumber<double>> doubleNumbers = new List<INumber<double>>();
    
      public static void Example()
      {
          // Populate the list with integers
          for (int i = 0; i < 10; i++)
          {
              intNumbers.Add(new Number<int>(i));
          }
    
          // Populate the list with doubles
          for (double d = 0.5; d < 10.0; d += 1.0)
          {
              doubleNumbers.Add(new Number<double>(d));
          }
    
          // Process and display integer numbers
          Console.WriteLine("Integer Numbers:");
          foreach (var num in intNumbers)
          {
              Console.WriteLine(num.Value);
          }
    
          // Process and display double numbers
          Console.WriteLine("\nDouble Numbers:");
          foreach (var num in doubleNumbers)
          {
              Console.WriteLine(num.Value);
          }
      }
    } Add the interface and its class implementation as follows public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T>
    {
        public T Value { get; set; }
        public Number(T value)
        {
            Value = value;
        }
    } public interface INumber<T>
    {
        T Value { get; set; }
    }
    
    public class Number<T> : INumber<T>
    {
        public T Value { get; set; }
        public Number(T value)
        {
            Value = value;
        }
    } Execute from the main method as follows #region Day 29: Generics & Custom Interfaces
    static string ExecuteDay29()
    {
        GenericCustomInterfaces.Example();
    
        return "Executed Day 29 successfully..!!";
    }
    
    #endregion #region Day 29: Generics & Custom Interfaces
    static string ExecuteDay29()
    {
        GenericCustomInterfaces.Example();
    
        return "Executed Day 29 successfully..!!";
    }
    
    #endregion Console Output Integer Numbers:
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    Double Numbers:
    0.5
    1.5
    2.5
    3.5
    4.5
    5.5
    6.5
    7.5
    8.5
    9.5 Integer Numbers:
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    Double Numbers:
    0.5
    1.5
    2.5
    3.5
    4.5
    5.5
    6.5
    7.5
    8.5
    9.5 Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub More content at C# Programming Youtube X LinkedIn Dev.to GitHub C# Programming

The 30-Day .NET Challenge - Day 29: Generics & Custom Interfaces

Twenty Thousand Leagues under the Sea by Jules Verne, is part of the HackerNoon Books Series. You can jump to any chapter in this book . ALL BY ELECTRICITY here CHAPTER XI: ALL BY ELECTRICITY “Sir,” said Captain Nemo, showing me the instruments hanging on the walls of his room, “here are the contrivances required for the navigation of the . Here, as in the drawing-room, I have them always under my eyes, and they indicate my position and exact direction in the middle of the ocean. Some are known to you, such as the thermometer, which gives the internal temperature of the the barometer, which indicates the weight of the air and foretells the changes of the weather; the hygrometer, which marks the dryness of the atmosphere; the storm-glass, the contents of which, by decomposing, announce the approach of tempests; the compass, which guides my course; the sextant, which shows the latitude by the altitude of the sun; chronometers, by which I calculate the longitude; and glasses for day and night, which I use to examine the points of the horizon, when the rises to the surface of the waves.” Nautilus Nautilus; Nautilus “These are the usual nautical instruments,” I replied, “and I know the use of them. But these others, no doubt, answer to the particular requirements of the . This dial with the movable needle is a manometer, is it not?” Nautilus “It is actually a manometer. But by communication with the water, whose external pressure it indicates, it gives our depth at the same time.” “And these other instruments, the use of which I cannot guess?” “Here, Professor, I ought to give you some explanations. Will you be kind enough to listen to me?” He was silent for a few moments, then he said— “There is a powerful agent, obedient, rapid, easy, which conforms to every use, and reigns supreme on board my vessel. Everything is done by means of it. It lights it, warms it, and is the soul of my mechanical apparatus. This agent is electricity.” “Electricity?” I cried in surprise. “Yes, sir.” “Nevertheless, Captain, you possess an extreme rapidity of movement, which does not agree with the power of electricity. Until now, its dynamic force has remained under restraint, and has only been able to produce a small amount of power.” “Professor,” said Captain Nemo, “my electricity is not everybody’s. You know what sea-water is composed of. In a thousand grammes are found 96½ per cent. of water, and about 2-2/3 per cent. of chloride of sodium; then, in a smaller quantity, chlorides of magnesium and of potassium, bromide of magnesium, sulphate of magnesia, sulphate and carbonate of lime. You see, then, that chloride of sodium forms a large part of it. So it is this sodium that I extract from sea-water, and of which I compose my ingredients. I owe all to the ocean; it produces electricity, and electricity gives heat, light, motion, and, in a word, life to the .” Nautilus “But not the air you breathe?” “Oh! I could manufacture the air necessary for my consumption, but it is useless, because I go up to the surface of the water when I please. However, if electricity does not furnish me with air to breathe, it works at least the powerful pumps that are stored in spacious reservoirs, and which enable me to prolong at need, and as long as I will, my stay in the depths of the sea. It gives a uniform and unintermittent light, which the sun does not. Now look at this clock; it is electrical, and goes with a regularity that defies the best chronometers. I have divided it into twenty-four hours, like the Italian clocks, because for me there is neither night nor day, sun nor moon, but only that factitious light that I take with me to the bottom of the sea. Look! just now, it is ten o’clock in the morning.” “Exactly.” “Another application of electricity. This dial hanging in front of us indicates the speed of the . An electric thread puts it in communication with the screw, and the needle indicates the real speed. Look! now we are spinning along with a uniform speed of fifteen miles an hour.” Nautilus “It is marvelous! And I see, Captain, you were right to make use of this agent that takes the place of wind, water, and steam.” “We have not finished, M. Aronnax,” said Captain Nemo, rising. “If you will follow me, we will examine the stern of the .” Nautilus Really, I knew already the anterior part of this submarine boat, of which this is the exact division, starting from the ship’s head:—the dining-room, five yards long, separated from the library by a water-tight partition; the library, five yards long; the large drawing-room, ten yards long, separated from the Captain’s room by a second water-tight partition; the said room, five yards in length; mine, two and a half yards; and, lastly a reservoir of air, seven and a half yards, that extended to the bows. Total length thirty five yards, or one hundred and five feet. The partitions had doors that were shut hermetically by means of india-rubber instruments, and they ensured the safety of the in case of a leak. Nautilus I followed Captain Nemo through the waist, and arrived at the centre of the boat. There was a sort of well that opened between two partitions. An iron ladder, fastened with an iron hook to the partition, led to the upper end. I asked the Captain what the ladder was used for. “It leads to the small boat,” he said. “What! have you a boat?” I exclaimed, in surprise. “Of course; an excellent vessel, light and insubmersible, that serves either as a fishing or as a pleasure boat.” “But then, when you wish to embark, you are obliged to come to the surface of the water?” “Not at all. This boat is attached to the upper part of the hull of the , and occupies a cavity made for it. It is decked, quite water-tight, and held together by solid bolts. This ladder leads to a man-hole made in the hull of the , that corresponds with a similar hole made in the side of the boat. By this double opening I get into the small vessel. They shut the one belonging to the I shut the other by means of screw pressure. I undo the bolts, and the little boat goes up to the surface of the sea with prodigious rapidity. I then open the panel of the bridge, carefully shut till then; I mast it, hoist my sail, take my oars, and I’m off.” Nautilus Nautilus Nautilus; “But how do you get back on board?” “I do not come back, M. Aronnax; the comes to me.” Nautilus “By your orders?” “By my orders. An electric thread connects us. I telegraph to it, and that is enough.” “Really,” I said, astonished at these marvels, “nothing can be more simple.” After having passed by the cage of the staircase that led to the platform, I saw a cabin six feet long, in which Conseil and Ned Land, enchanted with their repast, were devouring it with avidity. Then a door opened into a kitchen nine feet long, situated between the large storerooms. There electricity, better than gas itself, did all the cooking. The streams under the furnaces gave out to the sponges of platina a heat which was regularly kept up and distributed. They also heated a distilling apparatus, which, by evaporation, furnished excellent drinkable water. Near this kitchen was a bathroom comfortably furnished, with hot and cold water taps. Next to the kitchen was the berthroom of the vessel, sixteen feet long. But the door was shut, and I could not see the management of it, which might have given me an idea of the number of men employed on board the . Nautilus At the bottom was a fourth partition that separated this office from the engine-room. A door opened, and I found myself in the compartment where Captain Nemo—certainly an engineer of a very high order—had arranged his locomotive machinery. This engine-room, clearly lighted, did not measure less than sixty-five feet in length. It was divided into two parts; the first contained the materials for producing electricity, and the second the machinery that connected it with the screw. I examined it with great interest, in order to understand the machinery of the . Nautilus “You see,” said the Captain, “I use Bunsen’s contrivances, not Ruhmkorff’s. Those would not have been powerful enough. Bunsen’s are fewer in number, but strong and large, which experience proves to be the best. The electricity produced passes forward, where it works, by electro-magnets of great size, on a system of levers and cog-wheels that transmit the movement to the axle of the screw. This one, the diameter of which is nineteen feet, and the thread twenty-three feet, performs about a hundred and twenty revolutions in a second.” “And you get then?” “A speed of fifty miles an hour.” “I have seen the manœuvre before the , and I have my own ideas as to its speed. But this is not enough. We must see where we go. We must be able to direct it to the right, to the left, above, below. How do you get to the great depths, where you find an increasing resistance, which is rated by hundreds of atmospheres? How do you return to the surface of the ocean? And how do you maintain yourselves in the requisite medium? Am I asking too much?” Nautilus Abraham Lincoln “Not at all, Professor,” replied the Captain, with some hesitation; “since you may never leave this submarine boat. Come into the saloon, it is our usual study, and there you will learn all you want to know about the .” Nautilus About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jules Verne (1994). Twenty Thousand Leagues under the Sea. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/files/164/164-h/164-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

ALL BY ELECTRICITY

THE SLOE-WEEVIL

A step-by-step guide on how to create a React project from scratch with TypeScript and . Vite You can find the full source code here: https://github.com/alexadam/project-templates/tree/master/projects/react-app-vite Setup Prerequisites: node ( ) https://nodejs.org/en/download/ yarn ( ) https://yarnpkg.com/getting-started/install Create the project's folder: mkdir react-app
cd react-app Generate a default file with yarn: package.json yarn init -y Install React, TypeScript, and Vite: yarn add react react-dom

yarn add --dev @types/react \
        @types/react-dom \
        sass \
        typescript \
        @vitejs/plugin-react \
        vite Add build, dev, & clean scripts in the file: package.json ....
  },
  "scripts": {
    "clean": "rm -rf dist/*",
    "build": "vite --config vite.config.js build",
    "dev": "vite --config vite.config.js serve",
    "preview": "vite --config vite.config.js preview"
  } Configure TypeScript by creating the file with: tsconfig.json {
  "compilerOptions": {
    "incremental": true,
    "target": "es6",
    "module": "commonjs",
    "lib": ["dom", "dom.iterable", "es6"],
    "allowJs": true,
    "jsx": "react",
    "sourceMap": true,
    "outDir": "./dist/",
    "rootDir": ".",
    "removeComments": true,
    "strict": true,
    "moduleResolution": "node",            
    "allowSyntheticDefaultImports": true,
    "esModuleInterop": true,
    "experimentalDecorators": true
  },
  "include": [
    "./src"
  ],
  "exclude": [
    "./node_modules",
    "./build",
    "./dist"
  ]
} To configure Vite, make a file containing: vite.config.js import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react(
    {
      include: '**/*.{ts,js,tsx}',
    }
  )],
  base: '',
  root: 'src',
  build: {
    outDir: '../dist',
  },
  server: {
    port: 8080
  },
  preview: {
    port: 8080
  }
}) Example App Create a folder named (in the project's folder): src mkdir src
cd src Make a simple React component in the file : numbers.tsx import React, {useState} from 'react';

interface INumberProps {
  initValue: number
}

const Numbers = (props: INumberProps) => {
  const [value, setValue] = useState(props.initValue)

  const onIncrement = () => {
    setValue(value + 1)
  }

  const onDecrement = () => {
    setValue(value - 1)
  }

  return (
    <div>
      Number is {value}
        <div>
          <button onClick={onIncrement}>+</button>
          <button onClick={onDecrement}>-</button>
        </div>
    </div>
  )
}
export default Numbers Create the main React component (the entry point) in the file : app.tsx import * as React from 'react';
import ReactDOM from "react-dom/client";
import Numbers from './numbers';
import './app.scss'

const App = () => {

  return (
    <Numbers initValue={42} />
  )
}

const root = ReactDOM.createRoot(document.getElementById("app") as HTMLElement);
root.render(<App />); Next, add the : index.html <!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>React TypeScript</title>
</head>

<body>
  <div id="app"></div>
  <script type="module" src="./app.tsx"></script>
</body>

</html> Add some style in app.scss html,
body {
  width: 100%;
  height: 100%;
  margin: 0;
  padding: 0;
}

* {
  box-sizing: border-box;
}

#app {
  width: 100%;
  height: 100%;
  margin: 0;
  padding: 0;
} Then, run and open in a browser. yarn dev http://localhost:8080/ Use This Project as a Template You can save the steps as a shell script: Setup #!/bin/sh

rm -rf node_modules
rm -rf dist
rm -rf build
rm package.json
rm yarn.lock

yarn init --yes

yarn add react react-dom

yarn add --dev @types/react \
        @types/react-dom \
        sass \
        typescript \
        @vitejs/plugin-react \
        vite

# Remove the last line
sed -i.bak '$ d' package.json && rm package.json.bak

# append the scripts commads
cat <<EOT >> package.json
   ,"scripts": {
      "clean": "rm -rf dist/*",
      "build": "vite --config vite.config.js build",
      "dev": "vite --config vite.config.js serve",
      "preview": "vite --config vite.config.js preview"
   }
} Delete the folder, and, when you want to start a new project, you can copy the contents of to the new location: node-modules react-app mkdir new-project
cd new-project

# copy the react-app folder content to the new project
rsync -rtv /path/to/../react-app/ .

./init.sh

How to Create a React Project From Scratch With TypeScript and Vite

It's not new to anyone that has changed the way we ship software. The primary goal of using is containerization, and that is to have a consistent environment for your application and does not depend on the host machine where it runs. Docker Docker Also, is becoming a popular architectural choice for writing services. You can check this to get a glance of how to implement a service in . gRPC quick start gRPC Golang In this article, we'll see how to write and run a service with . We'll also cover a lot of cool and useful things, like: gRPC Docker How to compile files without the burden of installing locally; .proto protoc How we can easily use for parameterizing our application; environment variables How to write a so we end up with a small, optmized image; multistage build Docker How to easily invoke the service without having to manually write a client for it. gRPC Golang Let's go! The proposed application We'll write a service that is used to retrieve a number of random poetries. In order to achieve that, we'll use , an awesome free API for internet poets. gRPC PoetryDB We can see a simple to show how it will work: sequence diagram Protobuf Here's our file where we define the service, 'poetry.proto': .proto syntax = "proto3"


package proto;
option go_package = "bitbucket.org/tiagoharris/docker-grpc-service-tutorial/proto/poetry";


message Poetry {
    string title = 1;
    string author = 2;
    repeated string lines = 3;
    int32 linecount = 4;
}


message RandomPoetriesRequest {
    int32 number_of_poetries = 1;
}


message PoetryList {
    repeated Poetry list = 1;
}


service ProtobufService {
    rpc RandomPoetries(RandomPoetriesRequest) returns (PoetryList);
} Now we need to compile it in order to have: Code for populating, serializing, and retrieving 'RandomPoetriesRequest' and 'PoetryList' message types; Generated client and server code. We compile it using . Generally we would need to install it, but a better idea would be to use a image that has installed, pretty much similar to what we do when we want to use for example; instead of installing it, we could use a image for it. protoc Docker protoc MySQL Docker And is exactly what we need. docker-protoc Here's our Makefile target that we use to invoke it so we compile the file: .proto .PHONY: proto
## proto: compiles .proto files
proto:
    @ docker run -v $(PWD):/defs namely/protoc-all -f proto/poetry.proto -l 
go -o . --go-source-relative The '--go-source-relative' option is to keep the generated 'poetry.pb.go' file at the same folder of our file 'poetry.proto'. .proto When you call it for the first time, it will download 'namely/protoc-all:latest' image and then will compile our file: Docker .proto $ make proto
Unable to find image 'namely/protoc-all:latest' locally
latest: Pulling from namely/protoc-all
72a69066d2fe: Pull complete 
92b40fad93be: Pull complete 
6c681a0a5896: Pull complete 
ebc1d0ae2fce: Pull complete 
8419d9b6e1d6: Pull complete 
bea3673d63cb: Pull complete 
c4795970891a: Pull complete 
a07bfba13570: Pull complete 
390910a84268: Pull complete 
3b0c06e97c77: Pull complete 
02fad91bea96: Pull complete 
784aa2673488: Pull complete 
c5446e8648ec: Pull complete 
f3170de720de: Pull complete 
dbd0d73172b5: Pull complete 
3516e04721f7: Pull complete 
b91f69a87fb4: Pull complete 
37490bcef5e6: Pull complete 
fd5de9fd6a61: Pull complete 
35f2a04b2c22: Pull complete 
075200f557a8: Pull complete 
017c387ae8e9: Pull complete 
Digest: sha256:5406210e1dc68ffe4f36fa1ee98214bb50614d3a44428bf33ffca427079dd3d2
Status: Downloaded newer image for namely/protoc-all:latest Reading environment variables Before implementing our service, let's make an engineering decision about parameterizing the application. A good idea would be to parameterize the base for , as well as how many seconds we want to wait until an HTTP timeout occur. So how can we achieve that in a safe, clean way? gRPC URL PoetryDB Using is a common technique, right? A good solution would be: environment variables Defining the variables in some sort of file; Reading this file and exporting those values as ; environment variables Get those into a so we can easily use them. environment variables struct Godotenv is a package that solves the two bullet points defined above. We define our variables in an '.env' file and then we invoke it to export all those values as . Godotenv Golang environment variables Here's our 'config.env' file: POETRYDB_BASE_URL=https://poetrydb.org
POETRYDB_HTTP_TIMEOUT=10 Envconfig is a package that solves the last bullet point: it encapsulates that are correctly exported into a . Envconfig Golang environment variables struct Here's 'configreader/config_reader.go', which we use to get a configuration fulfilled with : struct environment variables // Copyright (c) 2022 Tiago Melo. All rights reserved.
// Use of this source code is governed by the MIT License that can be found in
// the LICENSE file.


package configreader


import (
    "github.com/joho/godotenv"
    "github.com/kelseyhightower/envconfig"
    "github.com/pkg/errors"
)


// These global variables makes it easy
// to mock these dependencies
// in unit tests.
var (
    godotenvLoad     = godotenv.Load
    envconfigProcess = envconfig.Process
)


// GoDotEnv is an interface that defines
// the functions we use from godotenv package.
// It enables mocking this dependency in unit testing.
type GoDotEnv interface {
    Load(filenames ...string) (err error)
}


// EnvConfig is an interface that defines
// the functions we use from envconfig package.
// It enables mocking this dependency in unit testing.
type EnvConfig interface {
    Process(prefix string, spec interface{}) error
}


// Config holds configuration data.
type Config struct {
    PoetrydbBaseUrl     string `envconfig:"POETRYDB_BASE_URL" required:"true"`
    PoetrydbHttpTimeout int    `envconfig:"POETRYDB_HTTP_TIMEOUT" required:"true"`
}


// ReadEnv reads envionment variables into Config struct.
func ReadEnv() (*Config, error) {
    err := godotenvLoad("configreader/config.env")
    if err != nil {
        return nil, errors.Wrap(err, "reading .env file")
    }
    var config Config
    err = envconfigProcess("", &config)
    if err != nil {
        return nil, errors.Wrap(err, "processing env vars")
    }
    return &config, nil
} gRPC service implementation Now that we compiled our file 'poetry.proto', we'll write a server that implements the service defined in 'poetry.pb.go': .proto gRPC // Copyright (c) 2022 Tiago Melo. All rights reserved.
// Use of this source code is governed by the MIT License that can be found in
// the LICENSE file.


package server


import (
    "context"
    "encoding/json"
    "fmt"
    "net"


    "bitbucket.org/tiagoharris/docker-grpc-service-tutorial/configreader"
    "bitbucket.org/tiagoharris/docker-grpc-service-tutorial/poetrydb"
    poetry "bitbucket.org/tiagoharris/docker-grpc-service-tutorial/proto"
    "github.com/pkg/errors"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
    "google.golang.org/protobuf/encoding/protojson"
)


// These global variables makes it easy
// to mock these dependencies
// in unit tests.
var (
    netListen           = net.Listen
    configreaderReadEnv = configreader.ReadEnv
    jsonMarshal         = json.Marshal
    protojsonUnmarshal  = protojson.Unmarshal
)


// Server defines the available operations for gRPC server.
type Server interface {
    // Serve is called for serving requests.
    Serve() error
    // GracefulStop is called for stopping the server.
    GracefulStop()
    // RandomPoetries returns a random list of poetries.
    RandomPoetries(ctx context.Context, in *poetry.RandomPoetriesRequest) (*poetry.PoetryList, error)
}


// server implements Server.
type server struct {
    listener   net.Listener
    grpcServer *grpc.Server
    poetryDb   poetrydb.PoetryDb
}


func (s *server) Serve() error {
    return s.grpcServer.Serve(s.listener)
}


func (s *server) GracefulStop() {
    s.grpcServer.GracefulStop()
}


// NewServer creates a new gRPC server.
func NewServer(port int) (Server, error) {
    server := new(server)
    listener, err := netListen("tcp", fmt.Sprintf(":%d", port))
    if err != nil {
        return server, errors.Wrap(err, "tcp listening")
    }
    server.listener = listener
    config, err := configreaderReadEnv()
    if err != nil {
        return server, errors.Wrap(err, "reading env vars")
    }
    server.poetryDb = poetrydb.NewPoetryDb(config.PoetrydbBaseUrl, config.PoetrydbHttpTimeout)
    server.grpcServer = grpc.NewServer()
    poetry.RegisterProtobufServiceServer(server.grpcServer, server)
    reflection.Register(server.grpcServer)
    return server, nil
}


func (s *server) RandomPoetries(ctx context.Context, in *poetry.RandomPoetriesRequest) (*poetry.PoetryList, error) {
    pbPoetryList := new(poetry.PoetryList)
    poetryList, err := s.poetryDb.Random(int(in.NumberOfPoetries))
    if err != nil {
        return pbPoetryList, errors.Wrap(err, "requesting random poetry")
    }
    json, err := jsonMarshal(poetryList)
    if err != nil {
        return pbPoetryList, errors.Wrap(err, "marshalling json")
    }
    err = protojsonUnmarshal(json, pbPoetryList)
    if err != nil {
        return pbPoetryList, errors.Wrap(err, "unmarshalling proto")
    }
    return pbPoetryList, nil
} Running it Here's the related targets in to run the server: Makefile .PHONY: build
## build: builds server's binary
build:
    @ go build -a -installsuffix cgo -o main .


.PHONY: run
## run: runs the server
run: build
    @ ./main So let's run the server: $ make run
GRPC SERVER : 2022/03/21 10:07:14.846821 main.go:19: main: Initializing GRPC server
GRPC SERVER : 2022/03/21 10:07:14.847286 main.go:32: main: GRPC server listening on port 4040 Invoking the gRPC service Now the cool part: what if we wanted a nice, clean tool like (used to test APIs) to makes it easy to call services? Postman REST gRPC is here to help. You just browse your files and you'll be ready to invoke it: Bloomrpc .proto And here you go. We've asked one random poetry, and now we can appreciate it. Time to Dockerize it! Now that our app is working, let's bake a image for it. Docker Here's our : Dockerfile FROM golang:alpine


# Install git and ca-certificates (needed to be able to call HTTPS)
RUN apk --update add ca-certificates git


# Move to working directory /app
WORKDIR /app


# Copy the code into the container
COPY . .


# Download dependencies using go mod
RUN go mod download


# Build the application's binary
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main .


# Command to run the application when starting the container
CMD ["/app/main"] Notice: we're installing git because tooling uses it, otherwise we would get an error "go: missing Git command. See https://golang.org/s/gogetcmd"; Golang we're installing 'ca-certificates' because uses , otherwise we would get an error "certificate signed by unknown authority". PoetryDB HTTPS Building the image Now let's build it. Here's the target: Makefile .PHONY: build-docker-image
## build-docker-image: builds the docker image
build-docker-image:
    @ docker build . -t docker-grpc-service-tutorial Invoking it: $ make build-docker-image
Sending build context to Docker daemon  13.71MB
Step 1/7 : FROM golang:alpine
 ---> 0e3b02146c47
Step 2/7 : RUN apk --update add ca-certificates git
 ---> Using cache
 ---> c326d9aa8cfc
Step 3/7 : WORKDIR /app
 ---> Using cache
 ---> 6c485ff6b69d
Step 4/7 : COPY . .
 ---> 9af131a39537
Step 5/7 : RUN go mod download
 ---> Running in a644255b6578
Removing intermediate container a644255b6578
 ---> 3b43ba797d11
Step 6/7 : RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main .
 ---> Running in 01b6ce6172a9
Removing intermediate container 01b6ce6172a9
 ---> b1eaebffb306
Step 7/7 : CMD ["/app/main"]
 ---> Running in e0ed88e2a687
Removing intermediate container e0ed88e2a687
 ---> edb7869f01a6
Successfully built edb7869f01a6
Successfully tagged docker-grpc-service-tutorial:latest


Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them Running it as a Docker container Here's the target: Makefile .PHONY: build-docker-image
## build-docker-image: builds the docker image
build-docker-image:
    @ docker build . -t docker-grpc-service-tutorial


.PHONY: run-docker
## run-docker: runs the server as a Docker container
run-docker: build-docker-image
    @ docker run -p 4040:4040 docker-grpc-service-tutorial Invoking it: $ make run-docker
Sending build context to Docker daemon  13.71MB
Step 1/7 : FROM golang:alpine
 ---> 0e3b02146c47
Step 2/7 : RUN apk --update add ca-certificates git
 ---> Using cache
 ---> c326d9aa8cfc
Step 3/7 : WORKDIR /app
 ---> Using cache
 ---> 6c485ff6b69d
Step 4/7 : COPY . .
 ---> 95f88bbbc63e
Step 5/7 : RUN go mod download
 ---> Running in 227656a7a691
Removing intermediate container 227656a7a691
 ---> b6765354b254
Step 6/7 : RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main .
 ---> Running in a8e881248c52
Removing intermediate container a8e881248c52
 ---> a05de0412553
Step 7/7 : CMD ["/app/main"]
 ---> Running in e0009bc99088
Removing intermediate container e0009bc99088
 ---> 351069eab03d
Successfully built 351069eab03d
Successfully tagged docker-grpc-service-tutorial:latest


Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
GRPC SERVER : 2022/03/21 13:30:18.404250 main.go:19: main: Initializing GRPC server
GRPC SERVER : 2022/03/21 13:30:18.404646 main.go:32: main: GRPC server listening on port 4040 And then you can invoke the service via like we did before. Bloomrpc Multistage build One of 's best practice is keeping the image size small, by having only the binary file then we make our image even smaller from the previous one. To achieve this we will use a technique called which means we will build our image with multiple steps. Docker multistage build Here's our .multistage: Dockerfile FROM golang:alpine AS builder


# Install git and ca-certificates (needed to be able to call HTTPS)
RUN apk --update add ca-certificates git


# Move to working directory /app
WORKDIR /app


# Copy the code into the container
COPY . .


# Download dependencies using go mod
RUN go mod download


# Build the application's binary
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main .


# Build a smaller image that will only contain the application's binary
FROM scratch


# Move to working directory /app
WORKDIR /app


# Copy certificates
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt


# Copy application's binary
COPY --from=builder /app .


# Command to run the application when starting the container
CMD ["./main"] Here are the targets: Makefile .PHONY: build-docker-image-multistage
## build-docker-image-multistage: builds a smaller docker image
build-docker-image-multistage:
    @ docker build -f Dockerfile.multistage  . -t docker-grpc-service-tutorial


.PHONY: run-docker-multistage
## run-docker-multistage: runs the server as a Docker container, using the smaller image
run-docker-multistage: build-docker-image-multistage
    @ docker run -p 4040:4040 docker-grpc-service-tutorial Notice that we can name whatever we want it, as long as we speficy if via '-f' flag. Dockerfile Invoking it: $ make run-docker-multistage
Sending build context to Docker daemon  13.71MB
Step 1/11 : FROM golang:alpine AS builder
 ---> 0e3b02146c47
Step 2/11 : RUN apk --update add ca-certificates git
 ---> Using cache
 ---> c326d9aa8cfc
Step 3/11 : WORKDIR /app
 ---> Using cache
 ---> 6c485ff6b69d
Step 4/11 : COPY . .
 ---> 8be509098958
Step 5/11 : RUN go mod download
 ---> Running in 776490901c8e
Removing intermediate container 776490901c8e
 ---> ec0d94130a65
Step 6/11 : RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o main .
 ---> Running in fa2e87f052ad
Removing intermediate container fa2e87f052ad
 ---> 57680526aaa1
Step 7/11 : FROM scratch
 ---> 
Step 8/11 : WORKDIR /app
 ---> Running in 0cc6905bb002
Removing intermediate container 0cc6905bb002
 ---> e41a9cb16982
Step 9/11 : COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 ---> 8429312feec5
Step 10/11 : COPY --from=builder /app .
 ---> 3d1c20349d38
Step 11/11 : CMD ["./main"]
 ---> Running in a4a88a400a96
Removing intermediate container a4a88a400a96
 ---> 0d27b2b85769
Successfully built 0d27b2b85769
Successfully tagged docker-grpc-service-tutorial:latest


Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
GRPC SERVER : 2022/03/21 13:37:50.456686 main.go:19: main: Initializing GRPC server
GRPC SERVER : 2022/03/21 13:37:50.457085 main.go:32: main: GRPC server listening on port 4040 And then you can invoke the service via like we did before. Bloomrpc Conclusion In this article, we've covered a lot of nice things when building a service in from scratch: gRPC Golang How to read into a so we can easily use them; environment variables struct How to delegate to an external image to compile our files; Docker .proto How to easily invoke service via ; gRPC Bloomrpc How to create a image using . Docker multistage build Download the source Here: https://bitbucket.org/tiagoharris/docker-grpc-service-tutorial/src/master/ Also Published Here

Running a gRPC Service with Docker

The Idea of a University Defined and Illustrated: Lecture IV - Elementary Studies

A step-by-step guide on how to create a React project from scratch, with TypeScript and Webpack. You can find the full source code . here Setup Prerequisites: node yarn Create the project's folder: mkdir react-app
cd react-app Generate a default file with yarn: package.json yarn init -y Install React, TypeScript and Webpack: yarn add react react-dom

yarn add --dev @types/react \
        @types/react-dom \
        awesome-typescript-loader \
        css-loader \
        html-webpack-plugin \
        node-sass \
        sass-loader \
        style-loader \
        typescript \
        webpack \
        webpack-cli \
        webpack-dev-server Add build, dev & clean scripts in the file: package.json ....
  }, : { : , : , : } "scripts" "clean" "rm -rf dist/*" "build" "webpack" "dev" "webpack serve" Configure TypeScript by creating the file with: tsconfig.json { : { : , : , : , : [ , , ], : , : , : , : , : , : , : , : , : , : , : }, : [ ], : [ , , ]
} "compilerOptions" "incremental" true "target" "es5" "module" "commonjs" "lib" "dom" "dom.iterable" "es6" "allowJs" true "jsx" "react" "sourceMap" true "outDir" "./dist/" "rootDir" "." "removeComments" true "strict" true "moduleResolution" "node" "allowSyntheticDefaultImports" true "esModuleInterop" true "experimentalDecorators" true "include" "client" "exclude" "node_modules" "build" "dist" To configure Webpack, make a file containing: webpack.config.js path = ( ); app_dir = __dirname + ; HtmlWebpackPlugin = ( ); HTMLWebpackPluginConfig = HtmlWebpackPlugin({ : app_dir + , : , : }); config = { : , : app_dir + , : { : __dirname + , : , : }, : { : [{ : , : [ , , ]
      }, { : , : , : },
      { : , : [ ], : },
      { : , : [ ], : },
      { : , : [ ], : , : { : ,
        },
      },
    ]
  }, : [HTMLWebpackPluginConfig], : { : [ , , , ]
  }, : { : , : , : ,
  }, : { : , hot: , : , : ,
  },
}; .exports = config; const require "path" const '/client' const require 'html-webpack-plugin' const new template '/index.html' filename 'index.html' inject 'body' const mode 'development' entry '/app.tsx' output path '/dist' filename 'app.js' publicPath '/' module rules test /\.s?css$/ use 'style-loader' 'css-loader' 'sass-loader' test /\.tsx?$/ loader "awesome-typescript-loader" exclude /(node_modules|bower_components)/ test /\.(woff|woff2|ttf|eot)(\?v=[0-9]\.[0-9]\.[0-9])?$/ exclude /node_modules/ loader "file-loader" test /\.(jpe?g|png|gif|svg)$/i exclude /node_modules/ loader "file-loader" test /\.(pdf)$/i exclude /node_modules/ loader "file-loader" options name '[name].[ext]' plugins resolve extensions ".ts" ".tsx" ".js" ".jsx" optimization removeAvailableModules false removeEmptyChunks false splitChunks false devServer port 8080 // open: true, true inline true historyApiFallback true module Example App Create a folder named (in the project's folder): client mkdir client
cd client Make a simple React component, in the file : numbers.tsx React, {useState} ;

interface INumberProps { : number
} Numbers = { [value, setValue] = useState(props.initValue) onIncrement = {
    setValue(value + )
  } onDecrement = {
    setValue(value - )
  } ( <div>
          <button onClick={onIncrement}>+</button>
          <button onClick={onDecrement}>-</button>
        </div> )
} Numbers import from 'react' initValue const ( ) => props: INumberProps const const => () 1 const => () 1 return Number is {value} < > div </ > div export default Create the main React component (the entry point), in the file : app.tsx * React ; * ReactDOM ; Numbers ;

ReactDOM.render( import as from 'react' import as from 'react-dom' import from './numbers' ,
    document.getElementById('app') as HTMLElement
  ); < = /> Numbers initValue {42} Next, add the : index.html <!DOCTYPE html> <head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>React TypeScript</title>
</head>

<body>
  <div id="app"></div>
</body>
</html> < > html Then, run yarn dev and open in a browser. http://localhost:8080/ Use this project as a template You can save the steps as a shell script Setup rm -rf node_modules
rm package.json

yarn init --yes

yarn add react react-dom

yarn add --dev @types/react \
        @types/react-dom \
        awesome-typescript-loader \
        css-loader \
        html-webpack-plugin \
        node-sass \
        sass-loader \
        style-loader \
        typescript \
        webpack \
        webpack-cli \
        webpack-dev-server

# Remove the last line
sed -i.bak package.json && rm package.json.bak

# append the scripts commads
cat <<EOT >> package.json
   , : { : , : , : }
} #!/bin/sh '$ d' "scripts" "clean" "rm -rf dist/*" "build" "webpack" "dev" "webpack serve" Delete the folder and, when you want to start a new project, you can copy the contents of to the new location: node-modules react-app mkdir -project
cd -project

# copy the react-app folder content to the project
rsync -rtv /path/to/../react-app/ .

./init.sh new new new Previously published at https://alexadam.dev/blog/create-react-project.html

INHUBBER

inhubber.com

-- employees

Since n.d.

COMPANY RANKING

INHUBBER

EVERGREEN INDEX #6255

INHUBBER WIKI

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

INHUBBER

inhubber.com

-- employees

Since n.d.

COMPANY RANKING

INHUBBER

EVERGREEN INDEX #6255

RELATED COMPANIESRANK

STORIES ABOUT INHUBBER

INHUBBER WIKI

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