DEV Community: Ângelo Galvão

Julia: Working with vectors and matrices — Part 1

Ângelo Galvão — Wed, 10 Jun 2026 22:29:14 +0000

This is the first post of a series in which I’ll talk about the Julia programming language and how to work with vectors and matrices.
Julia is a high-level, high-performance, dynamic programming language primarily designed for numerical, scientific, and technical computing. It is also open-sourced.
The language is simple and easy to learn, so let’s follow together and learn more about it. In this post, I will discuss the basics of working with vectors and matrices in Julia, but I will not discuss the very basic features, like addition, slicing, or scalar multiplication, because this is common in most programming languages, just use your common sense that it will be useful also work in Julia. I am interested in what makes Julia cool.

Vectors

A vector is an ordered finite list of numbers. It's numbers are member of a domain, like the ℝ (real numbers), or ℂ (complex numbers), or any other number domain.
So, given the following Integer vector:

To declare it in Julia type the following:

x = [ 3, 4, 0, -1]

The result will be something like this:

4-element Vector{Int64}:
  3
  4
  0
 -1

Special Vectors

Zero Vector

You can create special vectors in Julia, for example, if you want to create a vector only containing zeros, use the function zeros():

z = zeros(5)

The result is a zero 5-vector:

5-element Vector{Float64}:
 0.0
 0.0
 0.0
 0.0
 0.0

Ones Vector

Just like the zero vector, to create a vector only containing ones, use the function ones():

o = ones(5)

The result, as you might expect, is:

5-element Vector{Float64}:
 1.0
 1.0
 1.0
 1.0
 1.0

Unit Vector

Unit vector is a vector which one element is 1 and the others are 0. Unit vectors are used in multiple operations in linear algebra and usually are described by eᵢₜₕ, where ith means the index of the number 1 in the n-vector. For example, a 5-vector where the 1 index is 3, conventionally called e₃, is represented like:

# Create a zero matrix, the change the index position to 1
# To declare e₃, just type e\_3 and hit tab.
e₃ = zeros(5); e₃[3] = 1;

The result:

5-element Vector{Float64}:
 0.0
 0.0
 1.0
 0.0
 0.0

Stacked vectors

You can stack vectors one on top of another, like this:

# Notice that the separetor is ;  not ,
stacked = [ x; z; o ]

The result is a new vector containing all the elements of the 3 vectors:

14-element Vector{Float64}:
  3.0
  ...
  0.0
  ...
  1.0

Vector operations

Inner product (dot product)

If you remember linear algebra class, the inner product of two vector an and b is a transpose times b.

a^{T} b = a_{1} b_{1} + a_{2} b_{2} + \dots + a_{n} b_{n}

In Julia, it's implemented like this:

a = [ 1, 2, 3]
b = [4, -5, -6]

# The result of the inner product is -24
# The result variable is aᵀb. In Julia, you can define a variable in various ways.
aᵀb = a'b

You may wondering how I define the variable like that. It is simple! Just type a^T and hit tab. Julia support LaTeX expressions as variable names :-)

Vector norm

The n-vector norm, or Euclidian norm, is the square root of the sum of the squares of its elements — remember Pythagoras theorem?

∥ x ∥ = x_{12} + x_{22} + \dots + x_{n 2}

The euclidian norm is also called 2-norm. Its formula can be represented like this also:

∥ x ∥_{2} = x_{12} + x_{22} + \dots + x_{n 2}

Euclidian norm is the same as 2-norm.

Here is how to implement it in Julia:

# The result will be 3.7416573867739413
two_norm = norm(a) # or norm(a,2)

Infinity norm

There is also other types of norms. For example, the infinity norm return the absolute maximum element on the n-vector.

∥ x ∥_{\infty} = n = 1, 2, \dots, n max ∣ x_{i} ∣

# The result will be 3
inf_norm = norm(a, Inf)

1-norm

The 1-norm return the sum of the absolute values of its elements.

∥ x ∥_{1} = n = 1 \sum n ∣ x_{i} ∣

