DEV Community: Kotbi Abderrahmane

How to Create a Podcast Using an RSS Feed and Google Podcasts

Kotbi Abderrahmane — Sun, 12 Mar 2023 20:14:15 +0000

As a frequent listener of audio content, I often find myself jumping between different apps to listen to my favorite podcasts, audiobooks, and other tracks. It can be inconvenient to have a large number of audio files on my phone or in the cloud, especially if I need to download them or be connected to the internet to access them.

To solve this problem, I decided to create my own podcast using an RSS feed and Google Podcasts. An RSS feed is a web feed that allows users and applications to access updates to websites in a standardized format. By creating a hosted audio list in the form of an RSS feed, I could easily manage my audio content and access it all in one place through Google Podcasts.

In this article, I'll walk you through the steps to create your own podcast using an RSS feed and Google Podcasts.

Step 1: Host Your Audio Files

The first step is to host your audio files in a secure location. I used Firebase Storage to host my files, but you can use any hosting service that supports direct links to your audio files. To ensure that my files were safe, I added a security rule to my Firebase bucket that allowed read access but disallowed write access:

rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read: if true; // Allow anyone to read the files
      allow write: if false; // Do not allow anyone to upload or modify files
    }
  }
}

Once your files are hosted, make note of the direct links to each file. You'll need these links to create your RSS feed in the next step.

Step 2: Create Your RSS Feed

Next, you'll need to create an RSS feed that includes the direct links to your audio files. To make this easier, I wrote a Node.js program that creates theRSS XML file for me.

To use this program, save it as a JavaScript file on your computer and modify the variables at the top of the file to match your own hosting and podcast information. Then, run the program using Node.js to generate the RSS XML file.

Here's an example of what your final RSS XML file might look like:

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>My Podcast</title>
    <link>https://example.com/podcast/</link>
    <description>A podcast created using an RSS feed and Google Podcasts</description>
    <language>en-us</language>
    <itunes:author>My Name</itunes:author>
    <itunes:summary>A podcast created using an RSS feed and Google Podcasts</itunes:summary>
    <itunes:image href="https://example.com/podcast.jpg"/>
    <itunes:category text="Technology"/>
    <itunes:explicit>no</itunes:explicit>
    <item>
      <title>Episode 1: My First Episode</title>
      <link>https://example.com/podcast/episode1.mp3</link>
      <guid>https://example.com/podcast/episode1.mp3</guid>
      <description>My first episode of the podcast</description>
  </channel>
</rss>

Now that we have our RSS feed ready, we need to publish it. To do that, we need to upload the audio files and the RSS feed to a server. In this example, we will use Firebase to host our files.

Once we have our files uploaded to Firebase Storage, we can generate the RSS feed XML file using Node.js. We can use a package like rss to make the process easier. Here's an example code snippet:

const RSS = require('rss');
const { Storage } = require('@google-cloud/storage');

// Initialize Firebase Storage
const storage = new Storage({
  projectId: 'your-project-id',
});

// Create a new RSS feed
const feed = new RSS({
  title: 'My Podcast',
  description: 'A podcast about my favorite things',
  feed_url: 'https://my-podcast.com/feed.xml',
  site_url: 'https://my-podcast.com',
});

// Get a list of all audio files in Firebase Storage
const [files] = await storage.bucket('your-bucket-name').getFiles();

// Add each audio file to the RSS feed
files.forEach(file => {
  const url = `https://storage.googleapis.com/your-bucket-name/${file.name}`;
  feed.item({
    title: file.name,
    description: 'Listen to this audio track',
    url,
    enclosure: {
      url,
      size: file.metadata.size,
      type: 'audio/mpeg',
    },
  });
});

// Generate the XML file
const xml = feed.xml();

In this example, we are using the rss package to create a new RSS feed with a title, description, feed URL, and site URL. We then use the @google-cloud/storage package to get a list of all audio files in our Firebase Storage bucket. For each audio file, we add an item to the RSS feed with a title, description, URL, and enclosure (which specifies the audio file URL, size, and type). Finally, we generate the XML file using feed.xml().

