ShapesXR

shapesxr

Last-mile Security for gRPC-connected mobile APIs In , we evaluated for use in mobile applications. We took a look at common operations such as: Consider gRPC for Mobile APIs gRPC A basic request-response API callToken-based authenticationA single request, streaming response API call I concluded that the RPC function call paradigm felt more natural to me than designing and implementing a API implementation, and I said I wouldn’t hesitate to use gRPC with mobile clients when the API is static and well understood. fully-RESTful For mobile apps, is an important capability to strengthen API security, and in this sequel, we’ll examine certificate pinning for gRPC on Android. Spoiler alert — in the end, it’s quite similar to pinning a restful connection. certificate pinning Certificate Pinning is a well accepted and evolving standard to strengthen privacy and message integrity. When establishing a connection, a server endpoint sends its public key certificate to the requesting client. The client follows the certificate chain of trust until it reaches a root certificate it implicitly trusts. Transport Layer Security (TLS) (Source: : image originally via Gary Stevens of ) Wikipedia — chain of trust HostingCanada.org Android and iOS devices maintain an installed set of certificates which they implicitly trust. Unfortunately, it is too easy to trick mobile devices into trusting certificates signed by unexpected certificate authorities. Diagnostic tools, such as , use this same technique to intercept and potentially interfere with encrypted HTTPS streams. mitmproxy On mobile devices, should be used to limit trust to website leaf certificates or only those intermediate or root authorities trusted by the app itself. You can pin against the certificates, their public keys, or hashes of their public keys. Options for storing these certificate or key pins include: certificate pinning : Embedding the pins inside the distributed app package is usually the easiest to implement. Upgrading the pin set, though, requires an app field upgrade, so it is recommended to install multiple leaf and intermediate pins with each release. Preloading (TOFU): endpoints’ public keys are determined on first use after installation or upgrade. Security depends on the security of the environment at first use. Trust on First Use : Request pins from a trusted server. How to you trust the pin server? Perhaps you pin the pin server! If the pin server is stable, this allows you to manage a dynamic set of endpoints without requiring application upgrades for each change of served pins. Upgrades are only required if the pin server’s certificates change. It’s an interesting trade off and the subject of a future post. Pin Server When verifying the pinning certificates, the client verifies both the certificate’s signature and the requested hostname. Because the same IP address may share multiple hostnames, is a TLS extension which enables a client to request a specific certificate by virtual hostname. In addition to its use in virtual hosting, this technique simplifies debugging self-signed certificates served from localhost. Server Name Indication Pinning gRPC Managed Channels With gRPC, a client makes an to a interface which, through a , sends one or more proto request messages to and receives one or more response messages from the server. In , we used a plain managed channel for our transport. To pin the channel, we will enable TLS (SSL) and create our own set of trusted certificates, separate from the certificates already installed on the device. We’ll use Android for our examples. rpc call stub channel Consider gRPC for Mobile APIs First, we will build our own keystore within our demonstration app. For convenience, we store a set of public key certificates as raw resources, and we identify those resources in a certs.xml resource file: <?xml version="1.0" encoding="utf-8"?> < resources > < integer-array name = "certs" > < item > @raw/localhost </ item > < item > @raw/otherhost </ item > </ integer-array > </ resources > The keystore is created when the ShapesActivity is started, and the keystore and a server name override are passed to our pinned managed channel, PinnedChannelBuilder: rawCerts = getResources().obtainTypedArray(certsId);

    ks = KeyStore.getInstance(KeyStore.getDefaultType()); InputStream certIS = getResources(). X509Certificate cert = (X509Certificate) cf.generateCertificate(certIS); } } }

