However, the company did not meet its projections and saw its stock drop slightly.

Textron Aviation Records Over $1 Billion In Revenue During The First Quarter Of 2024

The US Marine Corps has picked General Dynamics Land Systems and <strong>Textron</strong> Systems Corporation for the Advanced Reconnaissance Vehicle 30mm autocannon prototype contract.

US Marines Select General Dynamics, Textron to Build New Recon Vehicle

Regarding business jets (bizjet), the 2024 forecast suggests continued robust Aviation volumes, the analysts added. Moreover, <strong>Textron</strong> concluded the year with a book-to-bill (BTB) ratio of 1.15x, surpassing its 2023 goal of 1.0x.

BofA upgrades Textron to Buy on undervaluation and strong bizjet demand By Investing.com

, Icarus Aerospace and <strong>Textron</strong> Systems unveiled a strategic alliance aimed at the expansion of non-military integration of advanced aerial technology.

Textron Systems and Icarus Aerospace Enter Strategic Partnership | Commercial UAV News

<strong>Textron</strong> Inc (TXT) receives a strong valuation score of 86 from InvestorsOb

Is Textron Inc (TXT) Stock Over or Undervalued?

Shares of <strong>Textron</strong> Inc. inched 0.80% higher to $89.39 Monday, on what proved to be an all-around rough trading session for the stock market, with the S&amp;P 500...

Textron Inc. stock outperforms competitors on strong trading day - MarketWatch

The death of Bristol pilot William O’Leary in the 2021 Cessna crash was "entirely preventable and should not have occurred," his children claim in a lawsuit.

Children of CT pilot who was among 4 killed in Farmington plane crash file wrongful death lawsuit

The Global Ultralight and Light Aircraft Market is projected to grow at a CAGR of 7.51% from 2023 to 2030, according to a new report

Ultralight and Light Aircraft Market size worth $ 10.99 Billion, Globally, by 2030 at 7.51% CAGR: Verified Market Research®

Wake Tech president and Elizabeth City State University chancellor both believe this to be a great learning and recruitment tool for their respective schools.

Wake Tech, ECSU launch aviation and drone partnership

Textron's quarterly results showed revenue growth and outperformed analyst estimates despite supply chain challenges. Find out why TXT stock is a Buy.

Textron Stock Can Soar With Robust Shareholder Returns

Textron

textron

Ensuring Reproducibility in AI Research: Code and Pre-trained Weights Open-Sourced

The motivation for writing this article is to provide clear instructions on how to create a file upload that looks attractive. The native button looks very minimalistic, but it can be improved. Unfortunately, there is no browser API that allows you to open the upload dialog without the input tag, so let's clarify how to do this. Pure JS - so it can be adapted to any framework;
No native upload button - we want custom button instead
Accessibility - strong trend of last several years Let’s Make a Pretty Button As I mentioned earlier, we still need to render an input with type="file" to support the browser API. Since we don’t want it to be visible, let’s hide it. Here’s a code example in pure HTML/CSS/JS: <body>
    <style>
        main {
            width: 100%;
            height: 800px;
            display: flex;
            justify-content: center;
            align-items: center;
        }
        .file-upload {
            display: flex;
            flex-direction: column;
            gap: 15px;
        }
        input.file-upload__input[type="file"] {
            display: none;
        }

        /* custom styles to make button pretty */
        .file-upload__button {
            position: relative;
            display: inline-block;
            padding: 12px 24px;
            font-size: 16px;
            font-weight: 600;
            text-align: center;
            color: white;
            background-color: #007BFF;
            border: none;
            border-radius: 50px;
            cursor: pointer;
            transition: background-color 0.3s ease, transform 0.2s ease;
            box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
            overflow: hidden;
        }
        .file-upload__button:hover {
            background-color: #0056b3;
            transform: translateY(-2px);
        }
        .file-upload__button:focus {
            outline: 2px solid #0056b3;
        }

        /* Styles for displaying uploaded file information */
        .file-info {
            font-size: 14px;
            color: #333;
            display: inline-flex;
        }

        /* Styles for the small delete button */
        .delete-button {
            background-color: transparent;
            color: #dc3545;
            font-size: 18px;
            border: none;
            margin-left: 10px;
            cursor: pointer;
            display: none; /* Initially hidden */
        }
        .delete-button:focus {
            outline: none;
        }

        .delete-button:hover {
            color: #c82333;
        }
    </style>

    <main>
        <section id="home">
            <div class="file-upload">
                <label for="file-upload-input" id="file-upload-label">Select a file</label>
                <button class="file-upload__button" aria-labelledby="file-upload-label" onclick="handleUploadClick(this)">
                    Press to upload
                    <input type="file" name="photo" id="file-upload-input" class="file-upload__input" onchange="handleFileChange(event)" aria-describedby="file-info" />
                </button>
                <div class="file-upload__uploaded">
                    
                    <div id="file-info" class="file-info" role="status" aria-live="polite">
                        No file selected
                    </div>
                    
                    <button id="delete-button" class="delete-button" aria-label="delete uploaded file" onclick="deleteFile()">-</button>
                </div>
            </div>
        </section>
    </main>

    <script>
        // Function to simulate clicking on the hidden input
        function handleUploadClick(button) {
            const fileInput = button.querySelector('input[type="file"]');
            fileInput.click();
        }

        // Function to handle the file change event
        function handleFileChange(event) {
            const fileInfo = document.getElementById('file-info');
            const file = event.target.files[0];
            const deleteButton = document.getElementById('delete-button');

            // Check if a file is selected and update the accessible status
            if (file) {
                fileInfo.textContent = `Selected file: ${file.name}`;
                deleteButton.style.display = 'inline-block'; // Show the delete button
            } else {
                fileInfo.textContent = 'No file selected';
                deleteButton.style.display = 'none'; // Hide the delete button
            }
        }

        // Function to delete the uploaded file
        function deleteFile() {
            const fileInput = document.getElementById('file-upload-input');
            const fileInfo = document.getElementById('file-info');
            const deleteButton = document.getElementById('delete-button');

            // Reset file input
            fileInput.value = '';

            // Update file info and hide delete button
            fileInfo.textContent = 'No file selected';
            deleteButton.style.display = 'none'; // Hide the delete button
        }
    </script>