Once we have our RSS feed XML file, we can upload it to our server and add it to Google Podcasts. To add our podcast to Google Podcasts, we need to submit our RSS feed URL to the Google Podcasts Portal. Once Google verifies our podcast, it will be added to the Google Podcasts directory.

And that's it! With just a few steps, we have created a podcast and made it available on Google Podcasts. Of course, there are many other things we can do to improve our podcast, such as adding cover art, optimizing the audio quality, and promoting the podcast. But this should give you a good starting point to create your own podcast.

How to create a production Docker image

Kotbi Abderrahmane — Sat, 25 Sep 2021 01:17:30 +0000

In a previous article, I explained how to create a virtual development workspace using Docker. Thus, I thought that it would be great if I presented a slightly different example using Docker. In this article, I am going to show you how to create a production Docker container ready for deployment. To make it interesting, I will work on a JakartaEE, and MySQL application. Therefore, you will learn how to build a multiple building stages Docker image using one single Dockerfile. Brief, this article aims to teach you and encourage you to learn more about Docker, because it's a very interesting technology. Maybe in the upcoming articles, I am going to do the exact same using Docker composer or Docker swarm (tell me if you are interested in such articles).

What are we trying to achieve?

First things first, we need a ready-to-use JakartaEE application. Luckily, I already prepared an application that you can find in this Github repository. It is a JakartaEE application tested on tomcat and requires a MySQL database. Hence, we need only to create one simple Dockerfile to get the job done. This last should:

Build the project. As a result, we will get a ready to run .war file.
Set up the .war produced file for our Tomcat application server.
Copy tomcat directory to new Docker image in which we have our MySQL database ready to use.
Run the application!

That been said, the work on our single Dockerfile will be divided into two parties. In the first part we are going to work on the first and second step described above (let's call it Tomcat Side), and in the second part we are going to work on the third step (let's call it MySQL side). Finally, we will test our application.

`Tomcat Side`: Building and deploying the application to `Tomcat` application server

The application used in this article relies on the maven build tool. The simple following command generates the .war file:

$ mvn package

Firstly, to use Tomcat you can use the suitable Docker image from Tomcat (based on the used Linux distribution and JDK version) official page on DockerHub. In this case, I usedtomcat:8.5.63-jdk11 and I named TomcatSide. Surely, we will copy the project files into the Docker image and install maven to build the project. After building the project, deploying the application to Tomcat can be done easily by copying the generated .war file to tomcat/webapps directory. You can do this eventually using the command:

cp -rf ./target/Cabinet_Medical-0.0.1-SNAPSHOT.war /usr/local/tomcat/webapps

Consequently, the Tomcat side would be:

# Create Docker image based on the tomcat:8.5.63-jdk11 base image and name it TomcatSide. 
FROM tomcat:8.5.63-jdk11 AS tomcatside

# Set up work directory
WORKDIR /Cabiner_Medical

# Copy the entire project to your Docker image
COPY . .

# Install maven
RUN apt-get update && \
    apt install maven -y && \
    java -version && \
    mvn -version
# Build the project
RUN mvn package

# Deploy the .war file to Tomcat server
RUN cp -rf ./target/Cabinet_Medical-0.0.1-SNAPSHOT.war /usr/local/tomcat/webapps

`MySQL Side`: Set up the database and run the application

As you may notice the previous section of this article isn't enough. We need our database! As the first section can be a general example of how to use tomcat in Docker, this one is a general example too that you can get inspired from to prepare your MySQL database and run a Tomcat server in Docker.

Hence, to create a Docker image with our I used a ready MySQL server Docker image from the official MySQL DockerHub container. Next, I set up the root user password, the database name, and the database schema. After that, I copied the /usr/local/tomcat directory from tomcatside image to the actual image. The following step is needed only so that we can run Tomcat server. It consists of installing the appropriate Java version and getting Tomcat application server ready for the final step, which is building our production image.

FROM mysql:latest

# Set up the password and the database name
ENV MYSQL_ROOT_PASSWORD=Strong@Independent1Password
ENV MYSQL_DATABASE=bd_cabinetmedicale

# Set up the database schema. The following line will result in having a database with tables and content
# To avoid any problems you need to make sure that your SQL code works fine.
ADD ./resources/dataBases.sql /docker-entrypoint-initdb.d