@Override int port = getResources().getInteger(R.integer.port); KeyStore certsKS = createPinnedKeyStore(R.array.certs);

  channel = PinnedChannelBuilder.build(host, port, 
      serverHostOverride, certsKS);
} // build a key store from a set of raw certificates KeyStore createPinnedKeyStore ( int certsId ) { TypedArray rawCerts = null ; KeyStore ks = null ; try { ks.load( null , null ); CertificateFactory cf = CertificateFactory.getInstance( "X.509" ); for (int i = 0 ; i < rawCerts.length(); ++i) { openRawResource(rawCerts.getResourceId(i, - 1 )); ks.setCertificateEntry( "cert" + i, cert); } catch (Exception e) { throw new RuntimeException(e); } finally { if (rawCerts != null ) rawCerts.recycle(); return ks; protected void onCreate ( Bundle savedInstanceState ) { super .onCreate(savedInstanceState); // ... // open grpc managed channel String host = getResources().getString(R.string.host); String serverHostOverride = "localhost" ; We override the server name so that the server will respond with an end-entity certificate whose common name (CN) matches what we have pinned. The PinnedChannelBuilder we are building will use a customized SSLSocketFactory to make its connections. Java’s security and networking stack make this a bit tedious, requiring 1) building a javax.net.ssl.TrustManagerFactory containing our java.security.KeyStore, 2) creating a javax.net.ssl.SSLContext containing this TrustManagerFactory, and 3) exposing the javax.net.ssl.SSLSocketFactory from within the SSLContext: ManagedChannelBuilder<?> channelBuilder = 
        ManagedChannelBuilder.forAddress(host, port) channelBuilder.overrideAuthority(serverHostOverride);
    } ((OkHttpChannelBuilder) channelBuilder).useTransportSecurity();
      ((OkHttpChannelBuilder) channelBuilder).
          sslSocketFactory(getSslSocketFactory(certsKS)); } } throws Exception { TrustManagerFactory tmf = TrustManagerFactory.
        getInstance(TrustManagerFactory.getDefaultAlgorithm());
    tmf.init(certsKS); }
} public class PinnedChannelBuilder { public static ManagedChannel build ( String host, int port, @Nullable String serverHostOverride, KeyStore certsKS ) { .maxInboundMessageSize( 16 * 1024 * 1024 ); if (serverHostOverride != null ) { // Force the hostname to match the cert the server uses. try { } catch (Exception e) { throw new RuntimeException(e); return channelBuilder.build(); private static SSLSocketFactory getSslSocketFactory(KeyStore certsKS) if (certsKS == null ) throw new RuntimeException( "No pinning Certificates found" ); // initialize trust manager factor from certs keystore // initialize SSL context from trust manager factory SSLContext context = SSLContext.getInstance( "TLS" ); context.init( null , tmf.getTrustManagers() , null ); // return socket factory from the SSL context return context.getSocketFactory(); Though cumbersome, this is not much different than building a custom socket factory for a restful HTTPS connection, although many networking stacks and have convenience methods to hide this complexity. Android N Trying It Out To try it out, we use the same shapes demo application we used previously. We are running a gRPC server on localhost serving a shapes.proto API to a shapes app running in a local Android emulator. First, we’ll generate a self-signed private key, public-key certificate pair for localhost using : openssl ............................................++
..................................................................++ -----.
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank ----- State or Province Name (full name) []:
Locality Name (eg, city) []:
Organization Name (eg, company) []:
Organizational Unit Name (eg, section) []:
Common Name (eg, fully qualified host name) []:localhost
Email Address []:

$ $ openssl req -newkey rsa: 4096 -nodes -keyout localhost.key -x509 -days 365 -out localhost.crt Generating a 4096 bit RSA private key writing new private key to 'localhost.key' For some fields there will be a default value, If you enter '.' , the field will be left blank. Country Name ( 2 letter code) []: The localhost.crt certificate file should be copied into the shape app’s raw resources directory (app/src/main/res/raw/). Similarly, we generate an otherhost.crt certificate file and also copy it to the raw resource directory. We’ll install both the localhost.key private key and the localhost.crt certificate files into our gRPC server. gRPC servers are commonly configured for mutual-SSL. Our client is pinning the gRPC server and not the other way around, so ensure mutual SSL is disabled. Now we fire up the app. The managed channel requests the localhost certificate from the server, and the channel is successfully pinned upon connection. Hitting the Stream button, we see the expected response: To test the pinning, we delete the localhost certificate from the app and restart. This time the server delivers the localhost certificate, but the trust manager finds no matching pinned certificate, so the channel connection fails: To keep it simple, we have only shown self-signed leaf certificates. A better practice would be to pin on intermediate certificates. Square’s is an excellent resource for generating your own test certificate authority and longer key chains if you would like to explore these scenarios. certstrap tool Wrapping Up On Android, we were able to demonstrate a pinned gRPC channel, and it really wasn’t any more difficult than pinning a restful HTTPS connection. Including , we have demonstrated: Consider gRPC for Mobile APIs A basic request-response API call Token-based authentication A single request, streaming response API call Pinned TLS connections to the server gRPC’s function call paradigm, along with gRPC’s ability to generate both client and server API interfaces for many target languages from a single proto file and our demonstration of basic and secure API functionality, makes gRPC a reasonable approach for mobile API development.

How to Pin Mobile gRPC Connections

One very important thing in the software development process that is often overlooked in the early stages of a project is API documentation. One of the solutions to this problem is frameworks for the automatic generation of documentation. In the case of dividing the project into microservices and using Event-Driven architecture, the interaction between services is built using events transmitted through the message broker. To generate documentation in the case of an Event-Driven architecture, there is . AsyncAPI is an open-source initiative that seeks to improve the current state of Event-Driven Architecture (EDA). AsyncApi has several Java tools that allow you to generate documentation from code. In , I described how to set up one of these tools. AsyncApi this article springwolf In this article, I would like to tell you how I solved the following task, namely the generation of DTOs using the JSON documentation that springwolf generates. Problem The documentation structure that spring wolf generates looks like this: {
  "service": {
    "serviceVersion": "2.0.0",
    "info": {
      //block with service info
    },
    "servers": {
      "kafka": {
        //describe of kafka connection
      }
    },
    "channels": {
      "kafka-channel": {
        "subscribe": {
          //...
          "message": {
            "oneOf": [
              {
                "name": "pckg.test.TestEvent",
                "title": "TestEvent",
                "payload": {
                  "$ref": "#/components/schemas/TestEvent"
                }
              }
            ]
          }
        },
        //...
      }
    },
    "components": {
      "schemas": {
        "TestEvent": {
          //jsonschema of component
        }
      }
    }
  }
} Since jsonschema is used to describe the components in the documentation, I decided to use the library to solve this problem. However, in the process of trying to implement my plan, I ran into several problems: jsonschema2pojo you need to additionally parse the JSON document to extract objects that describe the components. Since jsonschema2pojo takes jsonschema objects as input, they are in the components block. jsonschema2pojo does not work well with polymorphism and does not handle standard references from oneOf block that are in AsyncAPI. The description of inheritance requires special fields in the schema (extends.javaType), which cannot be added to the AsyncAPI documentation simply. since the generated classes in our case should be used to deserialize messages from the broker, it is necessary to add Jackson annotations describing descriptors and subtypes. All these problems led me to the need to implement my wrapper over jsonschema2pojo, which will extract the necessary information from the documentation, support polymorphism, and add Jackson annotations. The result is a Gradle plugin with which you can generate DTO classes for your project using the springwolf API. Next, I will try to demonstrate how to annotate classes for documentation and how to use the plugin. Springwolfdoc2dto Documentation setup Here I would like to consider the specifics of when generation for non-primitive types such as Enum and Map. And also describe the necessary actions for polymorphism. Let's look at the following message: @Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class TestEvent implements Serializable {

    private String id;
    private LocalDateTime occuredOn;
    private TestEvent.ValueType valueType;
    private Map<String, Boolean> flags;
    private String value;

    public enum ValueType {

        STRING("STRING"),
        BOOLEAN("BOOLEAN"),
        INTEGER("INTEGER"),
        DOUBLE("DOUBLE");
        
        private final String value;

        public ValueType(String value) {
            this.value = value;
        }
    }
} The jsonschema for such a message would look like this: {
  "service": {
    //...
    "components": {
      "schemas": {
        "TestEvent": {
          "type": "object",
          "properties": {
            "id": {
              "type": "string",
              "exampleSetFlag": false
            },
            "occuredOn": {
              "type": "string",
              "format": "date-time",
              "exampleSetFlag": false
            },
            "valueType": {
              "type": "string",
              "exampleSetFlag": false,
              "enum": [
                "STRING",
                "BOOLEAN",
                "INTEGER",
                "DOUBLE"
              ]
            },
            "flags": {
              "type": "object",
              "additionalProperties": {
                "type": "boolean",
                "exampleSetFlag": false
              },
              "exampleSetFlag": false
            },
            "value": {
              "type": "string",
              "exampleSetFlag": false
            }
          },
          "example": {
            "id": "string",
            "occuredOn": "2015-07-20T15:49:04",
            "valueType": "STRING",
            "flags": {
              "additionalProp1": true,
              "additionalProp2": true,
              "additionalProp3": true
            }
          },
          "exampleSetFlag": true
        }
      }
    }
  }
} When generating DTO classes, we will get the following class structure. You can see that Enum is processed as in the original version, however, the collection of type has turned into a separate class Flags and the entire value of the collection itself will fall into the field. Map<String, Boolean> Flags.additionalProperties package pckg.test;

// import

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "id",
    "occuredOn",
    "valueType",
    "flags",
    "value"
})
@Generated("jsonschema2pojo")
public class TestEvent implements Serializable
{
    @JsonProperty("id")
    private String id;
    @JsonProperty("occuredOn")
    private LocalDateTime occuredOn;
    @JsonProperty("valueType")
    private TestEvent.ValueType valueType;
    @JsonProperty("flags")
    private Flags flags;
    @JsonProperty("value")
    private String value;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new LinkedHashMap<String, Object>();
    private final static long serialVersionUID = 7311052418845777748L;

    // Getters ans Setters

    @Generated("jsonschema2pojo")
    public enum ValueType {

        STRING("STRING"),
        BOOLEAN("BOOLEAN"),
        INTEGER("INTEGER"),
        DOUBLE("DOUBLE");
        private final String value;
        private final static Map<String, TestEvent.ValueType> CONSTANTS = new HashMap<String, TestEvent.ValueType>();

        static {
            for (TestEvent.ValueType c: values()) {
                CONSTANTS.put(c.value, c);
            }
        }

        ValueType(String value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return this.value;
        }

        @JsonValue
        public String value() {
            return this.value;
        }

        @JsonCreator
        public static TestEvent.ValueType fromValue(String value) {
            TestEvent.ValueType constant = CONSTANTS.get(value);
            if (constant == null) {
                throw new IllegalArgumentException(value);
            } else {
                return constant;
            }
        }
    }
}


@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({

})
@Generated("jsonschema2pojo")
public class Flags implements Serializable
{

    @JsonIgnore
    private Map<String, Boolean> additionalProperties = new LinkedHashMap<String, Boolean>();
    private final static long serialVersionUID = 7471055390730117740L;

    //getters and setters

} Polymorphism And now let's look at how to provide a polymorphism option. This is relevant when we want to send several message subtypes to one broker topic and implement our listener for each subtype. To do this, we need to add a parent class to the list of providers and add the @Schema annotation from swagger to it. @NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Getter
@Setter(AccessLevel.PROTECTED)
@EqualsAndHashCode
@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.EXISTING_PROPERTY,
    property = "type",
    visible = true,
    defaultImpl = ChangedEvent.class
)
@JsonSubTypes(value = {
    @JsonSubTypes.Type(name = ChangedEvent.type, value = ChangedEvent.class),
    @JsonSubTypes.Type(name = DeletedEvent.type, value = DeletedEvent.class)
})
@JsonIgnoreProperties(ignoreUnknown = true)
@Schema(oneOf = {ChangedEvent.class, DeletedEvent.class},
discriminatorProperty = "type",
discriminatorMapping = {
    @DiscriminatorMapping(value = ChangedEvent.type, schema = ChangedEvent.class),
    @DiscriminatorMapping(value = DeletedEvent.type, schema = DeletedEvent.class),
})
public abstract class DomainEvent {
    @Schema(required = true, nullable = false)
    private String id;
    
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime occuredOn = LocalDateTime.now();
    
    public abstract String getType();
}

/**
* Subtype ChangedEvent
*/
public class ChangedEvent
    extends DomainEvent
    implements Serializable
{
    public static final String type = "CHANGED_EVENT";
    private String valueId;
    private String value;
}