</body> Important Details Use semantic HTML tags. This will help readers understand the job better;
For uploaded files, use role="status" and aria-live="polite". This way, the file upload message is accessible to users;
Adding a trash icon with an aria-label helps screen readers identify its purpose, making the button more accessible;
Using aria-describedby lets screen readers read content from another element, providing extra details about the component. Screenshot for new button Conclusion With the above implementation, you can create an accessible and customizable file upload button. The design ensures the button looks good while maintaining accessibility standards. The code and explanation should now be easier to read with corrected spelling and syntax. The motivation for writing this article is to provide clear instructions on how to create a file upload that looks attractive. The native button looks very minimalistic, but it can be improved. Unfortunately, there is no browser API that allows you to open the upload dialog without the input tag, so let's clarify how to do this. Pure JS - so it can be adapted to any framework; No native upload button - we want custom button instead Accessibility - strong trend of last several years Pure JS - so it can be adapted to any framework; Pure JS No native upload button - we want custom button instead No native upload button Accessibility - strong trend of last several years Accessibility Let’s Make a Pretty Button As I mentioned earlier, we still need to render an input with type="file" to support the browser API. Since we don’t want it to be visible, let’s hide it. Here’s a code example in pure HTML/CSS/JS: <body>
    <style>
        main {
            width: 100%;
            height: 800px;
            display: flex;
            justify-content: center;
            align-items: center;
        }
        .file-upload {
            display: flex;
            flex-direction: column;
            gap: 15px;
        }
        input.file-upload__input[type="file"] {
            display: none;
        }

        /* custom styles to make button pretty */
        .file-upload__button {
            position: relative;
            display: inline-block;
            padding: 12px 24px;
            font-size: 16px;
            font-weight: 600;
            text-align: center;
            color: white;
            background-color: #007BFF;
            border: none;
            border-radius: 50px;
            cursor: pointer;
            transition: background-color 0.3s ease, transform 0.2s ease;
            box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
            overflow: hidden;
        }
        .file-upload__button:hover {
            background-color: #0056b3;
            transform: translateY(-2px);
        }
        .file-upload__button:focus {
            outline: 2px solid #0056b3;
        }

        /* Styles for displaying uploaded file information */
        .file-info {
            font-size: 14px;
            color: #333;
            display: inline-flex;
        }

        /* Styles for the small delete button */
        .delete-button {
            background-color: transparent;
            color: #dc3545;
            font-size: 18px;
            border: none;
            margin-left: 10px;
            cursor: pointer;
            display: none; /* Initially hidden */
        }
        .delete-button:focus {
            outline: none;
        }

        .delete-button:hover {
            color: #c82333;
        }
    </style>

    <main>
        <section id="home">
            <div class="file-upload">
                <label for="file-upload-input" id="file-upload-label">Select a file</label>
                <button class="file-upload__button" aria-labelledby="file-upload-label" onclick="handleUploadClick(this)">
                    Press to upload
                    <input type="file" name="photo" id="file-upload-input" class="file-upload__input" onchange="handleFileChange(event)" aria-describedby="file-info" />
                </button>
                <div class="file-upload__uploaded">
                    
                    <div id="file-info" class="file-info" role="status" aria-live="polite">
                        No file selected
                    </div>
                    
                    <button id="delete-button" class="delete-button" aria-label="delete uploaded file" onclick="deleteFile()">-</button>
                </div>
            </div>
        </section>
    </main>

    <script>
        // Function to simulate clicking on the hidden input
        function handleUploadClick(button) {
            const fileInput = button.querySelector('input[type="file"]');
            fileInput.click();
        }

        // Function to handle the file change event
        function handleFileChange(event) {
            const fileInfo = document.getElementById('file-info');
            const file = event.target.files[0];
            const deleteButton = document.getElementById('delete-button');

            // Check if a file is selected and update the accessible status
            if (file) {
                fileInfo.textContent = `Selected file: ${file.name}`;
                deleteButton.style.display = 'inline-block'; // Show the delete button
            } else {
                fileInfo.textContent = 'No file selected';
                deleteButton.style.display = 'none'; // Hide the delete button
            }
        }

        // Function to delete the uploaded file
        function deleteFile() {
            const fileInput = document.getElementById('file-upload-input');
            const fileInfo = document.getElementById('file-info');
            const deleteButton = document.getElementById('delete-button');

            // Reset file input
            fileInput.value = '';

            // Update file info and hide delete button
            fileInfo.textContent = 'No file selected';
            deleteButton.style.display = 'none'; // Hide the delete button
        }
    </script>
</body> <body>
    <style>
        main {
            width: 100%;
            height: 800px;
            display: flex;
            justify-content: center;
            align-items: center;
        }
        .file-upload {
            display: flex;
            flex-direction: column;
            gap: 15px;
        }
        input.file-upload__input[type="file"] {
            display: none;
        }

        /* custom styles to make button pretty */
        .file-upload__button {
            position: relative;
            display: inline-block;
            padding: 12px 24px;
            font-size: 16px;
            font-weight: 600;
            text-align: center;
            color: white;
            background-color: #007BFF;
            border: none;
            border-radius: 50px;
            cursor: pointer;
            transition: background-color 0.3s ease, transform 0.2s ease;
            box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
            overflow: hidden;
        }
        .file-upload__button:hover {
            background-color: #0056b3;
            transform: translateY(-2px);
        }
        .file-upload__button:focus {
            outline: 2px solid #0056b3;
        }

        /* Styles for displaying uploaded file information */
        .file-info {
            font-size: 14px;
            color: #333;
            display: inline-flex;
        }

        /* Styles for the small delete button */
        .delete-button {
            background-color: transparent;
            color: #dc3545;
            font-size: 18px;
            border: none;
            margin-left: 10px;
            cursor: pointer;
            display: none; /* Initially hidden */
        }
        .delete-button:focus {
            outline: none;
        }

        .delete-button:hover {
            color: #c82333;
        }
    </style>

    <main>
        <section id="home">
            <div class="file-upload">
                <label for="file-upload-input" id="file-upload-label">Select a file</label>
                <button class="file-upload__button" aria-labelledby="file-upload-label" onclick="handleUploadClick(this)">
                    Press to upload
                    <input type="file" name="photo" id="file-upload-input" class="file-upload__input" onchange="handleFileChange(event)" aria-describedby="file-info" />
                </button>
                <div class="file-upload__uploaded">
                    
                    <div id="file-info" class="file-info" role="status" aria-live="polite">
                        No file selected
                    </div>
                    
                    <button id="delete-button" class="delete-button" aria-label="delete uploaded file" onclick="deleteFile()">-</button>
                </div>
            </div>
        </section>
    </main>

    <script>
        // Function to simulate clicking on the hidden input
        function handleUploadClick(button) {
            const fileInput = button.querySelector('input[type="file"]');
            fileInput.click();
        }

        // Function to handle the file change event
        function handleFileChange(event) {
            const fileInfo = document.getElementById('file-info');
            const file = event.target.files[0];
            const deleteButton = document.getElementById('delete-button');

            // Check if a file is selected and update the accessible status
            if (file) {
                fileInfo.textContent = `Selected file: ${file.name}`;
                deleteButton.style.display = 'inline-block'; // Show the delete button
            } else {
                fileInfo.textContent = 'No file selected';
                deleteButton.style.display = 'none'; // Hide the delete button
            }
        }

        // Function to delete the uploaded file
        function deleteFile() {
            const fileInput = document.getElementById('file-upload-input');
            const fileInfo = document.getElementById('file-info');
            const deleteButton = document.getElementById('delete-button');

            // Reset file input
            fileInput.value = '';

            // Update file info and hide delete button
            fileInfo.textContent = 'No file selected';
            deleteButton.style.display = 'none'; // Hide the delete button
        }
    </script>
</body> Important Details Use semantic HTML tags. This will help readers understand the job better; For uploaded files, use role="status" and aria-live="polite". This way, the file upload message is accessible to users; Adding a trash icon with an aria-label helps screen readers identify its purpose, making the button more accessible; Using aria-describedby lets screen readers read content from another element, providing extra details about the component. Use semantic HTML tags. This will help readers understand the job better; For uploaded files, use role="status" and aria-live="polite". This way, the file upload message is accessible to users; Adding a trash icon with an aria-label helps screen readers identify its purpose, making the button more accessible; Using aria-describedby lets screen readers read content from another element, providing extra details about the component. Screenshot for new button Conclusion With the above implementation, you can create an accessible and customizable file upload button. The design ensures the button looks good while maintaining accessibility standards. The code and explanation should now be easier to read with corrected spelling and syntax.

Accessible Custom File Upload

In-Depth Guide to Working with Strings in Rust

This is a simple gRPC communication between a web client and server with an Envoy proxy. I’m using the gRPC-Web library for this. gRPC-Web is a JavaScript client library that allows web applications to talk to gRPC services. Since browsers don’t support HTTP/2 or the binary protocol used by standard gRPC, gRPC-Web provides a way to bridge the gap by using HTTP/1.1 or HTTP/2 and encoding gRPC messages in a way that browsers can handle. Here’s how gRPC-Web works: 1- The client sends requests to the server using gRPC-Web, which typically uses HTTP/1.1 or HTTP/2. Metadata (like headers) can be attached to the request, such as for authentication (e.g., JWT tokens). The request is encoded in gRPC-Web format, typically using base64 encoding for the binary gRPC payload. The client sends this request over HTTP/1.1 or HTTP/2. 2- Envoy (or another reverse proxy like Nginx) sits between the gRPC-Web client and the gRPC server. Envoy receives the gRPC-Web request, decodes the gRPC-Web payload, and forwards it as a standard gRPC request to the gRPC server using HTTP/2. The gRPC server processes the request as if it were a native gRPC request, using HTTP/2. 3- The gRPC server processes the incoming gRPC request, does the business logic, and generates a response (in this case, the Go written application). The response is encoded in the standard gRPC format and sent back to Envoy. 4- Envoy receives the gRPC response, encodes it in gRPC-Web format (typically base64), and sends it back to the gRPC-Web client over HTTP/1.1 or HTTP/2. Any metadata in the gRPC response, such as status codes, is translated. 5- The gRPC-Web client decodes the response and uses the web application. NOTE: Client-side and Bi-directional streaming is not currently supported (see streaming roadmap) Advantages of gRPC-Web Browser Compatibility: Allows modern web applications to interact with gRPC services without needing native support for HTTP/2 and binary protocols. Efficiency: Leverages the performance and efficiency of gRPC while adapting it for the web. Here Is a Working Demo https://github.com/ehsaniara/gRPC-web-example Demo Quick Start docker compose up -d Then, open the browser on__http://localhost:8081__ (note: this demo uses 8081 and 8080 ports) Project Structure client/: Contains the gRPC-Web client code
server/: Contains the gRPC server code written in Go
envoy/: envoy configuration file Prerequisites Go
Node.js and npm
grpc-web
protoc compiler Proto File syntax = "proto3";