WORKDIR /usr/local/tomcat

# Copy the tomcat directory from tomcateside to this image
COPY --from=tomcatside /usr/local/tomcat /usr/local/tomcat

# Set up tomcat, and JDK
WORKDIR /usr/local/tomcat/webapps

ENV CATALINA_BASE=/usr/local/tomcat
ENV CATALINA_HOME=/usr/local/tomcat
ENV CATALINA_TMPDIR=usr/local/tomcat/temp
ENV JRE_HOME=/usr
ENV CLASSPATH=/usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar

RUN apt-get update && \
    apt-get install openjdk-11-jdk -y && \
    apt-get update && \
    apt-get install ca-certificates-java && \
    apt-get clean && \
    update-ca-certificates -f && \
    java -version

ENV JAVA_HOME /usr/lib/jvm/java-11-openjdk

RUN export JAVA_HOME && \
    export CATALINA_BASE && \
    export CATALINA_HOME && \
    export CATALINA_TMPDIR && \
    export JRE_HOME && \
    export CLASSPATH

# WORKDIR /var/run

# RUN cp mysqld/ mysqld.bc -rf
# RUN chown mysql:mysql mysqld.bc/

EXPOSE 8080

# Run the application
WORKDIR /usr/local/tomcat/bin
RUN chmod +x catalina.sh

CMD ["/usr/local/tomcat/bin/catalina.sh", "run"]

And here it is the final Dockerfile:

One other final step

Congratulations, you created your Dockerfile you need only the following command to build the Docker image:

$ docker build --pull --rm -f "Dockerfile" -t cabinetmedical:latest "."

Also, you need this command to run your container:

$ docker run --name="temp"-it  -p 3306:3306/tcp -p 33060:33060/tcp -p 8080:8080/tcp cabinetmedical:latest

And to accede to the container's shell terminal:

$ docker exec -it temp

Finally:

Now that you completed your Dockerfile, you can build your image. Probably you will see something like this on your terminal:

Conclusion

This article is a simple example in which I used docker multiple stages building to create using a single Dockerfile a production Docker image. I was excited about this article because often after learning Docker we use it less in our projects. Instead, we just go to Dockerhub whenever we need a database image or any kind of image that we need to pull. Don't get me wrong please, I have nothing against that it is totally normal for me. However, you can make more exciting things using docker. That is why I highly encourage you to try to make something similar to what I did in this article in your project. I hope you enjoyed my article, and thank you!

How to get into the "from your imagination to your screen" CSS level

Kotbi Abderrahmane — Fri, 17 Sep 2021 19:13:20 +0000

This article aims to help you get better at styling. All along with this article, I will change your understanding to CSS. Also, open your eyes to the keys that will unlock the next CSSlevel for you. However, this article won't be a simple course about CSSor another motivational speech that you will forget by the end of your reading. So you better practice more and keep your attention on the best practices included in this article.

The styling hidden problems

I believe that the first step to solve an issue is to find it out first. Except that problems are always tricky and tend to remain hidden. And that’s why I wrote this article: to help you find these sneaky problems and get rid of them all.

The first problem with CSS is that we often treat styling in the selector property value. In other words, we ask about the property that will make the exact effect that we want on the page while forgetting that CSSoperates based on the context of the elements of that page. Consequently, we can’t find the answer to all our questions about our styling. Don’t get me wrong please, I am not talking about the how to center a div kind of questions, but the how to make this animation or this design that I imagined kind of questions. Nevertheless, the answer isn’t ambiguous at all: the style operates as unites and you won’t find a unique property to achieve what you want. You will need a bench of properties and classes that works together. And that’s why I believe that styling isn’t just copy-paste process, but also is requires having an analytical mind.

That’s lead us to the second problem, or as I call it: the how to achieve what I imagine? problem. While the first problem is about misunderstanding CSS for a copy-paste with no analytics process, this one is about how to break down the design we have into structures, therefore creating the appropriate style. Because of this problem, we can’t find answers to all our styling questions on google: you can’t browser for example: how to make this element smaller and put it here and make it do this and do that? That’s why you need to have the ability to turn your complete design into smaller units of style that operate together to create the overall picture.