# The result will be 6
one_norm = norm(a, 1)

Distance

How about calculating the distance between two vectors? The mathematical formula point us to the solution:

d i s t (a, b) = ∥ a - b ∥

So, in Julia, to calculate the distances of two vectors, run the following:

# the result will be 11.789826122551595
distance = norm(a - b) # or norm(b - a), it doesn't matter

Average (or mean)

You can calculate the mean of the vector elements by using the Statistics module. Here is the average formula (where n is size/length and 1 is a ones vector of the same size of n) of the vector:

μ = (1 / n)^{T} a

Here is an example on how to implement in Julia:

using Statistics

# the result is 2.0
# to declare μ, just type \mu and hit the tab key
μ = mean(a)

Standard deviation

Last but not least, the standard deviation is obtained by subtracting from each entry of the vector the mean value of the entries. Confusing? Here is the math formula:

σ = x - a vg (x) 1

using Statistics # don't need to repeat if already declared
# the result is 1.0 
# to declare σ, just type \sigma and hit the tab key
σ = std(a)

Next matrices

This post became long, the next post in this series I will discuss about matrices in Julia. Stay on!

Strimzi: Create a simple Mutual TLS (mTLS) authentication

Ângelo Galvão — Fri, 05 Jun 2026 15:30:17 +0000

You probably already know about Strimzi. Strimzi enables Kafka on Kubernetes, simple as that. So, in this post, I will not talk about Strimzi, but about how to create a simple mTLS authentication on top of it. Follow this post to learn how. I will go directly to the point.

Prerequisites

streams for Apache Kafka operator installed in Openshift Container Platform (it can be the Strimzi community version on vannila Kubernetes also);
openssl tool installed on your machine;
KafkaNodePool already created in the Openshift project;
Kafka distribution/clients in your local environment.

Configure Kafka cluster

The Kafka cluster is created by configuring the Kafka custom resource (CR) in YAML, and applying it to the Openshift cluster. The relevant part of this configuration, for this example, is the listener configuration.

## This is just a snippet of Kafka custom resource
apiVersion: kafka.strimzi.io/v1
kind: Kafka
metadata:
  name: test-kafka-cluster
spec:
  kafka:
    listeners:
      - name: tls
        port: 9093
        type: route
        tls: true        
        authentication:
          type: tls

Notice that in the above configuration, I enabled tls and configured the authentication type as tls. The first enables regular TLS encryption, the second enables TLS authentication, or Mutual TLS, the subject of this post.

When using Strimzi, you are not required to create the user certificate by yourself. Just create the KafkaUser custom resource (CR) so all the certificates will be created automatically by the Strimzi operator. Here is an example of a KafkaUser CR (notice that authentication type is also tls):

apiVersion: kafka.strimzi.io/v1
kind: KafkaUser
metadata:
  labels:
    strimzi.io/cluster: test-kafka-cluster
  name: test-kafka-user
spec:
  authentication:
    type: tls

Verify the creation of Secret with the same name of the created KafkaUser:

oc describe secret test-kafka-user

Five files were created in the Secret by the operator. The output of the command will be something like this:

Name:         test-kafka-user
Namespace:    test-kafka-project
Labels:       app.kubernetes.io/instance=test-kafka-user
              app.kubernetes.io/managed-by=strimzi-user-operator
              app.kubernetes.io/name=strimzi-user-operator
              app.kubernetes.io/part-of=strimzi-test-kafka-user
              strimzi.io/cluster=test-kafka-cluster
              strimzi.io/kind=KafkaUser
Annotations:  <none>

Type:  Opaque

Data
====
ca.crt:         1854 bytes
user.crt:       1521 bytes
user.key:       1704 bytes
user.p12:       2974 bytes
user.password:  32 bytes

That's all for the Kafka cluster side. Now let's create the client.

Running the client

To run the client, we will use both the standard kafka-console-producer.sh and kafka-console-consumer.sh scripts. These scripts are available in the standard Kafka distribution, so you need to download it first.