package helloworld;

option go_package = "./proto"; // Add this line

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
} Server Server’s main file (server/main.go): package main

import (
   "context"
   "google.golang.org/grpc/reflection"
   "log"
   "net"

   pb "github.com/ehsaniara/gRPC-web-example/proto"
   "google.golang.org/grpc"
)

type server struct {
 pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
  log.Fatalf("failed to listen: %v", err)
 }
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})

 // Register reflection service on gRPC server.
 reflection.Register(s)
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }

 log.Println("Server is running on port 50051")
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }
} Envoy Config ...
http_filters:
  - name: envoy.filters.http.grpc_web
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.grpc_web.v3.GrpcWeb
  - name: envoy.filters.http.cors
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.cors.v3.Cors
  - name: envoy.filters.http.router
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
... Web Client Client file (client/src/index.js ) // Import the generated gRPC-Web client stubs and message classes
import {GreeterClient} from './generated/helloworld_grpc_web_pb';
import {HelloRequest} from './generated/helloworld_pb';

// Create an instance of the Greeter client
const client = new GreeterClient('http://localhost:8080');

// Function to send a greeting request
function sayHello(name) {
    // Create a new request
    const request = new HelloRequest();
    request.setName(name);

    // Call the sayHello method on the Greeter client
    client.sayHello(request, {}, (err, response) => {
        if (err) {
            console.error('Error:', err.message);
            document.getElementById('output').textContent = 'Error: ' + err.message;
        } else {
            console.log('Greeting:', response.getMessage());
            document.getElementById('output').textContent = 'Greeting: ' + response.getMessage();
        }
    });
}

// Example usage: sending a request when the page loads
document.addEventListener('DOMContentLoaded', () => {
    const name = 'World';
    sayHello(name);
}); Run generate.sh to generate *_pb.js files, for which you need to have grpc-web and protoc-gen-js already installed in your machine. $ npm i grpc-web
$ npm install -g protoc-gen-js This will generate helloworld_grpc_web_pb.js and helloworld_pb.js files, which already exist in this demo. Here’s a related GitHub project: https://github.com/ehsaniara/gRPC-web-example?embedable=true This is a simple gRPC communication between a web client and server with an Envoy proxy. I’m using the gRPC-Web library for this. gRPC-Web is a JavaScript client library that allows web applications to talk to gRPC services. Since browsers don’t support HTTP/2 or the binary protocol used by standard gRPC, gRPC-Web provides a way to bridge the gap by using HTTP/1.1 or HTTP/2 and encoding gRPC messages in a way that browsers can handle. Here’s how gRPC-Web works: 1- The client sends requests to the server using gRPC-Web, which typically uses HTTP/1.1 or HTTP/2. Metadata (like headers) can be attached to the request, such as for authentication (e.g., JWT tokens). The request is encoded in gRPC-Web format, typically using base64 encoding for the binary gRPC payload. The client sends this request over HTTP/1.1 or HTTP/2. The request is encoded in gRPC-Web format, typically using base64 encoding for the binary gRPC payload. The client sends this request over HTTP/1.1 or HTTP/2. The request is encoded in gRPC-Web format, typically using base64 encoding for the binary gRPC payload. The client sends this request over HTTP/1.1 or HTTP/2. 2- Envoy (or another reverse proxy like Nginx) sits between the gRPC-Web client and the gRPC server. Envoy receives the gRPC-Web request, decodes the gRPC-Web payload, and forwards it as a standard gRPC request to the gRPC server using HTTP/2. The gRPC server processes the request as if it were a native gRPC request, using HTTP/2. The gRPC server processes the request as if it were a native gRPC request, using HTTP/2. The gRPC server processes the request as if it were a native gRPC request, using HTTP/2. 3- The gRPC server processes the incoming gRPC request, does the business logic, and generates a response (in this case, the Go written application). The response is encoded in the standard gRPC format and sent back to Envoy. 4- Envoy receives the gRPC response, encodes it in gRPC-Web format (typically base64), and sends it back to the gRPC-Web client over HTTP/1.1 or HTTP/2. Any metadata in the gRPC response, such as status codes, is translated. 5- The gRPC-Web client decodes the response and uses the web application. NOTE: Client-side and Bi-directional streaming is not currently supported (see streaming roadmap) NOTE: Client-side and Bi-directional streaming is not currently supported (see streaming roadmap ) streaming roadmap streaming roadmap Advantages of gRPC-Web Browser Compatibility: Allows modern web applications to interact with gRPC services without needing native support for HTTP/2 and binary protocols. Browser Compatibility : Allows modern web applications to interact with gRPC services without needing native support for HTTP/2 and binary protocols. Browser Compatibility Efficiency: Leverages the performance and efficiency of gRPC while adapting it for the web. Efficiency : Leverages the performance and efficiency of gRPC while adapting it for the web. Efficiency Here Is a Working Demo https://github.com/ehsaniara/gRPC-web-example https://github.com/ehsaniara/gRPC-web-example Demo Quick Start docker compose up -d docker compose up -d Then, open the browser on__ http://localhost:8081 __ (note: this demo uses 8081 and 8080 ports) http://localhost:8081 Project Structure client/: Contains the gRPC-Web client code server/: Contains the gRPC server code written in Go envoy/: envoy configuration file client/: Contains the gRPC-Web client code server/: Contains the gRPC server code written in Go envoy/: envoy configuration file Prerequisites Go Node.js and npm grpc-web protoc compiler Go Go Go Node.js and npm Node.js and npm Node.js and npm grpc-web grpc-web grpc-web protoc compiler protoc compiler protoc compiler Proto File syntax = "proto3";

package helloworld;

option go_package = "./proto"; // Add this line

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
} syntax = "proto3";

package helloworld;

option go_package = "./proto"; // Add this line

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
} Server Server’s main file ( server/main.go ): server/main.go package main

import (
   "context"
   "google.golang.org/grpc/reflection"
   "log"
   "net"

   pb "github.com/ehsaniara/gRPC-web-example/proto"
   "google.golang.org/grpc"
)

type server struct {
 pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
  log.Fatalf("failed to listen: %v", err)
 }
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})

 // Register reflection service on gRPC server.
 reflection.Register(s)
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }

 log.Println("Server is running on port 50051")
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }
} package main

import (
   "context"
   "google.golang.org/grpc/reflection"
   "log"
   "net"

   pb "github.com/ehsaniara/gRPC-web-example/proto"
   "google.golang.org/grpc"
)

type server struct {
 pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
  log.Fatalf("failed to listen: %v", err)
 }
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})

 // Register reflection service on gRPC server.
 reflection.Register(s)
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }

 log.Println("Server is running on port 50051")
 if err := s.Serve(lis); err != nil {
  log.Fatalf("failed to serve: %v", err)
 }
} Envoy Config ...
http_filters:
  - name: envoy.filters.http.grpc_web
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.grpc_web.v3.GrpcWeb
  - name: envoy.filters.http.cors
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.cors.v3.Cors
  - name: envoy.filters.http.router
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
... ...
http_filters:
  - name: envoy.filters.http.grpc_web
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.grpc_web.v3.GrpcWeb
  - name: envoy.filters.http.cors
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.cors.v3.Cors
  - name: envoy.filters.http.router
    typed_config:
      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
... Web Client Client file ( client/src/index.js ) client/src/index.js // Import the generated gRPC-Web client stubs and message classes
import {GreeterClient} from './generated/helloworld_grpc_web_pb';
import {HelloRequest} from './generated/helloworld_pb';

// Create an instance of the Greeter client
const client = new GreeterClient('http://localhost:8080');