That been said, the final problem that you may face, is only about memorizing. Indeed, because we often don’t consider the analytical side of CSS we try to memorize as many properties as we can. Unfortunately, we forget them over time. What is wrong with this is that properties operate together, e.g. you may learn about ::after and ::before, but you will be confused why they don’t work because you don’t know how to use content with them. So you don’t need to memorize CSS rules only, but also how they work.

Did make you worry in the first section? Well, don’t feel sad because in the next two sections we will solve these problems together.

Long term best practices

The first thing you need to make sure of is to stop reading those bad articles about how you can be better if you learned the basics, read other people’s code and believe in yourself. You need real solutions!
The first one is to Learn CSS correctly. You can make styling easier by breaking it down into 4 main parts: Measurement units, Position properties, Forms properties, and colors properties.

Measurement units: are the units that CSS supports. There are two types generally: absolute and relative units. If you understood how to use them and how to convert from one to another you will be able to give the right size to your elements and to your text.
Position properties: are the properties used to position elements on the page. Understanding how these properties work is crucial so that you realize your project, and make it responsive. By means of these properties, you will divide your design into layers using z-index, organize them using grid or flex, or even define their absolute position.
Boxes properties: are the properties that either surround an element or for the element itself. For example, padding, margin, shadow, transform, keyframes, before, after, content, etc. If you learned how to use these properties you will be able to change the form of elements, add beautiful style to an element, or create animations.
Color properties: These are the properties related to colors like background color, color, gradient, etc.

By breaking down the CSS like above you will be able to ask good questions, and you won’t need to worry about memorizing. Instead, you will look for the exact property that will fulfill your needs.

Next, you need to learn how to divide your design into sections. This is a very important skill you must acquire. Since it will make your code cleaner by working on every single “component” alone. In fact, this brings up another issue which is that the code becomes missy as it grows up. However, if you make the code organized you won’t face spaghetti code problems like unused style, etc. To solve these issues, you need to draw on paper your page as it is divided into components. Then think of what position properties you will need to achieve that design, and what measurement units you will need to make it “responsive”. Finally, add the appropriate colors and the box properties to each element.

In a nutshell, draw your design into mockups, analyze the design and think of what properties you need, organize your code, and remember to practice so that you can improve and see how effective these practices are.

Short term tips

In this section, I am going to give you some interesting tools that can improve your productivity.

Google Chrome inspect flex/ grid/ transform/ fonts / animations / box-shadow/ margin...: Using these tools you will be able to work with these properties easily. You just need to add into your CSS class for example:

.my-class {
   display: grid;
   /* or display: flex;*/
   animation: leftrotation;
}
.my-other-class {
  box-shadow:
}

To use animations section type Ctl+Shift+p and then look for animations.

@keyframes leftrotation {
 100% {
   transform: rotate(315deg);
 }
}

Google Chrome style inspect and experimental CSS OverView feature: These features allows you to capture CSS of the website and check the colors and the fonts used, in addition to the unused style declarations and the media queries. You can check the entire website style.

To activate CSS OverView, go to settings by opening your inspect tools and then press F1 to get into settings. Then look for CSS OverView in the Experiments section.

VSCode extensions: If you use Visual Studio Code,you already know about how these extensions can make your life easier. So I am going to share with you a small collection of those:
Auto Close Tag + Auto Rename Tag
JavaScript (ES6) code snippets + ESLint
Prettier-Code Formatter
Color Highlight
Live Server

Conclusion:

I hope you enjoyed reading this article. In this conclusion I want to ask you if you have any addition related to this topic. I would love to read about some exciting methods and tools that can improve my productivity.

How to build your virtual workspace

Kotbi Abderrahmane — Sat, 11 Sep 2021 18:04:56 +0000

In this article I will teach how to use Docker containers as a development workspace using a real word example. I will go through multiple Dev Ops related topics. However, this is still an example that I have had the opportunity to work on during my open-sourcing journey.

What do we want to achieve?

One of the wonderful open source projects that I have got the opportunity to help in is the One Programming language . The goal of this project is to create a programming language named One. To build the project and run tests you must have a list of hard to install and configure dependencies on your machine, e.g. Make, LLVM, etc. Moreover, we wanted to make it easy for developers to get involved and contribute easily in the project. That's why we considered having a docker image to build the code and run tests as priority. Hence, we created this beautiful image for our organization.