Before we can run the scripts, we need to get the relevant certificates for the clients. We need the Kafka cluster certificate, that is on the {name-of-kafka-cluster}-cluster-ca-cert Secret, and the KafkaUser certificate, that is on the Secret with the same name. The name of the Kafka cluster is this example is test-kafka-cluster, so the commands to get the certificates from Openshift cluster are:

# Get the Kafka cluster certificate 
oc get secret test-kafka-cluster-cluster-ca-cert \
   -o jsonpath='{.data.ca\.p12}' | base64 -d  > test-kafka-cluster-ca.p12
# Get the KafkaUser certificate 
oc get secret test-kafka-user \
   -o jsonpath='{.data.user\.p12}'  | base64 -d  > test-kakfa-user.p12

Notice that I chose the P12 file, or PKCS 12 file, which is an encrypted archive format for storing certificates; it is not the certificates themselves, but a certificate store (Remember Java KeyStore?).

With both keystores in hand, create the client.property file. This file configure the mTLS, the truststore and the keystore that will be used to communicate with Kafka.

security.protocol=SSL

# Truststore contains the Kafka cluster certificate
ssl.truststore.location=test-kafka-cluster-ca.p12
ssl.truststore.password=PasswdFromSecret
ssl.truststore.type=PKCS12

# Keystore contains the KafkaUser certificate
ssl.keystore.location=test-kakfa-user.p12
ssl.keystore.password=PasswdFromSecret
ssl.keystore.type=PKCS12

# Enable mTLS 
ssl.client.auth=required
ssl.endpoint.identification.algorithm=

Notice that the Kafka cluster certificate is configured as truststore, and the KafkaUser certificate is configured as keystore.

Last, but no least, we need to get the Route URL for accessing the Kafka cluster outside Openshift. We are interested in the bootstrap route. So, to get the route URL, run the following command:

oc get routes

Now we have everything ready to run the client scripts. For producing messages, run the following command:

./kafka-console-producer.sh \
    --bootstrap-server test-kafka-cluster-kafka-tls-bootstrap-test-kafka-project.apps-crc.testing:443 \
    --topic test-topic --command-config /path/to/client.properties

For consuming messages, run the following command:

./kafka-console-consumer.sh \
    --bootstrap-server test-kafka-cluster-kafka-tls-bootstrap-test-kafka-project.apps-crc.testing:443 \
    --topic test-topic --command-config /path/to/client.properties \
    --from-beginning

Extra: Using custom certificate

Maybe you decide to use a custom certificate for your listener. You may be wondering: How can you configure that? How you configure the client to use it?

So, the first thing to do is to create the custom certificate:

# I am using openssl, but you can use Java keytool instead.
openssl req -x509 -nodes -days 365 \
   -newkey rsa:2048 -keyout custom-key.key -out custom-cert.crt

Then, upload it to Kafka cluster:

oc create secret tls custom-certificate --cert=custom-cert.crt \
   --key=custom-key.key

The Kafka CR configuration will be very similar as before, but now with the custom certificate configuration:

## Remember, this is just a snippet of Kafka custom resource, not the full CR
apiVersion: kafka.strimzi.io/v1
kind: Kafka
metadata:
  name: kafka-cluster
spec:
  kafka:
    listeners:
      - name: tls
        port: 9093
        type: route
        tls: true        
        authentication:
          type: tls
        configuration:
          brokerCertChainAndKey:
            certificate: tls.crt
            key: tls.key
            secretName: custom-certificate

If you have good eyes, you noticed that the certificate names are not the same names that we use to create the Secret, but tls.crt and tls.key. This is normal, Openshift changes its names, so, don't worry about it.

On the client side, before you can run the clients, create the PKCS 12 truststore with the custom certificates. I already have them in my working directory, so I don't need to download them from Openshift again, however, if you don't have them in your working directory, download both tls.crt and tls.key from the configured Secret.

Now, with the custom certificates in hand, create the PKCS 12 truststore using openssl (you will be asked to choose a password):

openssl pkcs12 -export -out custom-certificate.p12  -inkey custom-key.key -in custom-cert.crt