/**
* Subtype DeletedEvent
*/
public class DeletedEvent
    extends DomainEvent
    implements Serializable
{
    public static final String type = "DELETED_EVENT";
    private String valueId;
 } In this case, the description of the components in the documentation will change as follows: "components": {
    "schemas": {
        "ChangedEvent": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "occuredOn": {
                    "type": "string",
                    "format": "date-time",
                    "exampleSetFlag": false
                },
                "value": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "valueId": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "type": {
                     "type": "string",
                     "exampleSetFlag": false
                }
            },
            "example": {
                "id": "string",
                "occuredOn": "2015-07-20T15:49:04",
                "value": "string",
                "valueId": "string",
                "type": "CHANGED_EVENT"
            },
            "exampleSetFlag": true
        },
        "DeletedEvent": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "occuredOn": {
                    "type": "string",
                    "format": "date-time",
                    "exampleSetFlag": false
                },
                "valueId": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "type": {
                    "type": "string",
                    "exampleSetFlag": false
                }
            },
            "example": {
                "id": "string",
                "occuredOn": "2015-07-20T15:49:04",
                "valueId": "string",
                "type": "DELETED_EVENT"
            },
            "exampleSetFlag": true
        },
        "DomainEvent": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "string",
                    "exampleSetFlag": false
                },
                "occuredOn": {
                    "type": "string",
                    "format": "date-time",
                    "exampleSetFlag": false
                },
                "type": {
                    "type": "string",
                    "exampleSetFlag": false
                }
            },
            "example": {
                "id": "string",
                "occuredOn": "2015-07-20T15:49:04",
                "type": "string"
            },
            "discriminator": {
                "propertyName": "type",
                "mapping": {
                    "CHANGED_EVENT": "#/components/schemas/ChangedEvent",
                    "DELETED_EVENT": "#/components/schemas/DeletedEvent"
                }
            },
            "exampleSetFlag": true,
            "oneOf": [
                {
                    "$ref": "#/components/schemas/ChangedEvent",
                    "exampleSetFlag": false
                },
                {
                    "$ref": "#/components/schemas/DeletedEvent",
                    "exampleSetFlag": false
                }
            ]
        }
    }
} After that, the plugin will take into account the links from the oneOf block and the described discriminators. As a result, we get the following class structure. package pckg.test;

// import

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "id",
    "occuredOn",
    "type"
})
@Generated("jsonschema2pojo")
@JsonTypeInfo(property = "type", use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, visible = true)
@JsonSubTypes({
    @JsonSubTypes.Type(name = "CHANGED_EVENT", value = ChangedEvent.class),
    @JsonSubTypes.Type(name = "DELETED_EVENT", value = DeletedEvent.class)
})
public class DomainEvent implements Serializable
{

    @JsonProperty("id")
    protected String id;
    @JsonProperty("occuredOn")
    protected LocalDateTime occuredOn;
    @JsonProperty("type")
    protected String type;
    @JsonIgnore
    protected Map<String, Object> additionalProperties = new LinkedHashMap<String, Object>();
    protected final static long serialVersionUID = 4691666114019791903L;

    //getters and setters

}

// import

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "id",
    "occuredOn",
    "valueId",
    "type"
})
@Generated("jsonschema2pojo")
public class DeletedEvent
    extends DomainEvent
    implements Serializable
{

    @JsonProperty("id")
    private String id;
    @JsonProperty("occuredOn")
    private LocalDateTime occuredOn;
    @JsonProperty("valueId")
    private String valueId;
    @JsonProperty("type")
    private String type;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new LinkedHashMap<String, Object>();
    private final static long serialVersionUID = 7326381459761013337L;

    // getters and setters

}


package pckg.test;

//import

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "id",
    "occuredOn",
    "value",
    "type"
})
@Generated("jsonschema2pojo")
public class ChangedEvent
    extends DomainEvent
    implements Serializable
{
    @JsonProperty("id")
    private String id;
    @JsonProperty("occuredOn")
    private LocalDateTime occuredOn;
    @JsonProperty("value")
    private String value;
    @JsonProperty("type")
    private String type;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new LinkedHashMap<String, Object>();
    private final static long serialVersionUID = 5446866391322866265L;

    //getters and setters

} Plugin setup To connect the plugin, you need to add it to the gradle.build file and specify the parameters: folder was to generate DTO package of new classes springwolf documentation URL the root name in the documentation, usually the name of the service plugins {
    id 'io.github.stepanovd.springwolf2dto' version '1.0.1-alpha'
}

springWolfDoc2DTO{
    url = 'http://localhost:8080/springwolf/docs'
    targetPackage = 'example.package'
    documentationTitle = 'my-service'
    targetDirectory = project.layout.getBuildDirectory().dir("generated-sources")
} Run task using bash command: ./gradle -q generateDTO Conclusion In this article, I described how you can use the plugin to generate new DTO classes based on the AsyncApi documentation. At the same time, new classes will be according to original inheritance and contain Jackson annotations for correct deserialization. I hope you find this plugin useful to you. springwolfdocs2dto

Event-Driven Architecture: Automatic DTO Generation From Event Documentation

Arquitectura impulsada por eventos: generación automática de DTO a partir de documentación de eventos

Architecture pilotée par les événements : génération automatique de DTO à partir de la documentation des événements

इवेंट-ड्रिवेन आर्किटेक्चर: इवेंट डॉक्यूमेंटेशन से स्वचालित डीटीओ जनरेशन

イベント駆動型アーキテクチャ: イベント ドキュメントからの自動 DTO 生成

Arquitetura orientada a eventos: geração automática de DTO a partir da documentação do evento

Kiến trúc theo hướng sự kiện: Tạo DTO tự động từ tài liệu sự kiện

事件驱动架构：从事件文档自动生成 DTO

One very important thing in the software development process that is often overlooked in the early stages of a project is API documentation. Very often there are situations when developers do not describe the current API services due to tight deadlines or insufficient motivation, they plan to take up this task in the future. As a result, as the project grows, a large number of methods, parameters, and data formats appear, the description of which requires a huge amount of time and effort. This problem is especially critical when the development team is divided into small teams, such as front-end and back-end developers. In this case, without documentation, many problems can arise during the implementation process and a lot of time is spent on meetings and discussions of already implemented methods. Knowledge is passed orally from developer to developer. One of the solutions to this problem is frameworks for the automatic generation of documentation. For example, web applications often use swagger or its derivatives to describe REST APIs. This allows you to document the interfaces by which the front-end and back-end services interact. Swagger is a really good tool, but the interaction between different parts of the system is not limited to the REST API. In the case of dividing the project into microservices and using the Event-driven architecture, the interaction between services is built using events shared through the message broker. And each microservice is handled by a separate development team. It's reasonable to consider automatically documenting the events that are exchanged between services, just as swagger describes the REST API. In this article, we will look at how to enable automatic event documentation for services implemented using Spring Boot with interaction through Apache Kafka. Apache Kafka is a distributed streaming platform that allows you to process trillions of events per day. Kafka guarantees low latency, and high throughput provides fault-tolerant publish/subscribe pipelines and allows you to process event streams. To solve our problem, there is AsyncApi. AsyncAPI is an open source initiative that seeks to improve the current state of Event-Driven Architectures (EDA). AsyncApi has several Java tools that allow you to generate documentation from code. Springwolf is my choice because it provides a UI similar to springfox. Gradle dependencies To get started, we need to add dependencies to gradle.build implementation 'org.springframework.cloud:spring-cloud-starter-stream-kafka:3.2.2'
implementation 'javax.json:javax.json-api:1.1.4'
implementation 'org.glassfish:javax.json:1.1.4'

compileOnly 'org.projectlombok:lombok'