In this article I am going to show you how we made it and also how you can make you own development image.

Build the `Docker` image

First things first, we need to build the image. Indeed there is nothing special in this section, because we will only write a Dockerfile for our image. Yet, what make this image special are the pieces of software that will include. Generally, you ought to setup packages required to run your project and your tests, along side with a version control system like git. As far as I am concerned, I included the following packages in my lightweight alpine base image:

FROM alpine:latest
LABEL The One Programming Language

# LLVM version
ARG LLVM_VERSION=12.0.1

# LLVM dependencies
RUN apk --no-cache add \
    autoconf \
    automake \
    cmake \
    freetype-dev \
    g++ \
    gcc \
    libxml2-dev \
    linux-headers \
    make \
    musl-dev \
    ncurses-dev \
    python3 py3-pip \
    git

Next I setup the reaming packages, like LLVM and pre-commit. This last is a powerful framework for managing and maintaining multi-language pre-commit hooks. It is an important addition to your open source project. Since Git hook scripts are useful for identifying simple issues before submission to code review. We run our hooks on every commit to automatically point out issues in code such as missing semicolons, trailing whitespace, and debug statements. By pointing these issues out before code review, this allows a code reviewer to focus on the architecture of a change while not wasting time with trivial style nitpicks.

# Build and install LLVM
RUN wget "https://github.com/llvm/llvm-project/archive/llvmorg-${LLVM_VERSION}.tar.gz" || { echo 'Error downloading LLVM version ${LLVM_VERSION}' ; exit 1; }

RUN tar zxf llvmorg-${LLVM_VERSION}.tar.gz && rm llvmorg-${LLVM_VERSION}.tar.gz

RUN cd llvm-project-llvmorg-${LLVM_VERSION} && mkdir build

WORKDIR  /llvm-project-llvmorg-${LLVM_VERSION}/build

RUN cmake ../llvm \
    -G "Unix Makefiles" -DLLVM_TARGETS_TO_BUILD="X86" \
    -DLLVM_ENABLE_PROJECTS="clang;lld" \
    -DCMAKE_BUILD_TYPE=MinSizeRel \
    || { echo 'Error running CMake for LLVM' ; exit 1; }

RUN make -j$(nproc) || { echo 'Error building LLVM' ; exit 1; }
RUN make install || { echo 'Error installing LLVM' ; exit 1; }
RUN cd ../.. && rm -rf llvm-project-llvmorg-${LLVM_VERSION}

ENV CXX=clang++
ENV CC=clang

# pre-commit installation
RUN pip install pre-commit

Now as everything is perfectly configured, you can copy your project directory, build the code, and run your tests while showing significant logs:

# Work directory setup
COPY . /One
WORKDIR /One

# CMake configuration & building
RUN mkdir build
RUN cmake --no-warn-unused-cli -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE -DCMAKE_BUILD_TYPE:STRING=Debug -DCMAKE_C_COMPILER:FILEPATH=/usr/bin/gcc -DCMAKE_CXX_COMPILER:FILEPATH=/usr/bin/g++ -H/One -B/One/build -G "Unix Makefiles"
RUN cmake --build ./build --config Debug --target all -j 6 --

# Change directory to build
WORKDIR /One/build

# Running example input.one
RUN ./lexer ../src/input.one log
RUN cat log

# Running tests
RUN ./lexer_test
RUN ./parser_test
RUN ./argument_test

# Tests Dashboard
CMD ctest --output-on-failure

Deploy it to `DockerHub`

To do so, you will need a DockerHub account. Yet, only your account username and credentials are required. As we are going to deploy it using GitHub Actions. Similarly to pre-commit, using GitHub Actions, or any CI\CD tool is a good Dev Ops practice. Especially that we are going to configure our image to run pre-commit hooks, build the code, run tests, and deploy it the new image to DockerHub. In fact, you will do very minor changes to the following GitHub Workflow to use it in any other project.

Let's begging by configuring the GitHub Workflow that will run on every push or pull request:

name: Dockerize One Programming language

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