// Function to send a greeting request
function sayHello(name) {
    // Create a new request
    const request = new HelloRequest();
    request.setName(name);

    // Call the sayHello method on the Greeter client
    client.sayHello(request, {}, (err, response) => {
        if (err) {
            console.error('Error:', err.message);
            document.getElementById('output').textContent = 'Error: ' + err.message;
        } else {
            console.log('Greeting:', response.getMessage());
            document.getElementById('output').textContent = 'Greeting: ' + response.getMessage();
        }
    });
}

// Example usage: sending a request when the page loads
document.addEventListener('DOMContentLoaded', () => {
    const name = 'World';
    sayHello(name);
}); // Import the generated gRPC-Web client stubs and message classes
import {GreeterClient} from './generated/helloworld_grpc_web_pb';
import {HelloRequest} from './generated/helloworld_pb';

// Create an instance of the Greeter client
const client = new GreeterClient('http://localhost:8080');

// Function to send a greeting request
function sayHello(name) {
    // Create a new request
    const request = new HelloRequest();
    request.setName(name);

    // Call the sayHello method on the Greeter client
    client.sayHello(request, {}, (err, response) => {
        if (err) {
            console.error('Error:', err.message);
            document.getElementById('output').textContent = 'Error: ' + err.message;
        } else {
            console.log('Greeting:', response.getMessage());
            document.getElementById('output').textContent = 'Greeting: ' + response.getMessage();
        }
    });
}

// Example usage: sending a request when the page loads
document.addEventListener('DOMContentLoaded', () => {
    const name = 'World';
    sayHello(name);
}); Run generate.sh to generate *_pb.js files, for which you need to have grpc-web and protoc-gen-js already installed in your machine. generate.sh generate.sh *_pb.js grpc-web protoc-gen-js $ npm i grpc-web
$ npm install -g protoc-gen-js $ npm i grpc-web
$ npm install -g protoc-gen-js This will generate helloworld_grpc_web_pb.js and helloworld_pb.js files, which already exist in this demo. helloworld_grpc_web_pb.js helloworld_pb.js Here’s a related GitHub project: https://github.com/ehsaniara/gRPC-web-example?embedable=true https://github.com/ehsaniara/gRPC-web-example?embedable=true

gRPC Between Web and Server: A Simple gRPC Communication

I enjoy spending time learning new technologies. However, often the biggest drawback of working with new technologies are the inevitable pain points that come with early adoption. I saw this quite a bit when I was getting up to speed with Web3 in “How to Transition from Full-Stack Developer to Web3 Pioneer in 2022.” As software engineers, we’re accustomed to accepting these early-adopter challenges when giving new tech a test drive. What works best for me is to keep a running list of notes and commands I’ve executed since seemingly illogical steps don’t remain in my memory. Aside from Web3, I also found this challenge in the JavaScript space, with the semi-standard requirements of using Node.js and Webpack. I wanted to identify a solution where I could just use JavaScript as is without toiling away with Node.js and Webpack. I recently read how the Rails 7 release addressed this very situation. So, that’s the use case I’ll be covering in this article. About Rails To be fully transparent, my experience with Ruby and Ruby on Rails is little to none. I remember watching someone issue some commands to create a fully functional service years ago, and I thought, “Wow, that looks awesome.” But I’ve never spent time playing around with this approach to building services and applications. I’m pretty sure I saw that demo in early 2006 because Rails first emerged in late 2005. Like I saw in the demonstration, the end result was a service that supported the model-view-controller (MVC) design pattern, a pattern that I was familiar with through my early use of the Spring, Struts, JSF, and Seam frameworks. Rails maintains a promise to keep things straightforward while adhering to DRY (don’t repeat yourself) practices. To help honor this promise, Ruby uses Gems for engineers to introduce shared dependencies into their projects. Version 7 Highlights In late 2021, the seventh major version of Rails introduced some exciting features: Asynchronous querying – getting away from running queries serially
Encrypted database layer – securing data between the service and persistence layers
Comparison validator – allows object validation before persistence
Import maps – no longer require Node.js and Webpack for JavaScript libraries That last feature is what drove me to write this article. How Do Import Maps Work? At a high level, the importmaps-rails Gem allows developers to import maps into their applications. The use of /bin/importmap allows engineers to update, pin, or unpin dependencies as needed. This is similar to how Maven and Gradle work in Java-based projects. This eliminates needing to deal with the complexities related to bundling packages and transpiling ES6 and Babel. Goodbye Webpack! Goodbye Node.js! Let’s Build Something Since I hadn’t even touched Ruby on Rails in almost two decades, the first thing I needed to do was follow this guide to install Ruby 3.3 on my MacBook Pro. Once installed, I just needed to install the Ruby plugin as part of my IntelliJ IDEA IDE. Then, I created a new Ruby on Rails project in IntelliJ called import-map and specified the use of Importmap for the JavaScript framework: With the project created, I first wanted to see how easy it would be to use a local JavaScript library. So, I created a new JavaScript file called /public/jvc_utilities.js with the following contents: export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} The default function simply echoes some commands to the JavaScript console. Next, I created an HTML file (/public/jvc-utilities.html) with the following contents: <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> This example demonstrates how a local JavaScript file can be used with a public HTML file— without any additional work. Next, I created a new controller called Example: bin/rails generate controller Example index I wanted to use the Lodash library for this example, so I used the following command to add the library to my import-map project: bin/importmap pin lodash To add some JavaScript-based functionality to the controller, I updated javascript/controllers/example_controller.js to look like this: import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} This logic establishes an array of three values, and then it doubles the values. I use the Lodash map() method to do this. Finally, I updated views/example/index.html.erb to contain the following: <h3>Example Controller</h3>