// Provides the documentation API
implementation 'io.github.springwolf:springwolf-kafka:0.6.1'
runtimeOnly 'io.github.springwolf:springwolf-ui:0.4.0' Description of events First, we need to define the events that we will send or expect from the topic. I will create an abstract DomainEvent class that will be extended with specific events and define serialization and deserialization rules in it using Jackson annotations. @NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Getter
@Setter(AccessLevel.PROTECTED)
@EqualsAndHashCode
@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        property = "type",
        visible = true,
        defaultImpl = EntityChangedEvent.class
)
@JsonSubTypes(value = {
        @JsonSubTypes.Type(name = EntityChangedEvent.type, value = EntityChangedEvent.class),
        @JsonSubTypes.Type(name = EntityDeletedEvent.type, value = EntityDeletedEvent.class),
        @JsonSubTypes.Type(value = EntityChangedEvent.class)
})
@JsonIgnoreProperties(ignoreUnknown = true)
public abstract class DomainEvent {

    private String id;

    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime occuredOn = LocalDateTime.now();

    public abstract String getType();

} Change event class. @NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Setter(AccessLevel.PRIVATE)
@EqualsAndHashCode(callSuper = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class EntityChangedEvent extends DomainEvent {
    public static final String type = "ENTITY_CHANGED_EVENT";

    private String title;
    private String description;
    private String code;
    @NonNull
    private String entityId;  

    @Builder
    public EntityChangedEvent(
            String id,
            @NonNull String entityId,
            @NonNull String code, 
            String title,
            String description
    ) {
        super(id, LocalDateTime.now());

        if(StringUtils.isAllBlank(title, description)) {
            throw new IllegalStateException("changes is none");
        }

        this.entityId = entityId;
        this.code = code;

        this.title = title;
        this.description = description;
    }

    @Override
    public String getType() {
        return type;
    }
} Delete event class @NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Setter(AccessLevel.PRIVATE)
@EqualsAndHashCode(callSuper = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class EntityDeletedEvent extends DomainEvent {
    public static final String type = "ENTITY_DELETED_EVENT";
    @NonNull
    private String entityId;

    @Builder
    public EntityDeletedEvent(
            String id,
            @NonNull String valueId
    ) {
        super(id, LocalDateTime.now());
        this.valueId = valueId;
    }

    @Override
    public String getType() {
        return type;
    }
} Configuring Consumers and KafkaListeners After describing the event classes, we can move on to the listener configuration. To do this, we will get the configurations class KafkaConsumerConfig, in which we will initiate Beans for the ConcurrentKafkaListenerContainerFactory. We will also define the component KafkaListeners for our factory. If there are several factories, for example, if we have several families of events that need to be divided, then for each it is necessary to create a similar class. /**
Consumer configuration class for initiate factories for event families
*/
@Configuration
public class KafkaConsumerConfig {

    private final String SERVER;
    private final String SERVER_PORT;
    private final String GROUP;

    public KafkaConsumerConfig(
            @Value("${spring.cloud.stream.bindings.service-out-0.group}") String group,
            @Value("${spring.cloud.stream.kafka.binder.brokers}") String server,
            @Value("${spring.cloud.stream.kafka.binder.defaultBrokerPort}") String port
    ) {
        this.GROUP = group;
        this.SERVER = server;
        this.SERVER_PORT = port;
    }

/*
each key will be serialized to String and each event will be serialized to JSON
*/
    private <T> ConsumerFactory<String, T> typeConsumerFactory(Class<T> clazz) {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, String.format("%s:%s", SERVER, SERVER_PORT));
        props.put(ConsumerConfig.GROUP_ID_CONFIG, GROUP);

        return new DefaultKafkaConsumerFactory<>(
                props,
                new StringDeserializer(),
                new JsonDeserializer<>(clazz));
    }

    private <T> ConcurrentKafkaListenerContainerFactory<String, T> initFactory(Class<T> clazz) {
        ConcurrentKafkaListenerContainerFactory<String, T> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(typeConsumerFactory(clazz));
        return factory;
    }

/*
init bean factory for abstract DomainEvent. This factory accept all subclasses of DomainEvent
*/
    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, DomainEvent> domainEventKafkaListenerContainerFactory() {
        return initFactory(DomainEvent.class);
    }

} KafkaListener class must be define for each factory. @Component
@Log
@KafkaListener(
        topics = "topic-test",
        groupId="group-test",
        containerFactory="domainEventKafkaListenerContainerFactory")
public class KafkaListeners {

    @KafkaHandler
    void entityChangedKafkaListener(@Payload EntityChangedEvent message) {
        log.info(String.format("KafkaHandler[EntityChanged] %s %s %s", message.getType(), message.getEntityId(), message.getId()));
    }

    @KafkaHandler
    void entityDeletedKafkaListener(@Payload EntityDeletedEvent message) {
        log.info(String.format("KafkaHandler[EntityDeleted] %s %s %s", message.getType(), message.getEntityId(), message.getId()));
    }
} springwolf configuration Finally, we can move on to the springwolf configuration. We need to set up information about the application, producers, and consumers. Consumers are configured automatically based on the KafkaListener and KafkaHandler annotations, however, producers must be enumerated manually. The whole config will look something like this. @Configuration
@EnableAsyncApi
public class AsyncApiConfiguration {
    private final String SERVER;
    private final String SERVER_PORT;
    private final String CONSUMERS_BASE_PACKAGE = "consumers.package";
    private final String CHANNEL_NAME;


    public AsyncApiConfiguration(
            @Value("${spring.cloud.stream.bindings.service-out-0.destination}") String channelName,
            @Value("${spring.cloud.stream.kafka.binder.brokers}") String server,
            @Value("${spring.cloud.stream.kafka.binder.defaultBrokerPort}") String port
    ) {
        this.CHANNEL_NAME = channelName;
        this.SERVER = server;
        this.SERVER_PORT = port;
    }

    @Bean
    public AsyncApiDocket asyncApiDocket() {
        //application info
        Info info = Info.builder()
                .version("api version")
                .title("service name")
                .description("description")
                .build();

        //kafka server info
        Server kafkaServer = Server.builder()
                .protocol("kafka")
                .url(String.format("%s:%s", SERVER, SERVER_PORT))
                .build();

        //init producer builder
        KafkaProducerData.ProducerDataBuilder producerBuilder = ProducerData.builder()
                .channelName(CHANNEL_NAME)
                .channelBinding(Map.of("kafka", new KafkaChannelBinding()))
                .operationBinding(Map.of("kafka", new KafkaOperationBinding()));

        //list of event types for documentation
        List<Class<?>> events = List.of(
                EntityChangedEvent.class,
                EntityDeletedEvent.class
        );

        //generate producers
        List<ProducerData> producers = events.stream()
                .map(c -> producerBuilder
                        .payloadType(c)
                        .build()
                ).collect(Collectors.toList());

        //build AsyncApiDocket
        return AsyncApiDocket.builder()
                .basePackage(CONSUMERS_BASE_PACKAGE) //package for search KafkaListeners
                .info(info) //application info
                .producers(producers) //producers
                .server("kafka", kafkaServer) //kafka srever info
                .build();
    }
} The interface will be available at . Documentation in JSON format can be found at /springwolf/asyncapi-ui.html /springwolf/docs Conclusion In this article, we looked at how you can set up auto-generation of documentation for an Event-Driven architecture. Do not forget to take care of this at the start of your project to reduce costs in the future. Links https://www.asyncapi.com/docs/tools https://github.com/springwolf/springwolf-core https://springwolf.github.io/docs/quickstart/

Auto-generation of Documentation for Event-driven Architecture

Robots, AI, EW: How War in Ukraine Re-Shapes Military Tech

রোবট, এআই, ইডাব্লু: ইউক্রেনের যুদ্ধ কীভাবে সামরিক প্রযুক্তিকে পুনরায় আকার দেয়

Roboter, KI, elektronische Kriegsführung: Wie der Krieg in der Ukraine die Militärtechnologie verändert

Robots, IA, EW: cómo la guerra en Ucrania remodela la tecnología militar

Robots, IA, guerre électronique : comment la guerre en Ukraine remodèle la technologie militaire

रोबोट, एआई, ईडब्ल्यू: यूक्रेन में युद्ध ने सैन्य तकनीक को कैसे नया रूप दिया

ロボット、AI、電子戦：ウクライナ戦争が軍事技術をどのように変えるか

로봇, AI, EW: 우크라이나 전쟁이 군사 기술을 재편하는 방법

Robôs, IA, EW: como a guerra na Ucrânia remodela a tecnologia militar

Роботы, искусственный интеллект, РЭБ: как война в Украине меняет военную технику

Robotlar, Yapay Zeka, EW: Ukrayna'daki Savaş Askeri Teknolojiyi Nasıl Yeniden Şekillendiriyor?

Robot, AI, EW: Chiến tranh ở Ukraine định hình lại công nghệ quân sự như thế nào

机器人、人工智能、电子战：乌克兰战争如何重塑军事技术

Analyzing Media Polarization: How Broadcast News Language Shapes Online Discourse

মিডিয়া পোলারাইজেশন বিশ্লেষণ করা: কিভাবে সম্প্রচারিত সংবাদ ভাষা অনলাইন আলোচনার আকার দেয়

Analyse der Medienpolarisierung: Wie die Sprache der Nachrichtensendungen den Online-Diskurs prägt

Análisis de la polarización de los medios: cómo el lenguaje de las noticias difundidas da forma al discurso en línea

Analyser la polarisation des médias : comment le langage des informations diffusées façonne le discours en ligne

मीडिया ध्रुवीकरण का विश्लेषण: प्रसारण समाचार की भाषा ऑनलाइन चर्चा को कैसे आकार देती है

メディアの二極化を分析する: 放送ニュース言語がオンラインの言説をどのように形作るか

미디어 양극화 분석: 방송 뉴스 언어가 온라인 담론을 형성하는 방법

Analisando a polarização da mídia: como a linguagem das notícias transmitidas molda o discurso on-line

Анализ поляризации СМИ: как язык вещательных новостей формирует онлайн-дискурс

Medya Kutuplaşmasını Analiz Etmek: Yayın Haber Dili Çevrimiçi Söylemi Nasıl Şekillendiriyor?

Phân tích sự phân cực của phương tiện truyền thông: Ngôn ngữ phát sóng tin tức định hình diễn ngôn trực tuyến như thế nào

分析媒体两极分化：广播新闻语言如何影响网络话语

Why is it important to focus on customer experience? According to global research, global banks lose 20% of their customers, or 1 in 5 customers, due to poor customer experience (Source: 10xbanking). By building more meaningful personal relationships, banks can increase revenue from core customers by up to 20%, according to Accenture's Global Banking Consumer Study. It also shows that more than 30% of banking industry revenue from traditional products such as payments, consumer loans and credit cards comes from third parties, and this figure is expected to grow. Few banks understand the underlying motivations of a particular customer to purchase a particular product, and low satisfaction levels contribute to consumers signing up for financial services products from other providers. Regardless of age, customers are about 2.5 times more likely to purchase bank products embedded in non-bank channels if the product is managed in partnership with a bank. Customer engagement has long ceased to be a top priority for retail or marketing alone, for example. Many companies, practically all businesses, and even more so banks, are trying to do everything to make customer interaction comfortable. Firstly, this is promising, and secondly, customers now primarily pay attention to the convenience of a financial or banking application, its interface and functionality. The customer-oriented approach allows the banking and fintech sector to grow and constantly develop, inventing new opportunities for interaction with customers. What helps you successfully focus on the customer experience? Based on my many years of experience in developing products for the fintech sector, I will highlight the following components: — Real-time data analysis Analyzing data in real time plays a big role. It is the process of collecting, processing and analyzing data as it arrives, without delay or waiting, which plays a big role in today's world, because information is constantly changing or being updated. You can discover hidden patterns or some trends that will help you in future work. Data can be visualized, which is a definite plus. What kind of customer data is available? Geographic data, demographic data, data about what platform he uses to use your app, how much time he spent, etc. All this helps the team to make informed decisions in further development. In addition, getting data quickly allows you to react to and fix any processes that aren't working faster. What does real-time data analysis look like? — Adaptive personalization Personalization and adaptive interfaces are one of the key components of success when working with customers. Personalization is good because the customer can choose the element that meets their expectations. The development of personalized elements should be based on audience analysis and their needs. Adaptive personalization consists of the following elements: Development and implementation of personalization strategies; 2) Individual recommendations on products and services; 3) Personalized communication; 4) Personalized and adaptive user interfaces; 5) Personalized rewards and incentives. — Customer communication management Includes the following channels: social networks and media, messengers and e-mail; intrabank transaction processing systems; other information systems; printed documents; chatbots; online banking; call center automation system; archives; recommendation systems. Communication with the customer through various channels also plays a big role. It is not acceptable that there is no communication at all. It will play a negative role on your reputation and also deprive you of customer loyalty. It is important to communicate with the customer, if only because through this communication you learn about the problems and needs of your customers. — Training and development of staff and / or AI models The training process helps to acquire new skills and knowledge, as well as to improve existing behaviors. Synergetic development allows increasing productivity and achieve success in banking business through continuous development of skills, generation of new offers and creation of unique experience. The learning process of AI models needs to be continuous, due to the rapidly changing landscape of AI technologies. — Customer data integration Customer data is the key to understanding your customers. The data collected can be easily shared with team members, sales and marketing, customer service and, directly, with the executive. By integrating the data, you can get an improved view of your customers to understand them more deeply. Key Benefits: To summarize, we would like to mention the following benefits that you get by incorporating technology in this field: — Increased customer satisfaction; — Increased customer loyalty; — Increase in average revenue per customer; — Increased cross-selling; — Increased customer retention rate; — Increase conversion rate. Utilizing new technologies and staying on top of trends will allow you to take a step forward and set yourself apart from the competition. Why is it important to focus on customer experience? Why is it important to focus on customer experience? Why is it important to focus on customer experience? According to global research, global banks lose 20% of their customers, or 1 in 5 customers, due to poor customer experience (Source: 10xbanking ). By building more meaningful personal relationships, banks can increase revenue from core customers by up to 20%, according to Accenture's Global Banking Consumer Study . It also shows that more than 30% of banking industry revenue from traditional products such as payments, consumer loans and credit cards comes from third parties, and this figure is expected to grow. 10xbanking 10xbanking Accenture's Global Banking Consumer Study Accenture's Global Banking Consumer Study Few banks understand the underlying motivations of a particular customer to purchase a particular product, and low satisfaction levels contribute to consumers signing up for financial services products from other providers. Regardless of age, customers are about 2.5 times more likely to purchase bank products embedded in non-bank channels if the product is managed in partnership with a bank. Customer engagement has long ceased to be a top priority for retail or marketing alone, for example. Many companies, practically all businesses, and even more so banks, are trying to do everything to make customer interaction comfortable. Firstly, this is promising, and secondly, customers now primarily pay attention to the convenience of a financial or banking application, its interface and functionality. The customer-oriented approach allows the banking and fintech sector to grow and constantly develop, inventing new opportunities for interaction with customers. What helps you successfully focus on the customer experience? What helps you successfully focus on the customer experience? Based on my many years of experience in developing products for the fintech sector, I will highlight the following components: — Real-time data analysis — Real-time data analysis Analyzing data in real time plays a big role. It is the process of collecting, processing and analyzing data as it arrives, without delay or waiting, which plays a big role in today's world, because information is constantly changing or being updated. You can discover hidden patterns or some trends that will help you in future work. Data can be visualized, which is a definite plus. What kind of customer data is available? Geographic data, demographic data, data about what platform he uses to use your app, how much time he spent, etc. All this helps the team to make informed decisions in further development. In addition, getting data quickly allows you to react to and fix any processes that aren't working faster. What does real-time data analysis look like? What does real-time data analysis look like? — Adaptive personalization — Adaptive personalization Personalization and adaptive interfaces are one of the key components of success when working with customers. Personalization is good because the customer can choose the element that meets their expectations. The development of personalized elements should be based on audience analysis and their needs. Adaptive personalization consists of the following elements: Development and implementation of personalization strategies; Development and implementation of personalization strategies; 2) Individual recommendations on products and services; 3) Personalized communication; 4) Personalized and adaptive user interfaces; 5) Personalized rewards and incentives. — Customer communication management — Customer communication management Includes the following channels: social networks and media, messengers and e-mail; intrabank transaction processing systems; other information systems; printed documents; chatbots; online banking; call center automation system; archives; recommendation systems. Communication with the customer through various channels also plays a big role. It is not acceptable that there is no communication at all. It will play a negative role on your reputation and also deprive you of customer loyalty. It is important to communicate with the customer, if only because through this communication you learn about the problems and needs of your customers. — Training and development of staff and / or AI models — Training and development of staff and / or AI models The training process helps to acquire new skills and knowledge, as well as to improve existing behaviors. Synergetic development allows increasing productivity and achieve success in banking business through continuous development of skills, generation of new offers and creation of unique experience. The learning process of AI models needs to be continuous, due to the rapidly changing landscape of AI technologies. — Customer data integration — Customer data integration Customer data is the key to understanding your customers. The data collected can be easily shared with team members, sales and marketing, customer service and, directly, with the executive. By integrating the data, you can get an improved view of your customers to understand them more deeply. Key Benefits: Key Benefits: To summarize, we would like to mention the following benefits that you get by incorporating technology in this field: — Increased customer satisfaction; — Increased customer loyalty; — Increase in average revenue per customer; — Increased cross-selling; — Increased customer retention rate; — Increase conversion rate. Utilizing new technologies and staying on top of trends will allow you to take a step forward and set yourself apart from the competition.