jobs:
  build-deploy:
    name: Build and Publish Docker image
    runs-on: ubuntu-latest

Next, we will add steps to configure needed GitHub Actions to deploy to DockerHub. Particularly, you won't need any other GitHub Actions. Because, you already have a Dockerfile with all the prerequisites!

steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v1
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

We shall continue by Sign into our DockerHub account:

      - name: Login to DockerHub
        uses: docker/login-action@v1
        with:
          username: ${{secrets.DOCKER_HUB_USERNAME}}
          password: ${{secrets.DOCKER_HUB_PASSWORD}}

Before we go to the next step you need to add secrets.DOCKER_HUB_USERNAME and secrets.DOCKER_HUB_PASSWORD to your Github repository:

Finally, publish your new image named onelangorg/one:latest to DockerHub:

      - name: Build and Push to DockerHub
        uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: onelangorg/one:latest

Don't forget to configure cache so that you won't need to go with all the unnecessary configuration steps everytime. Also, this will decrease the run time dramatically. In my case without cache the run time is about two hours, but with cache it often doesn't surpass one minute and a half!

          cache-from: type=registry,ref=onelangorg/one:latest
          cache-to: type=inline

Consequently, you will cerate a Docker repository in your docker account.

Use it as a Workspace

In this section you will need to pull the docker image form DockerHube have VSCode with Remote-Containers installed:

This awesome extension admit of getting into the Docker container itself, by opening a VSCode window inside it.

After Opening the new window attached to your container you can open the development directory:

And Here you go you have a workspace configured and ready to use!

Conclusion

Now that you come to the end of this article, you can see how important to use Docker, DockerHub, and GitHub Actions. As well as how easy to use are they. These technologies helps developers to be more productive and not bother with the repetitive configuration of the workspace. On every pull request, we get an updated Docker image with a clean code and successfully run tests thanks to pre-commit, Github Actions, and cache.

Java Functional Programming

Kotbi Abderrahmane — Tue, 07 Sep 2021 11:56:27 +0000

This article will take you to the next level in java. Are you ready!

Introduction

This article is basically a set of examples of multiple tools provided by Java 8. Those tools have helped to make programming way more easier and optimal(even in terms of hardware resources), using a declarative approach. Hence, we don't have to tell many details, but only what we want to achieve by our code. I should highlight also the fact that this pack of tools is something that a java developer "must" know.

Map

1) Stream:

In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
2) Lazy expressions:

By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
3) Functional interfaces:

This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what you have learnt. Still more concrete examples will be in the last section.
4) Optional:

This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null value problems.

Finally, you will work on real examples and learn some specific tricks that will alter your programming style to the best!

To understand exactly why I choose to follow this planing You need to understand the relation between those parts. Because, this selection of topics doesn't recover every thing about java and functional programming. Still, it will be your main support to learn more.

1) Java 8 Stream API

Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called pip-lining. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are consumable and functional in nature. One more powerful point for stream is that they are possibly unbounded (unlimited, so we don't have to precis a certain size for a stream). Thus, you can perform operations on the first and last elements of a stream with no worries for its size or the order of elements because they also keep the same order of elements as the source.

This article will just give some important and highly used examples of functions and operations. If you were looking for more operations that java offers, you can look for them here.

In a nutshell:

Collection	Stream
under the java.util package	under the java.util.stream package
in memory data structure	only for processing data
all values must be computed then stored (eager)	allow operations on only the required values (lazy)
we can perform operations as much as we want on collection	the elements of a stream are only visited once during the life of a stream (if you want to visit them again use an other stream!)
must have certain size	doesn't need a fixed size. Yet, we can get the first/last elements

In the next example we gonna use the following import:

import java.util.List;

If you take this list of friends:

List<String> friends = List.of("Mohamed","Abderrahmane","Ajar","Omar","Youssef");

Imagine we want to print the length of each name. Normally, your code would be something like this:

int[] r = new int[5];
for (int i = 0;i<5;i++) {
r[i] = friends.get(i).length();
System.out.println(r[i]);
}

I think this code is clear for you. But other method to do the same thing with no need to declare any variable is the following:

friends
   .stream()//create stream of friends
   .forEach(n->System.out.println( n.length()));//Then print successively each one of them

Please refer to the next section to understand what are these expressions: t -> expression.

2) Lazy expressions