The modify the client.property file with the new truststore:

# Snippet of client.property file
# Truststore contains the new custom Kafka cluster certificate
ssl.truststore.location=custom-certificate.p12
ssl.truststore.password=passwd
ssl.truststore.type=PKCS12

Now, just run the client script as before. Done!

The source code for this post can be found in my personal GitHub here.

Some extra tips

If you are having trouble configuring the certificates or receiving errors about missing certificates, and need to troubleshoot the connection to the Kafka cluster, here are some tips to help you overcome it:

First, enable SSL debug by running the following command before calling the client scripts:

# This will enable SSL debugging.
export KAFKA_OPTS="-Djavax.net.debug=ssl"

If, instead of debugging the SSL handshake, you want to debug the script itself, you can enable DEBUG logging by doing 2 things.

First, create a Log4J2 configuration file named client.log4j2.properties with the following content:

rootLogger=DEBUG, console

appender.console.type = Console
appender.console.name = console

Then invoke the following command before calling the scripts:

export KAFKA_LOG4J_OPTS="-Dlog4j2.configurationFile=file:/path/to/client-log4j2.properties"

Red Hat's Spring Boot application on OpenShift 4

Ângelo Galvão — Tue, 05 Mar 2024 20:02:53 +0000

Do you know that Red Hat offers and support its own brand of Spring Boot libraries? Do you know that Red Hat also offers libraries that makes build and deploy on OpenShift easier?

In this quick article you will learn how to build and deploy an example application on OpenShift 4!

First, let's review the environment and versions:

Openshift Container Platform 4.14
Red Hat build of Spring Boot 2.7
Java 11

Diclaimer

This article expects that you have some knowledge on Spring Boot and Openshift

Use Red Hat libraries

Fix your libraries

Starting with version 2.7 of Spring Boot, instead of shipping its own version of Spring Boot libraries, Red Hat strategy is to allow the use of the same official version of Spring Boot and only override the components that Red Hat offers with its own version.
The most notable example is the Undertow web container, which is offered on version 2.2.26.SP2-redhat-00001 at the time of this writing. This is how you override the libraries:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>    
        <!-- Exclude the Tomcat dependency -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

<dependency>
    <groupId>io.undertow</groupId>
    <artifactId>undertow-core</artifactId>
    <version>2.2.26.SP2-redhat-00001</version>
    <scope>compile</scope>
</dependency>

Visit Red Hat Spring Boot Component details page to a list of components and versions that overrides the provide Spring Boot libraries.

Include the Dekorate dependency

The dekorate.io is a new project that facilitates build and deploying your application on OpenShift. It uses annotations to decorate your application with OpenShift own resources. To use it, first add the dependency in the pom.xml of your project.

<dependency>
    <groupId>io.dekorate</groupId>
    <artifactId>openshift-annotations</artifactId>
    <version>2.11.5.redhat-00017</version>
</dependency>

Annotate your application

To take advantage of the Dekorate library, annotate your application with @OpenshiftApplication annotation to configure how it will be deployed in OpenShift. In this example, the application will run 3 replicas and a Route object will be created.

@SpringBootApplication
@OpenshiftApplication(replicas = 3, expose = true) 
public class SpringBootExampleAppApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootExampleAppApplication.class, args);
    }

}

Set the s2i builder image

In some clusters, the default s2i builder image is incorrectly running pods with Java 8 version instead of Java 11. To fix that, add the following property in application.properties Spring Boot file:

dekorate.s2i.builder-image=registry.access.redhat.com/ubi9/openjdk-11:latest

Finally, deploy your application

Now, the final step is to deploy your application on Openshift. Just run the following command on the application root folder after properly login on OpenShift cluster with the oc client library:

./mvnw clean install -Ddekorate.deploy=true

If everything runs correctly, your application will be running on 3 pods and a be accessible from a route.

What is next?

Did you like this article? Then, visit the example application repository in Git Hub to get more details on how to build and deploy Red Hat own version of Spring Boot on Openshift 4.