How IT Shapes The New Customer Experience

United States v. Apple INC Court Filing, retrieved on March 21, 2024 is part of . You can jump to any part in this filing . This part is 5 of 25. HackerNoon’s Legal PDF Series here B. Apple invited third-party investment on the iPhone and then imposed tight controls on app creation and app distribution 41. Apple controls how developers distribute and create apps for iPhone users. For example, developers can only distribute native iPhone apps through Apple’s App Store, which is the only way for users to download native iOS apps. Limiting distribution to the Apple App Store enables Apple to exert monopoly power over developers by imposing contractual restrictions and rules that limit the behavior of non-Apple apps and services. Specifically, Apple sets the conditions for apps it allows on the Apple App Store through its App Store Review Guidelines. Under these guidelines, Apple has sole discretion to review and approve all apps and app updates. Apple selectively exercises that discretion to its own benefit, deviating from or changing its guidelines when it suits Apple’s interests and allowing Apple executives to control app reviews and decide whether to approve individual apps or updates. Apple often enforces its App Store rules arbitrarily. And it frequently uses App Store rules and restrictions to penalize and restrict developers that take advantage of technologies that threaten to disrupt, disintermediate, compete with, or erode Apple’s monopoly power. 42. Apple also controls app creation by deciding which APIs are available to developers when they make third-party apps. For example, developers cannot provide native apps on the iPhone unless they enter into Apple’s non-negotiable Developer Program License Agreement (DPLA). That agreement requires developers to use public APIs only “in the manner prescribed by Apple.” It also prohibits third-party apps from using APIs that Apple designates as “private.” Apple selectively designates APIs as public or private to benefit Apple, limiting the functionality developers can offer to iPhone users even when the same functionality is available in Apple’s own apps, or even select third-party apps. Similar to Apple’s App Store restrictions, Apple uses its DPLA to impose restrictions that penalize and restrict developers that take advantage of technologies that threaten to disrupt, disintermediate, compete with, or erode Apple’s monopoly power. 43. Developers cannot avoid Apple’s control of app distribution and app creation by making web apps—apps created using standard programming languages for web-based content and available over the internet—as an alternative to native apps. Many iPhone users do not look for or know how to find web apps, causing web apps to constitute only a small fraction of app usage. Apple recognizes that web apps are not a good alternative to native apps for developers. As one Apple executive acknowledged, “[d]evelopers can’t make much money on the web.” Regardless, Apple can still control the functionality of web apps because Apple requires all web browsers on the iPhone to use WebKit, Apple’s browser engine—the key software components that third-party browsers use to display web content. 44. Nor can developers rely on alternative app stores even though this would benefit developers and users. For example, developers cannot offer iPhone users an app store that only offers apps curated for use by children, which would provide opportunities to improve privacy, security, and child safety. By contrast, Apple allows certain enterprise and public sector customers to offer versions of app stores with more curated apps to better protect privacy and security. 45. Apple’s control over both app distribution and app creation gives Apple tremendous power. For example, Apple designates as “private” the APIs needed to send Short Message Service, or SMS, text messages, which is a protocol used by mobile carriers since the early 1990s to allow users to send basic text messages to other mobile phone numbers using their own mobile phone numbers. Developers have no technical means to access these private APIs, but even if they did, doing so would breach their developer agreement with Apple, and therefore put the developer at risk of losing the ability to distribute apps through the App Store. For example, Apple prohibits third-party iPhone apps from sending or receiving SMS text messages even though this functionality is available through Apple Messages. Likewise, Apple can control the functionality of third-party apps and accessories through its control of app distribution because if an app includes functionality that Apple does not like, Apple can and does exercise its discretion to simply block the app from the App Store. 46. Apple’s dominance is such that neither app developers nor iPhone users can benefit from lower cost or higher quality means of distributing apps or purchasing and providing digital products and services. Instead, Apple guarantees that it continues to benefit from the contributions of third-party developers and other platform participants while also protecting itself from the competitive threats and pressure those participants pose to Apple’s smartphone monopoly. 47. This complaint focuses on Apple’s use of its dominance to impose contracts and rules that restrict the behavior and design decisions of companies other than Apple. Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case retrieved on March 21, 2024, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. justice.gov