Lazy expressions or lazy evaluation is a strategy of coding and also a mindset. You will find a lot of complex explanations to what exactly a lazy evaluation is. Yet, it is all about how to make your code lazier, and by this I mean optimal. This could be done by postpone the execution of a function until we really need it be executed. Java is lazy when it comes to the evaluation of logical arguments,e.g. in f1() || f2() , the call of f2() is never performed if f1() returns a boolean true. Still, a method is executed as soon as it is called. On the other hand, if a lazy method wasn't called, then it will just lay around whithout doing anything. However, we are often tempted towards writing a code which is executed eagerly, because it is easy to write and to understand the logic behind it. But sometimes it is just a waste of time and hardware resources if a method doesn't use all the passed arguments. In this section we gonna focus exclusively on lambdas, method reference, and how they make your code lazier.

Method reference

Method reference refers to a method from class or object using class::methodName type syntax. There is different types of available method references in java 8. For example:

Explanation	Form	Example
Reference to static method	Class::staticMethodName	Math::max equivalent to Math.max(x,y)
Reference to instance method from instance	ClassInstance::instanceMethodName	System.out::println equivalent to System.out.println(x)
Reference to instance method from class type	Class::instanceMethodName	String::length equivalent to str.length()
Reference to constructor	Class::new	ArrayList::new equivalent to new ArrayList()

Lambda expression

Lambda expression are also called anonymous function, i.e., a function with no name and any identifier.
They are nameless functions given as constant values, and written exactly in the place where it’s needed, typically as a parameter to some other function. They are writing in this form:(parameters) -> expression; which means that expression is preformed when it is called, on the value that takes the variables parameters.( For example, this expression (x, y) -> x + y returns the result of the addition of x and y, also this expression (x) -> System.out.println(x) prints the value given to the argument x;

In the example above .forEach(n->System.out.println( n.length())); means that we gonna perform the action between brackets on each element of our stream, which is to print them one by one.

Moreover, the code above also can be written as following with some small changes:

friends
   .stream()
   .map(String::length)//Map each name to its length. As result we get a stream of lengths.
   .forEach(System.out::println);//Print each element of the stream.

3) Functional interfaces

It's time to dive more in one of the main innovations that java 8 has come with.

Overall, Functional interfaces are interfaces that permit exactly one abstract method inside them, in addition to as many as you like of default methods. Since they are not abstract because they have an implementation (I should also highlight the fact that default functions are a revolutionary addition in java 8). Functional interfaces are also named Single Abstract Method interfaces *(SAM Interfaces)*. In Java 8, functional interfaces can be represented using lambda expressions, method reference and constructor references as well. It is optional to add @FunctionalInterface annotation to a functional interface to define one. For example we can have something like this:

@FunctionalInterface
public interface MyInterface 
{
public void job();//one abstract method
default void fct1(){//default method
//Method body
}
default void fct2(){//default method
//Method body
}

static void fct(){//default static method
//Method body
}
}

Default methods are a related topic. Since, they are methods that can have an implementation into an interface! This implementation by default can be either kept as it is, or overridden. We can make a default method by adding the keyword default or, and this is so cool, by making it static with no need to add the default keyword. I won't dive into more details that you can look for later(believe me this new feature is awesome so please check the references), but a good question to ask is what also they provide so that I putted them into this section? Well, because default methods enable the lambdas functionality in java. Take a look to this example from java.lang.Iterable:

//This method allow you to perform action on collection
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
/*
Before java 8 you have to iterate on your collection using the loop for. But now you can do something like this (I reused the first example here):
*/
friends
   .stream()
   .forEach(System.out::println);//to print all the friends names.
//Or;
friends
   .stream()
   .forEach(f -> System.out.println(f));

Also, java.util has a set of pre-implimented functional interfaces like the following examples:

Functional interface	Definition
Function < TypeOfInput,TypeOfReturn>	Represents a function that accepts one argument and produces a result.
Consumer < TypeOfInput>	Represents an operation that accepts a single input argument and returns no result.
Supplier< TypeOfInput>	Represents a supplier of results.
Predicate< TypeOfInput>	Represents a predicate (boolean-valued function) of one argument.