<div data-controller="example"></div> At this point, the following URIs are now available: /jvc-utilities.html
/example/index Let’s Deploy and Validate Rather than run the Rails service locally, I thought I would use Heroku instead. This way, I could make sure my service could be accessible for other consumers. Using my Heroku account, I followed the “Getting Started on Heroku with Ruby” guide. Based upon my project, my first step was to add a file named Procfile with the following contents: web: bundle exec puma -C config/puma.rb Next, I used the Heroku CLI to create a new application in Heroku: heroku login
heroku create With the create command, I had the following application up and running: Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git This step also created the Git remote that the Heroku ecosystem uses. Now, all I needed do was push my latest updates to Heroku and deploy the application: git push heroku main With that, my code was pushed to Heroku, which then compiled and deployed my application. In less than a minute, I saw the following, letting me know that my application was ready for use: remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main Then, I navigated to the /example/index page using my Heroku URL (which is unique to my application, but I have since taken it down): https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index This is what I saw: And when I viewed the JavaScript console in my browser, the following logs appeared: Navigating to /jvc-utilities.html, I saw the following information: When I viewed the JavaScript console in my browser, I saw the the following logs: Success. I was able to use a self-contained JavaScript library and also the public Lodash JavaScript library in my Rails 7 application—all by using Import Maps and without needing to deal with Webpack or Node.js. Buh-bye, Webpack and Node.js! Conclusion My readers may recall my personal mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester In this article, I dove head-first into Rails 7 and used Import Maps to show how easily you can use JavaScript libraries without the extra effort of needing to use Webpack and Node.js. I was quite impressed by the small amount of time that was required to accomplish my goals despite it being over two decades since I had last seen Rails in action. From a deployment perspective, the effort to deploy the Rails application onto the Heroku platform consisted of the creation of a Procfile and three CLI commands. In both cases, Rails and Heroku adhere to my mission statement by allowing me to remain laser-focused on delivering value to my customers and not get bogged down by challenges with Webpack, Node.js, or even DevOps tasks. While I am certain we will continue to face not-so-ideal pain points when exploring new technologies, I am also confident that in time, we will see similar accomplishments as I demonstrated in this article. As always, my source code can be found on GitLab here. Have a really great day! I enjoy spending time learning new technologies. However, often the biggest drawback of working with new technologies are the inevitable pain points that come with early adoption. I saw this quite a bit when I was getting up to speed with Web3 in “ How to Transition from Full-Stack Developer to Web3 Pioneer in 2022 .” How to Transition from Full-Stack Developer to Web3 Pioneer in 2022 As software engineers, we’re accustomed to accepting these early-adopter challenges when giving new tech a test drive. What works best for me is to keep a running list of notes and commands I’ve executed since seemingly illogical steps don’t remain in my memory. Aside from Web3, I also found this challenge in the JavaScript space, with the semi-standard requirements of using Node.js and Webpack. I wanted to identify a solution where I could just use JavaScript as is without toiling away with Node.js and Webpack. I recently read how the Rails 7 release addressed this very situation . So, that’s the use case I’ll be covering in this article. this very situation About Rails To be fully transparent, my experience with Ruby and Ruby on Rails is little to none. I remember watching someone issue some commands to create a fully functional service years ago, and I thought, “Wow, that looks awesome.” But I’ve never spent time playing around with this approach to building services and applications. I’m pretty sure I saw that demo in early 2006 because Rails first emerged in late 2005. Like I saw in the demonstration, the end result was a service that supported the model-view-controller (MVC) design pattern, a pattern that I was familiar with through my early use of the Spring, Struts, JSF, and Seam frameworks. Rails maintains a promise to keep things straightforward while adhering to DRY (don’t repeat yourself) practices. To help honor this promise, Ruby uses Gems for engineers to introduce shared dependencies into their projects. Version 7 Highlights In late 2021, the seventh major version of Rails introduced some exciting features: Asynchronous querying – getting away from running queries serially Encrypted database layer – securing data between the service and persistence layers Comparison validator – allows object validation before persistence Import maps – no longer require Node.js and Webpack for JavaScript libraries Asynchronous querying – getting away from running queries serially Encrypted database layer – securing data between the service and persistence layers Comparison validator – allows object validation before persistence Import maps – no longer require Node.js and Webpack for JavaScript libraries That last feature is what drove me to write this article. How Do Import Maps Work? At a high level, the importmaps-rails Gem allows developers to import maps into their applications. The use of /bin/importmap allows engineers to update, pin, or unpin dependencies as needed. This is similar to how Maven and Gradle work in Java-based projects. importmaps-rails /bin/importmap This eliminates needing to deal with the complexities related to bundling packages and transpiling ES6 and Babel. Goodbye Webpack! Goodbye Node.js! Let’s Build Something Since I hadn’t even touched Ruby on Rails in almost two decades, the first thing I needed to do was follow this guide to install Ruby 3.3 on my MacBook Pro. Once installed, I just needed to install the Ruby plugin as part of my IntelliJ IDEA IDE. this guide install the Ruby plugin Then, I created a new Ruby on Rails project in IntelliJ called import-map and specified the use of Importmap for the JavaScript framework: import-map Importmap With the project created, I first wanted to see how easy it would be to use a local JavaScript library. So, I created a new JavaScript file called /public/jvc_utilities.js with the following contents: /public/jvc_utilities.js export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} export default function() {
    console.log('*****************');
    console.log('* jvc-utilities *');
    console.log('* version 0.0.1 *');
    console.log('*****************');
} The default function simply echoes some commands to the JavaScript console. Next, I created an HTML file ( /public/jvc-utilities.html ) with the following contents: /public/jvc-utilities.html <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> <!DOCTYPE html>
<html>
    <head>
        <title>jvc-utilities</title>
    </head>

    <script type="importmap">
        { "imports": { "jvc_utilities": "./jvc_utilities.js"} }
    </script>
    <script type="module">
        import JvcUtilities from "jvc_utilities";

        JvcUtilities();
    </script>

    <h3>jvc-utilities.html</h3>

    <p>Open the console to see the output of the 
       <code>JvcUtilities()</code> function.
    </p>
</html> This example demonstrates how a local JavaScript file can be used with a public HTML file— without any additional work. Next, I created a new controller called Example : Example bin/rails generate controller Example index bin/rails generate controller Example index I wanted to use the Lodash library for this example, so I used the following command to add the library to my import-map project: Lodash library import-map bin/importmap pin lodash bin/importmap pin lodash To add some JavaScript-based functionality to the controller, I updated javascript/controllers/example_controller.js to look like this: javascript/controllers/example_controller.js import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} import { Controller } from "@hotwired/stimulus"
import _ from "lodash"

export default class extends Controller {
  connect() {
    const array = [1, 2, 3]
    const doubled = _.map(array, n => n * 2)
    console.log('array', array)  // Output: [1, 2, 3]
    console.log('doubled', doubled)  // Output: [2, 4, 6]
    this.element.textContent = `array=${array} doubled=${doubled.join(', ')}`
  }
} This logic establishes an array of three values, and then it doubles the values. I use the Lodash map() method to do this. map() Finally, I updated views/example/index.html.erb to contain the following: views/example/index.html.erb <h3>Example Controller</h3>

<div data-controller="example"></div> <h3>Example Controller</h3>

<div data-controller="example"></div> At this point, the following URIs are now available: /jvc-utilities.html /example/index /jvc-utilities.html /jvc-utilities.html /example/index /example/index Let’s Deploy and Validate Rather than run the Rails service locally, I thought I would use Heroku instead. This way, I could make sure my service could be accessible for other consumers. Using my Heroku account, I followed the “ Getting Started on Heroku with Ruby ” guide. Based upon my project, my first step was to add a file named Procfile with the following contents: Getting Started on Heroku with Ruby Procfile web: bundle exec puma -C config/puma.rb web: bundle exec puma -C config/puma.rb Next, I used the Heroku CLI to create a new application in Heroku: heroku login
heroku create heroku login
heroku create With the create command, I had the following application up and running: create Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git Creating app... done, ⬢ lit-basin-84681
https://lit-basin-84681-3f5a7507b174.herokuapp.com/ | https://git.heroku.com/lit-basin-84681.git This step also created the Git remote that the Heroku ecosystem uses. Now, all I needed do was push my latest updates to Heroku and deploy the application: git push heroku main git push heroku main With that, my code was pushed to Heroku, which then compiled and deployed my application. In less than a minute, I saw the following, letting me know that my application was ready for use: remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main remote: Verifying deploy... done.
To https://git.heroku.com/lit-basin-84681.git
   fe0b7ad..1a21bdd  main -> main Then, I navigated to the /example/index page using my Heroku URL (which is unique to my application, but I have since taken it down): https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index /example/index https://lit-basin-84681-3f5a7507b174.herokuapp.com/example/index This is what I saw: And when I viewed the JavaScript console in my browser, the following logs appeared: Navigating to /jvc-utilities.html , I saw the following information: /jvc-utilities.html When I viewed the JavaScript console in my browser, I saw the the following logs: Success. I was able to use a self-contained JavaScript library and also the public Lodash JavaScript library in my Rails 7 application—all by using Import Maps and without needing to deal with Webpack or Node.js. Buh-bye, Webpack and Node.js! Conclusion My readers may recall my personal mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester “Focus your time on delivering features/functionality that extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” — J. Vester In this article, I dove head-first into Rails 7 and used Import Maps to show how easily you can use JavaScript libraries without the extra effort of needing to use Webpack and Node.js. I was quite impressed by the small amount of time that was required to accomplish my goals despite it being over two decades since I had last seen Rails in action. From a deployment perspective, the effort to deploy the Rails application onto the Heroku platform consisted of the creation of a Procfile and three CLI commands. Procfile In both cases, Rails and Heroku adhere to my mission statement by allowing me to remain laser-focused on delivering value to my customers and not get bogged down by challenges with Webpack, Node.js, or even DevOps tasks. While I am certain we will continue to face not-so-ideal pain points when exploring new technologies, I am also confident that in time, we will see similar accomplishments as I demonstrated in this article. As always, my source code can be found on GitLab here . here Have a really great day!

Buh-Bye Webpack and Node.js, Hello Rails and Import Maps

Buh-Bye Webpack এবং Node.js, Hello Rails এবং Import Maps

Tschüß Webpack und Node.js, hallo Rails und Import Maps

Buh-Bye Webpack y Node.js, Hello Rails e Importar mapas

Buh-Bye Webpack et Node.js, Hello Rails et Import Maps

अलविदा वेबपैक और नोड.जेएस, नमस्ते रेल्स और इम्पोर्ट मैप्स

さようなら Webpack と Node.js、こんにちは Rails と Import Maps

이제 안녕 Webpack 및 Node.js, Hello Rails 및 가져오기 맵

Buh-Bye Webpack e Node.js, Hello Rails e Import Maps

Прощайте, Webpack и Node.js, Hello Rails и импорт карт

Buh-Bye Webpack ve Node.js, Hello Rails ve İçe Aktarma Haritaları