Inside Apple's Stranglehold on App Development and How it Shapes Consumer Choices

As a tech that allows companies to build powerful systems and store data securely, blockchain has found , especially in the field of finance. The decentralization capabilities have also become a valuable asset in political, social, and economic areas. quick adoption Like so many young technologies, blockchain works very well on paper. In fact, blockchain technology has been reviewed from every possible angle and its future is . very promising Despite the glowing reviews, however, we have yet to experience a futuristic world run on blockchain systems. Risks often come from an unexpected source, one that is not necessarily considered when securing blockchain systems: the human factor. The human factor has prevented blockchain from flourishing. This article will look at how and why. System Building Decentralized systems are arguably the most interesting aspect of the blockchain ecosystem. Initially, it promised a true revolution as a financial system not controlled by banks. Human behavior, however, affects the rules and protocol configuration. Selecting or is always determined by the way humans interact with the system, which can allow people to take advantage of it. consensus algorithms security parameters While some architectures can successfully navigate the human factor—such as the , which was originally designed as a captcha mechanism in the early 2000s—multiple architectures are more susceptible to external attacks. For example, happen regularly as a result of asset concentration. proof of work consensus 51% of attacks Another factor to consider is how the blockchain is managed. There are also private blockchains and several decentralized platforms—such as Hyperledger, Corda, and Quorum—but a blockchain can’t be controlled and regulated by a single authority, as that would defeat the purpose. Security And Audits Despite its efficient operation, blockchain cannot create or evolve its security measures. During the process of development, human error can create vulnerabilities within the system. Regular and efficient audits are, therefore, vital. Ideally, every time a new string of code is written, it should be audited and tested separately and with the whole contract. But some cut corners, eager to release the product quickly. External attacks are , and the responsibility for them falls equally on the attacker and the protocol owner. You can’t prevent every attack, but there are mechanisms to contain it or stop it altogether. very common Security has to be an essential part of the whole development process. That’s where consensus audits and attack threat modeling come in. Unlike a code audit, this process involves the initial idea and possibly some block diagrams. Consensus audits review the main rules that need to be followed for a consensus to be reached. Something like passing a law or a bill in the government. Attack threat modeling follows that law analogy and shows what happens if the law is abused. By modeling such situations in advance, you can help prevent them. We encounter this all the time with , especially with experienced companies as they order attack threat modeling to be able to see in advance which types of attacks would be likely used against the architecture. Consulting during the early development stages can provide project owners with the necessary information and help them overview the scope of the work that lies ahead. HashEx There are methods to secure blockchains. All we need is to take advantage of them. Interface And Accessibility One of the primary goals for all blockchain developers is increasing the adoption of this technology. So far it’s been a slow and painful process, mostly due to blockchain’s complexity. Psychologically, we aren’t inclined to use a system that consumes a lot of time and requires extensive education. Humans want and will always choose user-friendly options. That’s what blockchain has to become: user-friendly. Sure, it starts with a code, but it doesn’t have to be complicated. There have been many suggested uses for blockchain in commerce, healthcare or when working with documents. In all cases, one of the main issues preventing adoption is usability. To understand this, here are a few examples that illustrate the practical applications of blockchain: Walmart has been at the into its supply chain management, particularly in the realm of food safety and traceability. By implementing a blockchain-based system, Walmart has enhanced the transparency and efficiency of its supply chain. This technology allows for precise tracking of food items throughout the entire supply chain, from farm to store shelves. The primary goal is to ensure food safety by quickly identifying and addressing any potential issues in the food supply chain. forefront of integrating blockchain technology Another sector where blockchain has made significant strides is in digital identity verification. Estonia's e-Residency program is a pioneering example of how . blockchain can secure personal data In the healthcare industry, blockchain-based systems are being developed to in order to improve the security and interoperability of healthcare information. manage electronic medical records By focusing on user-centric design, blockchain can be made more accessible, encouraging adoption across various industries. What Blockchain Needs Some may disagree, but blockchain doesn’t have the best reputation today. Yes, it’s been an incredible help to many areas, but its notoriety is mostly connected to financial scams and failures of the market. The key to changing that is education. And I don’t just mean educating people about the technology and its advantages. We need to educate professionals to take over the development and management of blockchain-based systems. We have to involve it so it can do more good. And it’s most necessary to fix our previous mistakes. Maximizing the positive effects of this technology should be a priority. Blockchain can’t remain a closed field for a group of skilled experts. For the technology to truly bloom, it has to become accessible. Lead image by Terry on Unsplash