I will just give an exhaustive example of implementation of a function. Everything else goes the same way. Yet, if you want the full list you can check the provided documentation of Oracle.

/*
This example represente a method that increment its int argument by one.
*/

//It would be something like this:
int increment(int i){
return i+1;
}

/*
With functional interface "Function" it becomes:
Don't forget to import:
import java.util.function.Function;
*/
Function<Integer, Integer> increment = i -> ++i;

If you want more easy examples for this topic you can check my github repository.

4) Optional

When I was a 'newbie' to java I hated it because of one scary exception that keeps popping up on my screen: The java famous NullPointerException. To be honest it was because some stupid, missed yet required initial values, so java is not the one to blame here. Later, I learnt about the class Optional of the package java.util. Optional, is in fact a value that can be null or not null. You have a huge set of tools and methods to manipulate it. If it was present, if you want to throw a specific exception, if you want to get the value, or else you have methods to do so in this class.

So let us go directly to see some examples:


/*In all the example you can change the value 'null' and the SomeUserCostumizedOrAnyException by something else.
*/

/*
If you want to print a value when only it is present.
*/
System.out.println(Optional
   .ofNullable(null)
   .orElseGet(() -> "value to show by default"));
/*
If you want to print a value when only it is present, or just throw an exception.
*/

// method reference
System.out.println(Optional.ofNullable(null).orElseThrow(SomeUserCostumizedOrAnyException::new));

//Lambda
System.out.println(Optional.ofNullable(null)
   .orElseThrow(()-> new SomeUserCostumizedOrAnyException("the default value is missed")));
/*
If you want to check of the value is present and then print the String email(you have first change null by something like this "xyz@example.com")
*/

Optional.ofNullable(null).ifPresentOrElse(v->
System.out.println("Sending email to "+v+"."),
() -> System.out.println("Cannot send emails!")
);
/*
A last comparison, in case of you want to just get the value.
*/

//normal method(imperative approach in which you declare all your variables and explicitly the logic of how to get the wanted result)
String s="present value";
if(s==null){
System.out.println("s is null");
} else {
System.out.println(s);
}

//new method with Optional (declarative approach in which you just describe what you want as result exactly)
System.out.println(Optional.ofNullable("present value").orElse("s is null"));

//Or just simply
System.out.println(Optional.of("present value").get());

Conclusion

The main goal of this article was to teach you about declarative approach of programming in java. I hope I achieved this goal! But before to wrap up, I just want to remind you of the fact that this should serve as an opening and the given article and examples shouldn't be the last thing you see. So, please keep practicing to learn.

In this article you learnt:

Section	Importance
Streams	Streams make your code lazy by only using the required values in a data source. To do so, you have a powerful set of aggregate methods to use
Lazy expressions	Lambdas and method reference change your coding style to be more declarative and also lazier
Functional Interfaces	This part serves as the theory behind functional programming in java and some good examples to understand it.
Optional	This class works lot with streams and functional interfaces, in case of null values. It will allow you to avoid the struggle of facing the `NullPointerException` every time you execute your code.

Thank you for reading.

References

HowToDoInJava

Oracle Documentation:

Function

Stream

DEV Community: Kotbi Abderrahmane

How to Create a Podcast Using an RSS Feed and Google Podcasts

Step 1: Host Your Audio Files

Step 2: Create Your RSS Feed

How to create a production Docker image

What are we trying to achieve?

Tomcat Side: Building and deploying the application to Tomcat application server

MySQL Side: Set up the database and run the application

One other final step

Conclusion

How to get into the "from your imagination to your screen" CSS level

The styling hidden problems

Long term best practices

Short term tips

Conclusion:

How to build your virtual workspace

What do we want to achieve?

Build the Docker image

Deploy it to DockerHub

Use it as a Workspace

Conclusion

Java Functional Programming

Introduction

Map

1) Java 8 Stream API

2) Lazy expressions

3) Functional interfaces

4) Optional

Conclusion

References

`Tomcat Side`: Building and deploying the application to `Tomcat` application server

`MySQL Side`: Set up the database and run the application

Build the `Docker` image

Deploy it to `DockerHub`