Buh-Bye Webpack và Node.js, Hello Rails và Nhập bản đồ

告别 Webpack 和 Node.js，迎接 Rails 和 Import Maps

Server Side Rendering Web components Generating static HTML from JavaScript on the server called Server Side Rendering is a technique used to improve the perceived performance, SEO, and support for non-scripting environments. Shadow DOM: Shadow DOM is a web standard enabling the encapsulation of DOM subtrees in web components, shielding them from external styling and manipulation. It allows developers to create isolated scopes for CSS and JavaScript within a document, preventing conflicts with other parts of the page. Shadow DOM's key feature is its "shadow root," serving as a boundary between the component's internal structure and the rest of the document. This enables building modular, reusable components with their own encapsulated styles and behavior, enhancing code maintainability and reducing the risk of unintended side effects in complex web applications. Here is the sample code of the web component with Shadow DOM <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Shadow DOM Example</title>
</head>
<body>
  <div id="parent"></div>

  <script>
    // Create a shadow DOM for the container element
    const container = document.getElementById('parent');
    const shadowRoot = container.attachShadow({ mode: 'open' });

    // Create an element inside the shadow DOM
    const paragraph = document.createElement('p');
    paragraph.textContent = 'This paragraph text is inside the Shadow DOM.';
    
    // Apply some styling to the paragraph
    const style = document.createElement('style');
    style.textContent = `
      p {
        color: blue;
      }
    `;
    
    // Append the elements to the shadow DOM
    shadowRoot.appendChild(style);
    shadowRoot.appendChild(paragraph);
  </script>
</body>
</html> The text in the above code "This paragraph text is inside the Shadow DOM." will be displayed on the page, but its styling will be isolated from the rest of the document due to the use of Shadow DOM. Imperative-only API for Shadow DOM: As we observe closely in JavaScript, create Shadow DOM imperatively by selecting an element, attaching a shadow root (attachShadow({mode: 'open'})), and appending child elements. const container = document.getElementById('parent');
const shadowRoot = container.attachShadow({ mode: 'open' });
const paragraph = document.createElement('p');
paragraph.textContent = 'This text is inside the Shadow DOM.';
const style = document.createElement('style');
style.textContent = 'p { color: blue; }';
shadowRoot.appendChild(style);
shadowRoot.appendChild(paragraph);This creates encapsulated DOM and styling within container, isolating the paragraph's appearance and behavior from the rest of the document. We need a way to be able to serve shadow roots, of native and custom elements, in a static HTML document and let them upgrade progressively. Declarative API for Shadow DOM: In HTML, we can use the slot element to create a declarative API for Shadow DOM. This allows you to define placeholders for content insertion within custom elements. Here's an example: <html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Declarative Shadow DOM</title>
</head>
<body>
  <div id="parent">
    <p>This content is outside the Shadow DOM.</p>
    <my-custom-element>
      <p slot="content">This text is inside the Shadow DOM.</p>
    </my-custom-element>
  </div>

  <script>
    customElements.define('my-custom-element', class extends HTMLElement {
      constructor() {
        super();
        const shadowRoot = this.attachShadow({ mode: 'open' });
        const template = document.querySelector('#my-custom-element-template');
        shadowRoot.appendChild(template.content.cloneNode(true));
      }
    });
  </script>

  <template id="my-custom-element-template">
    <style>
      p { color: blue; }
    </style>
    <slot name="content"></slot>
  </template>
</body>
</html> In the declarative example, we use HTML to define a template for the Shadow DOM structure. We then use JavaScript to clone and append this template to the Shadow DOM, along with any additional content we wish to add. Declarative Shadow DOM removes this limitation, bringing Shadow DOM to the server. Conclusion Declarative Shadow DOM is a groundbreaking feature that enhances web components by allowing developers to define shadow DOM content directly within HTML. This approach simplifies the creation and maintenance of encapsulated components, improving code readability and reusability. For server-side rendering (SSR), Declarative Shadow DOM offers significant benefits by enabling better performance and SEO. By rendering shadow DOM content server-side, developers can ensure faster initial page loads and improved indexing by search engines. This innovation effectively bridges the gap between client-side encapsulation and server-side efficiency, making Declarative Shadow DOM a powerful tool for modern web development. Server Side Rendering Web components Generating static HTML from JavaScript on the server called Server Side Rendering is a technique used to improve the perceived performance, SEO, and support for non-scripting environments. HTML JavaScript Shadow DOM: Shadow DOM: Shadow DOM is a web standard enabling the encapsulation of DOM subtrees in web components, shielding them from external styling and manipulation. It allows developers to create isolated scopes for CSS and JavaScript within a document, preventing conflicts with other parts of the page. Shadow DOM's key feature is its "shadow root," serving as a boundary between the component's internal structure and the rest of the document. This enables building modular, reusable components with their own encapsulated styles and behavior, enhancing code maintainability and reducing the risk of unintended side effects in complex web applications. Here is the sample code of the web component with Shadow DOM <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Shadow DOM Example</title>
</head>
<body>
  <div id="parent"></div>

  <script>
    // Create a shadow DOM for the container element
    const container = document.getElementById('parent');
    const shadowRoot = container.attachShadow({ mode: 'open' });

    // Create an element inside the shadow DOM
    const paragraph = document.createElement('p');
    paragraph.textContent = 'This paragraph text is inside the Shadow DOM.';
    
    // Apply some styling to the paragraph
    const style = document.createElement('style');
    style.textContent = `
      p {
        color: blue;
      }
    `;
    
    // Append the elements to the shadow DOM
    shadowRoot.appendChild(style);
    shadowRoot.appendChild(paragraph);
  </script>
</body>
</html> <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Shadow DOM Example</title>
</head>
<body>
  <div id="parent"></div>

  <script>
    // Create a shadow DOM for the container element
    const container = document.getElementById('parent');
    const shadowRoot = container.attachShadow({ mode: 'open' });

    // Create an element inside the shadow DOM
    const paragraph = document.createElement('p');
    paragraph.textContent = 'This paragraph text is inside the Shadow DOM.';
    
    // Apply some styling to the paragraph
    const style = document.createElement('style');
    style.textContent = `
      p {
        color: blue;
      }
    `;
    
    // Append the elements to the shadow DOM
    shadowRoot.appendChild(style);
    shadowRoot.appendChild(paragraph);
  </script>
</body>
</html> The text in the above code "This paragraph text is inside the Shadow DOM." will be displayed on the page, but its styling will be isolated from the rest of the document due to the use of Shadow DOM. "This paragraph text is inside the Shadow DOM." Imperative-only API for Shadow DOM: Imperative-only API for Shadow DOM: As we observe closely in JavaScript, create Shadow DOM imperatively by selecting an element, attaching a shadow root (attachShadow({mode: 'open'})), and appending child elements. const container = document.getElementById('parent');
const shadowRoot = container.attachShadow({ mode: 'open' });
const paragraph = document.createElement('p');
paragraph.textContent = 'This text is inside the Shadow DOM.';
const style = document.createElement('style');
style.textContent = 'p { color: blue; }';
shadowRoot.appendChild(style);
shadowRoot.appendChild(paragraph);This creates encapsulated DOM and styling within container, isolating the paragraph's appearance and behavior from the rest of the document. const container = document.getElementById('parent');
const shadowRoot = container.attachShadow({ mode: 'open' });
const paragraph = document.createElement('p');
paragraph.textContent = 'This text is inside the Shadow DOM.';
const style = document.createElement('style');
style.textContent = 'p { color: blue; }';
shadowRoot.appendChild(style);
shadowRoot.appendChild(paragraph);This creates encapsulated DOM and styling within container, isolating the paragraph's appearance and behavior from the rest of the document. We need a way to be able to serve shadow roots, of native and custom elements, in a static HTML document and let them upgrade progressively. Declarative API for Shadow DOM: In HTML, we can use the slot element to create a declarative API for Shadow DOM. This allows you to define placeholders for content insertion within custom elements. Here's an example: Here's an example: <html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Declarative Shadow DOM</title>
</head>
<body>
  <div id="parent">
    <p>This content is outside the Shadow DOM.</p>
    <my-custom-element>
      <p slot="content">This text is inside the Shadow DOM.</p>
    </my-custom-element>
  </div>

  <script>
    customElements.define('my-custom-element', class extends HTMLElement {
      constructor() {
        super();
        const shadowRoot = this.attachShadow({ mode: 'open' });
        const template = document.querySelector('#my-custom-element-template');
        shadowRoot.appendChild(template.content.cloneNode(true));
      }
    });
  </script>

  <template id="my-custom-element-template">
    <style>
      p { color: blue; }
    </style>
    <slot name="content"></slot>
  </template>