How the Human Element Shapes and Limits Blockchain Development

Fabric.js is an open-source JavaScript library used for creating interactive and high-quality graphics for the web. It's a powerful tool that enables developers to create complex shapes, graphics, and animations on the canvas element of HTML5. Fabric.js simplifies the process of creating and manipulating graphical objects, making it easier for developers to build creative and dynamic web applications. Demo project structure To fully grasp Fabric.js, it's essential to first comprehend the demo project structure. Fabric.js comes with a "demo" folder that includes numerous examples and projects showcasing its capabilities. The demo folder is organized in a user-friendly manner, allowing for easy modification of projects to meet individual requirements. Canvas initializing In order to utilize Fabric.js, a canvas element must be present on your webpage. The initial step for setting up a Fabric.js canvas involves creating an instance of the fabric.Canvas class, which is responsible for managing the graphical objects on the canvas element. To initialize the canvas, the following code can be used: var canvas = new fabric.Canvas('canvasId'); The code requires you to provide the ID of the canvas element that exists on your webpage as "canvasId". After the canvas initialization process is complete, you can begin generating and altering graphical objects on it. Fabric.js is a powerful tool for developing engaging and innovative web applications. Its range of functionalities is extensive, allowing for the effortless creation of intricate shapes, graphics, and animations. By familiarizing yourself with the demo project structure, the process of initializing a canvas, as well as the various other features and functions of Fabric.js, you can elevate your web development projects to new heights. Drawing Objects with Fabric.js Fabric.js is a robust library that enables the creation of diverse shapes and objects. The following section will guide you through the process of drawing multiple objects with the help of Fabric.js. Drawing Rectangles and Ellipses Creating rectangles and ellipses is a simple procedure with Fabric.js. To draw a rectangle, you can utilize the class and specify its essential attributes like height, width, fill color, border color, and border width. In a similar fashion, to draw an ellipse, you can use the class and provide necessary attributes such as radius, fill color, border color, and border width. fabric.Rect fabric.Ellipse The code below illustrates the process of drawing a rectangle and an ellipse using Fabric.js: // Create a rectangle
var rect = new fabric.Rect({
    left: 100,
    top: 100,
    width: 100,
    height: 50,
    fill: 'red',
    stroke: 'black',
    strokeWidth: 2
});

// Create an ellipse
var ellipse = new fabric.Ellipse({
    left: 250,
    top: 100,
    rx: 50,
    ry: 25,
    fill: 'blue',
    stroke: 'black',
    strokeWidth: 2
});

// Add both objects to the canvas
canvas.add(rect, ellipse); Free-hand Drawing With Fabric.js, you can create free-hand shapes by utilizing the class. To draw a free-hand shape, you need to specify an array of points that determine the path's outline. The code below illustrates how to draw a free-hand shape using Fabric.js: fabric.Path // Create a free-hand path
var path = new fabric.Path('M 0 0');

// Set the stroke color and width

path.set({
    stroke: 'green',
    strokeWidth: 5
});

// Add the path to the canvas
canvas.add(path);


// Listen for mouse down event to start drawing the path
canvas.on('mouse:down', function(event) {
    var pointer = canvas.getPointer(event.e);
    path.path[0][1] = pointer.x;
    path.path[0][2] = pointer.y;

    canvas.renderAll();
});


// Listen for mouse move event to continue drawing the path
canvas.on('mouse:move', function(event) {
    if (!path.path.length) return;
    var pointer = canvas.getPointer(event.e);

    path.path.push(['L', pointer.x, pointer.y]);
    canvas.renderAll();
});


// Listen for mouse up event to stop drawing the path
canvas.on('mouse:up', function(event) {
    path.setCoords();
    canvas.renderAll();
}); Line-dashed Line With Fabric.js, you have the ability to create dashed lines using the fabric.Line class. To achieve this, simply specify the strokeDashArray attribute, which requires an array of numbers to determine the length of both the dashes and gaps within the line. The example code below demonstrates how to use Fabric.js to draw a dashed line: // Create a dashed line
var line = new fabric.Line([50, 50, 250, 50], {
    stroke: 'black',
    strokeWidth: 2,
    strokeDashArray: [5, 2]
});

// Add the line to the canvas
canvas.add(line); Polygon Fabric.js also facilitates the creation of polygons. To draw a polygon, you must specify the points attribute, which is an array of numbers representing the x and y coordinates of each point in the polygon. The code below demonstrates how to draw a polygon using Fabric.js: var polygon = new fabric.Polygon([{
    x: 150,
    y: 50
}, {
    x: 225,
    y: 150
}, {
    x: 150,
    y: 250
}, {
    x: 75,
    y: 150
}], {
    fill: 'orange',
    stroke: 'black',
    strokeWidth: 5
}) Working with Events In web development, events refer to actions or occurrences that happen within a webpage, which may be initiated by a user, an external system, or internal browser functions. Fabric.js offers a comprehensive event system that enables you to define actions in response to user interactions with your canvas and its objects. Mouse events are among the most widely used events in web development. In Fabric.js, you can listen for and react to various mouse events, including click, double-click, hover, press, and release. These events are linked to canvas objects and can be utilized to execute custom actions of your choosing. For instance, you could create a click event that changes the color of a shape or launches a custom popup when an object is double-clicked. Keyboard events are another crucial type of event that you can utilize in Fabric.js. These events let you respond to user keyboard input within your canvas. You can use this to control the behavior of objects within the canvas, such as moving them in response to arrow key input or applying a transformation with another key. Additionally, the Fabric.js event system includes object events that are triggered when a particular canvas object is interacted with. For example, you could define a custom event that fires when a specific shape is clicked or double-clicked. These object events can be used to create custom interactions and functionality within your canvas. To work with events in Fabric.js, you need to define an event listener function that is attached to either the canvas or specific objects within it. The function will then execute whenever the event is triggered. For example, to respond to a click event on a canvas, you could define a function as shown below: // Create a new canvas
var canvas = new fabric.Canvas('canvas');

// Add a rectangle object to the canvas
var rect = new fabric.Rect({
  left: 100,
  top: 100,
  width: 50,
  height: 50,
  fill: 'red'
});
canvas.add(rect);

// Define a function to handle the click event
function handleClick(event) {
  console.log('Rectangle clicked!');
  rect.set('fill', 'blue');
  canvas.renderAll();
}