</body>
</html> <html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Declarative Shadow DOM</title>
</head>
<body>
  <div id="parent">
    <p>This content is outside the Shadow DOM.</p>
    <my-custom-element>
      <p slot="content">This text is inside the Shadow DOM.</p>
    </my-custom-element>
  </div>

  <script>
    customElements.define('my-custom-element', class extends HTMLElement {
      constructor() {
        super();
        const shadowRoot = this.attachShadow({ mode: 'open' });
        const template = document.querySelector('#my-custom-element-template');
        shadowRoot.appendChild(template.content.cloneNode(true));
      }
    });
  </script>

  <template id="my-custom-element-template">
    <style>
      p { color: blue; }
    </style>
    <slot name="content"></slot>
  </template>
</body>
</html> In the declarative example, we use HTML to define a template for the Shadow DOM structure. We then use JavaScript to clone and append this template to the Shadow DOM, along with any additional content we wish to add. Declarative Shadow DOM removes this limitation, bringing Shadow DOM to the server. Conclusion Declarative Shadow DOM is a groundbreaking feature that enhances web components by allowing developers to define shadow DOM content directly within HTML. This approach simplifies the creation and maintenance of encapsulated components, improving code readability and reusability. For server-side rendering (SSR), Declarative Shadow DOM offers significant benefits by enabling better performance and SEO. By rendering shadow DOM content server-side, developers can ensure faster initial page loads and improved indexing by search engines. This innovation effectively bridges the gap between client-side encapsulation and server-side efficiency, making Declarative Shadow DOM a powerful tool for modern web development.

Declarative Shadow DOM: The Magic Pill for Server-Side Rendering and Web Components

Recollections of My Life: Part 3

Micro frontends architecture is still a hot topic in the Front-End field. Many projects are adopting or have already adopted this approach. However, it is one of the most controversial topics, and you should carefully consider the pros and cons before implementing it. Today, I will share how I dealt with this challenge and solved it in my application. Understanding Your Goals The first thing to consider is the business needs of the project and how your architecture will fit in. You can't build whatever you want – your decisions should align with the business direction. Secondly, evaluate the benefits of this architecture for your specific project. Don't rely solely on observations from others or follow trends without a cost-benefit analysis. Determine if the advantages are worth the cost. Thirdly, address these common concerns before making the shift: What is my current architecture?
How is the application deployed, and how will it deploy in the new architecture?
Can a micro frontend application be integrated into other applications? What stack do they use?
What is the complexity of the application? Does it involve routing or state management?
How will communication between apps be handled?
Is your team technically ready for this shift? These are the minimal recommendations before you start development. Solving the Problem If you have answers to the above questions, you're ready to proceed with the technical implementation for Angular apps. Historically, Angular apps are built using Webpack. This is not a significant issue until you face the micro frontend topic. Different bundlers can have runtime compatibility issues. For example, integrating an Angular app into a React app built with Vite and esbuild can be problematic. It makes more sense to follow web standards (ES Modules) rather than locking your projects to a specific bundler like Module Federation and Webpack. Fortunately, since Angular 16, the Angular team has included esbuild out of the box. I recommend updating beyond version 16. Now, it's enough to update your angular.json file with the new builder and other fields: {
  "build": {
    "executor": "@angular-devkit/build-angular:browser-esbuild",
    "options": {
      "stylePreprocessorOptions": {
        "includePaths": [""]
      },
      "outputPath": "dist",
      "index": "src/index.html",
      "main": "src/main.ts",
      "polyfills": ["zone.js"],
      "tsConfig": "./tsconfig.app.json",
      "inlineStyleLanguage": "scss",
      "assets": ["src/favicon.ico", "src/assets"]
    },
    "configurations": {
      "production": {
        "budgets": [
          {
            "type": "initial",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          },
          {
            "type": "anyComponentStyle",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          }
        ],
        "outputHashing": "none",
        "baseHref": "/"
      },
      "development": {
        "optimization": false,
        "extractLicenses":false,
        "sourceMap": true
      }
    },
    "defaultConfiguration": "production"
  }
} It's a good practice to integrate the micro frontend with minimal effort. For example, you can expose a component that accepts the remote app name and link. This makes it easier for consumers, as they don't need to worry about the underlying processes. Consider the following example: import { Component, Input, OnInit } from '@angular/core';

const MFE_CACHE_KEY = '__mfe-cache';

@Component({
    selector: 'mfe-wrapper',
    template: '<div id="mfe-root"></div>'
})
export class MfeWrapperComponent implements OnInit {
    @Input() public url: string;
    @Input() public appName: string;

    public ngOnInit(): void {
        const importFn = async (path: string): Promise<string> => {
            if (window[MFE_CACHE_KEY]?.[path]) {
                return window[MFE_CACHE_KEY][path];
            } else {
                const response = await fetch(path);
                const scriptContent = await response.text();
                window[MFE_CACHE_KEY] = { ...window[MFE_CACHE_KEY], [path]: scriptContent };
                return scriptContent;
            }
        };
        const element = document.getElementById('mfe-root');

        const executeScript = (scriptContent: string): void => {
            const scriptElement = document.createElement('script');
            scriptElement.type = 'module';
            scriptElement.async = true;
            scriptElement.textContent = scriptContent;
            element.appendChild(scriptElement);
        };

        element.appendChild(document.createElement(this.appName));

        (async (): Promise<void> => {
            const mainScript = await importFn(`${this.url}/main.js`);
            executeScript(mainScript);
            const polyfillsScript = await importFn(`${this.url}/polyfills.js`);
            executeScript(polyfillsScript);
        })();
    }
} In this example, we download the necessary scripts (main.js and polyfills.js) from the provided source. You must deploy your Angular build to the URL that you expose to the consumers. We convert the script into text and insert it into the script tag to avoid caching issues. You can extract the logic of downloading and script creation into separate scripts and reuse it for a React component wrapper for React app integrations – the approach remains the same. One important note is dealing with styles. You may notice that angular.json doesn't have a styles field. This is intentional. If you leave this field, the builder creates a style.css file, which can override the host application’s styles. By removing this field, the styles are added to the main.js file. Additionally, you can wrap the app in ShadowDOM to ensure that your styles don't override the host styles. If you use UI libraries and components without styles encapsulation, these approaches won't help – the styles will leak into the host application’s head. Carefully choose the components you use. Advantages: Your Angular application can be integrated into any other application regardless of the framework. Easy integration with the host by providing a component with only two inputs – URL and app name (you can omit the name if the URL has only one application). In most cases, your application’s styles are encapsulated and don't override the host’s styles. Disadvantages: This approach is compatible with Angular 16 and above. Version upgrades can be challenging. Path resolution issues. If the host and remote app are on different domains, import paths will resolve within the host domain. You can either remap all your imports after the build (use this only if necessary) or host the remote app on the same domain (or use emulation). The styles encapsulation problem is not fully solved. Conclusion Adopting a micro frontend architecture requires careful planning and consideration of both business and technical factors. The approach described here provides a way to integrate Angular applications into various host environments with minimal effort. While it offers significant advantages, such as framework-agnostic integration and style encapsulation, there are also challenges to address, including compatibility with older Angular versions and path resolution issues. By understanding these trade-offs and planning accordingly, you can effectively implement a micro frontend architecture that meets your project’s needs. Micro frontends architecture is still a hot topic in the Front-End field. Many projects are adopting or have already adopted this approach. However, it is one of the most controversial topics, and you should carefully consider the pros and cons before implementing it. Today, I will share how I dealt with this challenge and solved it in my application. Understanding Your Goals The first thing to consider is the business needs of the project and how your architecture will fit in. You can't build whatever you want – your decisions should align with the business direction. Secondly, evaluate the benefits of this architecture for your specific project. Don't rely solely on observations from others or follow trends without a cost-benefit analysis. Determine if the advantages are worth the cost. Thirdly, address these common concerns before making the shift: What is my current architecture? How is the application deployed, and how will it deploy in the new architecture? Can a micro frontend application be integrated into other applications? What stack do they use? What is the complexity of the application? Does it involve routing or state management? How will communication between apps be handled? Is your team technically ready for this shift? What is my current architecture? How is the application deployed, and how will it deploy in the new architecture? Can a micro frontend application be integrated into other applications? What stack do they use? What is the complexity of the application? Does it involve routing or state management? How will communication between apps be handled? Is your team technically ready for this shift? These are the minimal recommendations before you start development. Solving the Problem If you have answers to the above questions, you're ready to proceed with the technical implementation for Angular apps. Historically, Angular apps are built using Webpack. This is not a significant issue until you face the micro frontend topic. Different bundlers can have runtime compatibility issues. For example, integrating an Angular app into a React app built with Vite and esbuild can be problematic. It makes more sense to follow web standards (ES Modules) rather than locking your projects to a specific bundler like Module Federation and Webpack. Fortunately, since Angular 16, the Angular team has included esbuild out of the box. I recommend updating beyond version 16. Now, it's enough to update your angular.json file with the new builder and other fields: {
  "build": {
    "executor": "@angular-devkit/build-angular:browser-esbuild",
    "options": {
      "stylePreprocessorOptions": {
        "includePaths": [""]
      },
      "outputPath": "dist",
      "index": "src/index.html",
      "main": "src/main.ts",
      "polyfills": ["zone.js"],
      "tsConfig": "./tsconfig.app.json",
      "inlineStyleLanguage": "scss",
      "assets": ["src/favicon.ico", "src/assets"]
    },
    "configurations": {
      "production": {
        "budgets": [
          {
            "type": "initial",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          },
          {
            "type": "anyComponentStyle",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          }
        ],
        "outputHashing": "none",
        "baseHref": "/"
      },
      "development": {
        "optimization": false,
        "extractLicenses":false,
        "sourceMap": true
      }
    },
    "defaultConfiguration": "production"
  }
} {
  "build": {
    "executor": "@angular-devkit/build-angular:browser-esbuild",
    "options": {
      "stylePreprocessorOptions": {
        "includePaths": [""]
      },
      "outputPath": "dist",
      "index": "src/index.html",
      "main": "src/main.ts",
      "polyfills": ["zone.js"],
      "tsConfig": "./tsconfig.app.json",
      "inlineStyleLanguage": "scss",
      "assets": ["src/favicon.ico", "src/assets"]
    },
    "configurations": {
      "production": {
        "budgets": [
          {
            "type": "initial",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          },
          {
            "type": "anyComponentStyle",
            "maximumWarning": "1mb",
            "maximumError": "2mb"
          }
        ],
        "outputHashing": "none",
        "baseHref": "/"
      },
      "development": {
        "optimization": false,
        "extractLicenses":false,
        "sourceMap": true
      }
    },
    "defaultConfiguration": "production"
  }
} It's a good practice to integrate the micro frontend with minimal effort. For example, you can expose a component that accepts the remote app name and link. This makes it easier for consumers, as they don't need to worry about the underlying processes. Consider the following example: import { Component, Input, OnInit } from '@angular/core';

const MFE_CACHE_KEY = '__mfe-cache';

@Component({
    selector: 'mfe-wrapper',
    template: '<div id="mfe-root"></div>'
})
export class MfeWrapperComponent implements OnInit {
    @Input() public url: string;
    @Input() public appName: string;

    public ngOnInit(): void {
        const importFn = async (path: string): Promise<string> => {
            if (window[MFE_CACHE_KEY]?.[path]) {
                return window[MFE_CACHE_KEY][path];
            } else {
                const response = await fetch(path);
                const scriptContent = await response.text();
                window[MFE_CACHE_KEY] = { ...window[MFE_CACHE_KEY], [path]: scriptContent };
                return scriptContent;
            }
        };
        const element = document.getElementById('mfe-root');

        const executeScript = (scriptContent: string): void => {
            const scriptElement = document.createElement('script');
            scriptElement.type = 'module';
            scriptElement.async = true;
            scriptElement.textContent = scriptContent;
            element.appendChild(scriptElement);
        };

        element.appendChild(document.createElement(this.appName));

        (async (): Promise<void> => {
            const mainScript = await importFn(`${this.url}/main.js`);
            executeScript(mainScript);
            const polyfillsScript = await importFn(`${this.url}/polyfills.js`);
            executeScript(polyfillsScript);
        })();
    }
} import { Component, Input, OnInit } from '@angular/core';

const MFE_CACHE_KEY = '__mfe-cache';

@Component({
    selector: 'mfe-wrapper',
    template: '<div id="mfe-root"></div>'
})
export class MfeWrapperComponent implements OnInit {
    @Input() public url: string;
    @Input() public appName: string;

    public ngOnInit(): void {
        const importFn = async (path: string): Promise<string> => {
            if (window[MFE_CACHE_KEY]?.[path]) {
                return window[MFE_CACHE_KEY][path];
            } else {
                const response = await fetch(path);
                const scriptContent = await response.text();
                window[MFE_CACHE_KEY] = { ...window[MFE_CACHE_KEY], [path]: scriptContent };
                return scriptContent;
            }
        };
        const element = document.getElementById('mfe-root');

        const executeScript = (scriptContent: string): void => {
            const scriptElement = document.createElement('script');
            scriptElement.type = 'module';
            scriptElement.async = true;
            scriptElement.textContent = scriptContent;
            element.appendChild(scriptElement);
        };

        element.appendChild(document.createElement(this.appName));

        (async (): Promise<void> => {
            const mainScript = await importFn(`${this.url}/main.js`);
            executeScript(mainScript);
            const polyfillsScript = await importFn(`${this.url}/polyfills.js`);
            executeScript(polyfillsScript);
        })();
    }
} In this example, we download the necessary scripts ( main.js and polyfills.js ) from the provided source. You must deploy your Angular build to the URL that you expose to the consumers. We convert the script into text and insert it into the script tag to avoid caching issues. You can extract the logic of downloading and script creation into separate scripts and reuse it for a React component wrapper for React app integrations – the approach remains the same. main.js polyfills.js One important note is dealing with styles. You may notice that angular.json doesn't have a styles field. This is intentional. If you leave this field, the builder creates a style.css file, which can override the host application’s styles. By removing this field, the styles are added to the main.js file. Additionally, you can wrap the app in ShadowDOM to ensure that your styles don't override the host styles. angular.json styles style.css main.js ShadowDOM If you use UI libraries and components without styles encapsulation, these approaches won't help – the styles will leak into the host application’s head. Carefully choose the components you use. If you use UI libraries and components without styles encapsulation, these approaches won't help – the styles will leak into the host application’s head. Carefully choose the components you use. Advantages: Advantages: Your Angular application can be integrated into any other application regardless of the framework. Your Angular application can be integrated into any other application regardless of the framework. Easy integration with the host by providing a component with only two inputs – URL and app name (you can omit the name if the URL has only one application). Easy integration with the host by providing a component with only two inputs – URL and app name (you can omit the name if the URL has only one application). In most cases, your application’s styles are encapsulated and don't override the host’s styles. In most cases, your application’s styles are encapsulated and don't override the host’s styles. Disadvantages: Disadvantages: This approach is compatible with Angular 16 and above. Version upgrades can be challenging. This approach is compatible with Angular 16 and above. Version upgrades can be challenging. Path resolution issues. If the host and remote app are on different domains, import paths will resolve within the host domain. You can either remap all your imports after the build (use this only if necessary) or host the remote app on the same domain (or use emulation). Path resolution issues. If the host and remote app are on different domains, import paths will resolve within the host domain. You can either remap all your imports after the build (use this only if necessary) or host the remote app on the same domain (or use emulation). The styles encapsulation problem is not fully solved. The styles encapsulation problem is not fully solved. Conclusion Adopting a micro frontend architecture requires careful planning and consideration of both business and technical factors. The approach described here provides a way to integrate Angular applications into various host environments with minimal effort. While it offers significant advantages, such as framework-agnostic integration and style encapsulation, there are also challenges to address, including compatibility with older Angular versions and path resolution issues. By understanding these trade-offs and planning accordingly, you can effectively implement a micro frontend architecture that meets your project’s needs.

Stories, News & Mentions about TEXTRON

Textron’s Stories on HackerNoon

Textron's News & Mentions