// Add a click event listener to the rectangle object
rect.on('mousedown', handleClick); Tips for Optimizing Fabric.js Performance Optimizing performance is crucial for Fabric.js, not just for debugging and troubleshooting, but also for ensuring maximum efficiency and speed. Here are a few helpful tips to help you improve the performance of your Fabric.js project: Use caching: Fabric.js provides a powerful caching mechanism that can speed up object rendering and manipulation. Caching frequently used objects and settings can reduce the processing power required to display or modify them. You can learn more about Fabric.js caching by visiting the official documentation page. Preload images: When using images in your Fabric.js project, preloading them before they're used can significantly reduce load times and improve overall performance. Use object pooling: Object pooling is a technique that involves reusing existing objects instead of creating new ones. By reusing objects, you can reduce the amount of memory required to run your Fabric.js project. This technique is especially useful when dealing with large numbers of objects. Minimize DOM interactions: Interacting with the Document Object Model (DOM) can be slow and resource-intensive. To reduce the impact of DOM interactions on your Fabric.js project, use techniques like batching and throttling to minimize the number of interactions required. Optimize animations: Animations can be resource-intensive, so it's important to optimize them for maximum performance. Techniques like using requestAnimationFrame and limiting the number of animations can help improve your Fabric.js performance. By implementing these tips and techniques, you can help ensure that your Fabric.js project runs smoothly and efficiently, with minimal errors and maximum performance. For further information or support, refer to Fabric.js official documentation or visit the Fabric.js community forum. Applications of Fabricjs Fabric.js is a versatile library that can be used to build a wide range of interactive and dynamic web applications. Some examples of what can be built using Fabric.js include: Drawing and editing tools, such as image editors and graphic design software. Interactive games and simulations. E-commerce and product customization applications. Data visualization and reporting tools. Collaborative applications, such as whiteboard and brainstorming tools. Virtual try-on and augmented reality experiences. Educational and training tools, such as interactive tutorials and quizzes. Animated infographics and explainer videos. Responsive and mobile-friendly user interfaces. Customized dashboards and analytics tools. The possibilities with Fabric.js are endless, and its robust features and easy-to-use API make it a powerful tool for web developers looking to create dynamic and engaging user experiences.

A Comprehensive Guide to Working with Objects and Shapes in Fabric.js

According to , the global market for industrial design services stood at $2.2 bln in 2020 and experts project that it will be around $2.9 billion by 2027. This suggests that the global industrial design market is expected to grow by 3.9% yearly. Research and Markets Moreover, under the based on Prudour's research, the Global industrial design revenue is constantly rising and experts believe this its profits will increase from almost $39 million in 2021 to $59.5 million by 2030. Market.us report What is the reason for such an intensive industrial design market development? Let's consider the evolution of the industrial design (ID) sphere. This will help us to understand the these trends better. How Did That All Start? For the first time in history, the German company AEG began to use industrial designers' services. In 1907 the enterprise's owner hired the architect and artist P. Behrens to improve his company's product appearance. Source However, the idea of ID revealed itself much earlier. For example, in the 18th century, an English entrepreneur, J. Wedgwood, used some industrial design concepts as a part of printed fabrics' production. Industrial design concepts were widely used in the USA during the Great Depression that began in 1929. At that time, numerous business owners had to shut down their factories because of significantly decreased incomes. Source Entrepreneurs usually rent out their industrial workshops to get at least some profit. The latter were commonly occupied by artists. The craftsmen frequently lived in deep poverty. Therefore, low workshops' rent prices incredibly attracted them. Industrial Design After World War II The middle of the 20th century is a distinct ID growth and development era. Today, we can see that many of the design solutions that were common for those days, come back to our lives as vintage ideas. Bright colors and round shapes are becoming stylish again. But why did they even appear in the routine lives of people from the 50s? Enhanced simplicity of the household appliances Rationalization of the design was the main trend during the 50s. This was the post-war period so manufacturers couldn’t afford to use too expensive materials to create necessary household appliances such as TV sets, refrigerators, microwave ovens, etc. They needed to make the production process as cheap as possible. That’s why the range of the most popular materials included artificial materials such as glass, plastic, and various metal alloys. The simplest solution was to manufacture household appliances of round shapes. At the same time, the simplicity of these materials allowed manufacturers to play with a wide range of colors. This combination became the most popular design trend of the 50s. In addition, many common household appliances, including radio-phonograph consoles and refrigerator-stove combinations, were just invented during the 50s. Other utensils, such as dishwashers, became available for the middle class. Naturally, the technical characteristics of these devices were quite simple. There were not many extra details, so manufacturers didn’t think about how to integrate them into the designs of their products. Optimism was the rescue WWII was undoubtedly one of the biggest disasters in the history of humanity. It caused not only economic problems, which made manufacturers look for cheap solutions, but also had an extremely negative impact on the mental health of the entire society. Source Because of this, there was a necessity to boost and enhance the feeling of idealism. People were willing to feel real democracy; they wanted to see things more open and simple. The designs of the most common household appliances were quite helpful in fulfilling this aim. The modernist style appeared, and designers started experimenting with different ideas that could make post-war life more optimistic. They achieved this by adding bright hues to the routine lives of ordinary people. Durability becoming the matter Manufacturers realized that people couldn’t afford to buy their products multiple times. The economic conditions weren’t the best. The vast majority of buyers were looking for cost-effective options. That’s why companies had to ensure that the devices they produced would be as durable as possible. One of the most common ways to solve the durability issue was to cover the metal surface with special enamel or liquid plastic. Thanks to this, the surface of the device became more solid. Alongside this, enamel and liquid plastic had unusual visual features, which helped the appliances look more sleek and glossy. Source Evolution of the designer profession One more thing we should take into consideration is the fact that the middle of the 20th century was the time when the US and European cultures started closely interacting. Besides, the US competed against the USSR and tried to promote the idea of the “American dream.” The design of everyday things turned out to be one of the most efficient marketing tools in this promotional campaign. Harley Earl was one the first who understood this. The entrepreneur revolutionized the car production industry – his cars weren’t just vehicles, these were attractive products. Actually, the invention of automobile styling by Harley Earl was the reason why other companies started hiring designers as their full-time staff members. Thus, the designer profession became more popular, creating a better field for competition and accelerating the style's progress. What Is Industrial Design Nowadays About? Source Over the course of time, the industry of household appliance manufacturing has evolved. New technologies, concepts, solutions, and materials have been introduced. Thus, manufacturers started looking for new ideas and combinations of materials. This is why the style from the 50s isn’t the routine anymore, but rather a fashionable trend that is now being replaced by something more creative and functional. Presently, ID helps to solve a lot of manufacturing tasks. Furthermore, business owners can only stay competitive in the global market by applying such a concept within their companies' production processes. That's because modern ID includes the following mottos: Innovations' implementation. For instance, Sony made an audio player, , in 1979. The device allowed listening to music and not disturbing people around, thanks to headphones. The player had plenty of unusual functions for that time. So, it became a revolution in the music sphere. Walkman Providing consumers with easy-to-use products. Here, e.g., Apple is a great example. This company invented a PC mouse ( ) that looked like contemporary analogs. It could work on any surface. Nay, sensor smartphones became popular worldwide because of this company. That's due to Apple creating . The latter was the first sensor smartphone with a truly user-friendly interface. Lisa Mouse iPhone 2G Ensuring products' aesthetics and natural appearance. E.g., shaping an ordinary bottle into a female body profile can significantly increase sales of products in such a container. However, if such a flask has a label with a strict font style, this will alienate consumers. Compliance with current fashion trends. Many brands release restyled versions of their products to match the vogue. Source Also, the popularity of products made from environmentally friendly materials has increased over the past few decades. E.g., in the USA, a supercar, , with a stylish wooden body and even a timbered suspension, was introduced in 2007. Splinter How Does The Demand for Goods Relate to Industrial Design? Well-designed products affect consumers in a similar way to optical illusions. So, customers frequently buy goods with stylish appearances. However, they may have the same quality and number of options as analogs with slightly worse looks. And the worse the design of competitors' products, the better the good with the most stylish appearance will look. Source The stats confirm the information above. Under , based on McKinsey research, manufacturers that use ID concepts receive 32% more income. Also, their shareholders obtain 56% larger returns. So, things' shape changings help not only realize creative ideas but also increase profits. To get more spectacular information on this topic, follow my posts. the uxdesign.cc report Lead image . source

Industrial Design: Why Do Product Shapes Change Over Time?

Stories, News & Mentions about SHAPESXR

Shapesxr’s Stories on HackerNoon