DEV Community: PythonIsNotASnake

Glam Up My Markup - Camp Form for kids

PythonIsNotASnake — Thu, 21 Mar 2024 20:34:27 +0000

This is a submission for DEV Challenge v24.03.20, Glam Up My Markup: Camp Activities

What I Built And Why

I built the "Glam Up My Markup" Challenge. I decided to format the form a little bit to make it look like a regular form. Additional I added some colors and bigger fonts so that it is easy to understand for kids and parents. I saw this challenge by the Use-Case parents want to fill out this form for the camp and get supported by their child. So it should look a little bit cute or funny and not like a office document.
The button and the header got a small hover effect so it is more enjoyable in user interaction.
The HTML got the language property with the value "en-us" so a web browser plugin can easily translate the website in any language (tested by Firefox' translator in Beta state).

Demo

<!DOCTYPE html>

<html lang="en-us">
    <head>
        <meta charset="UTF-8">
        <title>Camp Activities Inquiry</title>
<!-- CSS Style Sheet -->        
        <style>
            section {
                margin-left: 10%;
                margin-right: 10%;
            }
            form {
                padding: 1%;
                background-color: #bec4ae;
                font-size: x-large;
                display: flex;
                flex-direction: column;
                flex-wrap: wrap;
                border-radius: 1rem;
                border-width: 5px;
                border-color: black;
                border-style: solid;
            }
            select {
                font-size: x-large;
                margin-bottom: 15px;
            }
            textarea {
                font-size: x-large;
                margin-bottom: 15px;
            }
            button {
                margin: auto;
                font-size: x-large;
                color: white;
                width: 100px;
                background-color: #787f4b;
                border-style: solid;
                border-width: 5px;
                border-radius: 1rem;
                border-color: black;
                transition: all .5s;
            }
            button:hover {
                background-color: #d76e4f;
                cursor: pointer;
                width: 100%;
            }
            body {
                background-color: #cdd3bc;
            }

            h1 {
                color: #313738;
                font-size: xx-large;
                text-align: center;
            }
            h1:hover {
                color: #d76e4f;
            }
        </style>
    </head>
    <body>
<!-- HTML Body -->
        <section id="camp-activities-inquiry">
            <h1>Camp Activities Inquiry</h1>
            <form action="/submit-form" method="POST">
                <label for="activity-select">Which camp activities are you most looking forward to?</label>
                <select id="activity-select" name="activity">
                    <option value="">--Please choose an option--</option>
                    <option value="hiking">Hiking</option>
                    <option value="canoeing">Canoeing</option>
                    <option value="fishing">Fishing</option>
                    <option value="crafts">Crafts</option>
                    <option value="archery">Archery</option>
                </select>

                <label for="food-allergies">Food Allergies (if any)</label>
                <textarea id="food-allergies" name="food_allergies" rows="4" cols="50"></textarea>

                <label for="additional-info">Additional things the counselor should know</label>
                <textarea id="additional-info" name="additional_info" rows="4" cols="50"></textarea>

                <button type="submit">Submit</button>
            </form>
        </section>
    </body>
</html>

Conclusion

I made this in an hour of evening coding session. The code is not special but it consider to the use-case I mentioned above.
PS: Hope to get a badge for this :)

Keep coding!

Don't do this with your parameters in functions - functional programming🤢

PythonIsNotASnake — Sat, 16 Mar 2024 12:39:42 +0000

Functional programming is a different concept than object oriented programming. For example Java is object oriented meanwhile JavaScript is functional. Additional there are hybrids like Python which allow to use the language in a functional or object oriented way. In all this cases you have functions (for functional programming) or methods (for object oriented programming) which get parameters as input and return a value as output.

First I show you an easy example of a function and then we will analyze what we can do better.

function doSomething(p1) {
  p1 = p1 * 2;
}

What can we see here? We see a function called doSomething which doubles the value of p1. Which problems can we identify when we look at the function? There are three main points.

1) Function name doesn't describe anything🧐

The first issue is the name of the function. If you read doSomething anywhere in a project you will never know what this function is doing. Best practice is to use function names with a describing name of the purpose or of the processing steps the function is doing. In our case a name like multiplyByTwo or doubleNumber is a much better choice.

2) What means p1?😵‍💫

The next issue is the name of the parameter. If you have only one parameters this is not so dramatically. But if you have three, four or more parameters no one can understand which parameter have which effect on the process or result of the function. In this case multiplier can be a valid choice or anything else which can be understand very well.

3) Never change parameter in function body🤬

You never want to change the input value in a function. It is best practice to create a copy of the input value and then do all the operations on this copy. At last return the copy. So the input value has no changes at all. And if anyone need the changes on the input value then the input value can be changed by the return value of the function.

Now we have evaluated all the issues and can make it better in a new try:

function multiplyByTwo(multiplier) {
  var copyOfMultiplier = multiplier;
  copyOfMultiplier = copyOfMultiplier * 2;
  return copyOfMultiplier;
}

var input = 3;
input = multiplyByTwo(input);

How you can see the function never changed the value of multiplier. A copy of the input value is changed instead and returned by the function. Under the function a variable called input is instantiate and will be changed by the return value of the function. So the programmers can decide by their own if a variable value should be overwritten by a function or not. Not the function take the decision.

To be honest this code snippet will never look like this in reality. A regular programmer will be shorten the code massively to make it look like this now:

function multiplyByTwo(multiplier) {
  return multiplier * 2;
}

var input = 3;
input = multiplyByTwo(input);

No copy of the input value is needed at all and the value is never changed before the function will be called in the last line of the snippet.

Conclusion

Clean code can make a huge different in readability of code and to understand the best practices of your chosen programming language or framework can let you avoid issues like changing parameters in function body.
If you have more tips and best practices for beginners of functional programming share them in the comment section.
Keep coding.

PONG - The Hello World of Game Development - The 2nd month

PythonIsNotASnake — Fri, 01 Mar 2024 06:00:00 +0000

In the second month of my game coding journey I had not very much time to invest in the learning process. Nevertheless I implement the first game of the 20 games challenge. Surprise! It was PONG. One of the very first games from the year 1972.
The concept is very simple but contain most of the essential functions you need in game development. There are two players. Each of them can only move up or down. The goal to achieve is to let the ball bounce on your bar and hope that your opponent don't do the same.
The whole project I present in the following lines can be checkout on github. For this project I have used Godot in the version 4.2.1.

Preparation

First of all I started to create some assets. For the whole game I needed two bars as players, one ball, the game field, the goals and walls. To make it a little eye catcher I decided to use same colors. After I had the assets the process of game development started.

Building scenes

The structure of the project is apart in different scenes. First of all I have a player_one and a player_two scene. Both of them are identical. The only different is the sprite. In general there are solutions to not duplicate the scene in the way I had done it. But to keep it simple I made it this way. Next there is the ball as a separate scene. Further in a separate directory are the last scenes goal and level.

Goal

As goal I used an Area2D as scene. In this scene I put a Sprite2D and a CollisionShape2D. To keep it so simple as possible the Area2D has a signal. This is the body_entered signal to track if the ball enter the collision shape of the goal. If the ball enter this area the game will be reset so the players must remember the result by their self.

Player

The player scenes are from type CharacterBody2D and are nearly as simple as the goal is. Each player consists of a Sprite2D and a CollisionShape2D. In the script are functions to enable the movement of the players. For each player are different keys defined to move up and down. Because I use two separate scenes for the players I need a player script which exports essential variables like the speed so no player have an advantage in movement.

Ball

The ball is a CharacterBody2D too. It consists like the other scenes a Sprite2D and a CollisionShape2D. To make the ball bounce if it collide with any object in the game world the move_and_collide() function will be needed. This function returns collision info. If the info is true the bounce() function of the velocity will be triggered. So the ball can bounce between the two players and don't stuck in the walls of the court.

Level

The level is a Node2D which consists all previous scenes and combine them. To show a background as court for the game a CanvasLayer with a TextureRect is used. This is only for the aesthetic and feeling and have no effect to the game logic nor the physics. Next a TileMap allows to place some squares as the wall. The wall is needed so the ball can bounce on it and don't leave the screen and disappears in the Nirvana. Additional the two players, the ball and the two goals are brought into position. The game can start and two players can enjoy the nostalgic charm of the 70s.

Conclusion

I hope I could help you a bit with my first GODOT game. Probably you stuck at some point and found a solution. If you have code PONG by yourself share your code with the community. My code can be discovered on github.
Open to discuss different approaches to solve the challenge to code PONG.
Have fun and keep coding.

Every beginning is hard or my first steps with GODOT - The 1st month

PythonIsNotASnake — Thu, 01 Feb 2024 06:00:00 +0000

In my DEVResolutions for this year I mentioned that I'm going to learn the game engine GODOT. An answer on the mentioned post was to document the journey of learning game development. My idea to this is that I will share my progress of every month. Possibly it motivate someone or give an idea how hard or easy is the learning curve of GODOT and game development in general.

Prior knowledge

To my person I never before have done game development. The only things I have made was a visual novel game with Ren'Py. But Ren'Py make things very easy. There are no collisions or physics in it. For a simple base game you're not needing any programming skills because you write a storybook. It is more similar to PowerPoint meets LaTeX.
Another part of my skill level is web development. In general I use Java and Angular for my daily work.

So there comes the knowledge about programming. I not start from scratch at this point. I know how to code so it is not difficult to understand the script language of GODOT. The challenge is to understand the concepts of game development. This mean specific keywords and the structure of a game.

Where to start?

Last year I started with the tutorial on the GODOT website but never finished it. I recommend to start with this at first. It will give you an overview of the different buttons and other stuff of the GODOT UI. If you have done this you can decide if you want a look into 3D games and do their next tutorial. My personal decision was to stay with 2D games.
In this year I started first to watch a video series on YouTube in my native language about the keywords of GODOT. This helped a lot to get a feeling for the structure of a game. Probably there will be a lot other videos or texts in a language of your choice with a similar content.

After basics come more basics

So at this point I have decided to concentrate on 2D games. My idea was

Why not starting with a complete guided game?

So I found on YouTube a video series in which exactly this was done. The guys from GDQuest have made a video series of programming a platform game. The explanations are very good and each step is described in a deep that you really understand what impact this edit has on the game. Sadly it was made with GODOT major version 3 and not with the latest major version 4. In my case I tried with version 4 and search on the web for objects or methods which not anymore exists or work in another way in the latest version of GODOT.
The first video of the series was the one which contains the most knowledge. After this I get a really good feeling on some points:

how is the structure of a game
how to use different kinds of nodes
how can I make my player to move and interact with the world
how are collisions working

The second part of the series tell you how to make animations and transitions to other scenes (or levels). This can make your game more beautiful and help you to build bigger games than single scene games like pong.

In the last part of the video series there came menus. But this was a little bit difficult. The comments under the video support my impression. It feels like there was missing some parts in the video as also between video two and video three. So the theoretical use is good explained but it is not simple possible to expand the own project by these.

The big goal

It is nearly impossible to learn anything what you never will be use by your own. To give me some motivation I was looking for a game that I will finally code. My intuition tell me that I want to build a 2D fighting game like Street Fighter. After that I make some research for this topic and find out that it is not so difficult to make a rudimentary fighting game. But if you want that the players have fun and enjoy it you need many additional things like a combo system or many sprites of fighters in different positions to make fluent animations and give the player the feeling that the combos feel right and awesome. As I'm not a designer I change my mind. At this point I will try to build a sidescroller shoot'em up like Airwolf or WingWarriors. Possibly my goal can change in the future.

Assets and more assets

The most important part of a game are assets. From backgrounds over parts in the scene to items and characters. You will need assets for all of them. To get assets I have tried three different ways.

AI generated assets

First of all I let an AI generate me background images for my games. One of them can you see in the cover image of this post. It looks very good and is not much work to do. The problem in this case is if you need an asset in multiple positions like a character who is walking. In most of the tested image generators the character in the next image don't look like the character in the first one. So it is genius for backgrounds, parts in the game world or items but not for animated sprites.

Design assets by your own

My next way was to design easily my own characters. So I tried it with pixelart to get simple but not bad looking assets. The result are the samurai and knight in the cover image. If you have the effort to live your creativity this can be a adorable way.

Get assets legal from the web

The last way is the easiest way to get assets for your game. On OpenGameArt.org you find a huge amount of free assets for your projects. It can be filter by the type of license. So you can choose by yourself which type of license is alright for you. There are not only sprites but also textures or sounds and background music. Give it a try and search for your own if you want start quick develop a game without spend to much time in drawing assets.

Conclusion

This was many input for one month. I hope with this in your mind you will have a first idea where to start. If you make your own game don't be shy and share it with the community.
Keep coding.

My personal #DEVResolutions2024

PythonIsNotASnake — Wed, 03 Jan 2024 13:29:01 +0000

I want to use this to share my personal goals. This is stuff which I want to get done in 2024. As background information I am a backend web developer but my goals aim more on private dev goals than on goals for my career.

Personal Goals:

Goal: Develop an own game.
Action Steps: In the last year I have developed a visual novel game by the use of Ren'Py. This year I want to learn Godot to develop bigger games. The plan is at first to start with the documentation. The next step will be challenge projects from the 20 games challenge. After this I should earned the knowledge to start with a own game.
Timeline: To reach this goal I will nearly need the complete year 2024 and probably parts of the next year.

Personal Aspirations:

Aspiration: To be up to date.
Why it Matters: For me it is important to be up to date. This means that I can read and learn new things right then when they appear. So it can support me in my daily job to know about the newest 'shit' like Blockchain or AI.
Support System: To reach this I will read more tech news and will be a more active reader on DEV.to.

DEV Community Contributions:

Contribution Goal: Be more part of the DEV.to community.
Collaboration Plans: I will publish more posts and use DEV.to as first source to solve my programming issues and to rise my knowledge.
Measuring Impact: Feedback from the community is very important to see if I could help anyone to solve their issues or problems. One reaction or comment are enough for me to see that someone could benefit from my post.

Take your documentation to the next level with Ren'Py

PythonIsNotASnake — Sun, 17 Dec 2023 14:16:25 +0000

Do you ever heard of Ren'Py? Ren'Py is an engine for visual novel games published in 2004. The engine is open source and run by MIT License. Visual novel games are games which based on visuals and dialogs and live by decisions of the player. Visual novel games are very popular in the Asian region. But there are more use cases than game development. Let me tell you which potential is sleeping in this engine.
Disclaimer: This post will not teach you Ren'Py in any kind and don't explain exactly how you can program your documentation. It will only show you some basics and what you can do and achieve with it.

The idea

Which tools do you use to publish documentation for your software to end users? In most of the cases it is a document to read by the end user. Divided into chapters so the user can search for the fitting part of the document.
This proceed is full of information and can give a deep dive into the product. But it can also be overwhelming to read many pages of content.
This is exactly the point on which Ren'Py can make a big different. The plan is to get a interactive documentation which will be a pleasure for users to learn and understand your product. So let's take a look on the details.

Gamification

Do you know what gamification is? It is the method to integrate parts of games in software to achieve an enjoyable experience for the user by use of the product. An quick example are success screens at the end of a process. A little symbol of a medal with a short text like 'You have create personal costs successfully' is enough to let the user get a little experience of success in the daily work routine.
In our situation we want to use Ren'Py to let the users enjoy the experience to read the documentation. This goal will be reached by dialogs to see faster the information the user is looking for combined with a visual contact person. The feeling to play a game instead of doing work can motivate a user a lot more to learn something about a product.

rpy Files and the Ren'Py Script Language

To write a game with the Ren'Py engine you don't need knowledge in any programming language. Ren'Py is written in Python and the engine use their own format named rpy. It is more like the script for a movie or a theatre play. There are two main sectors in which the language is split.
First the dialogs. The dialogs give the information in text on the screen and enable the user to interact with the program by select an answer. Those are menus which mean the decision by user. Each menu has one or more answers to keep the dialog running. For each option in the menu you can define different actions in your program. This can be completely different conversations.
The second sector are visuals and animations. The animations are similar to power point animations. You can choose between different effects to show or hide objects and switch from one scene to another scene. With this knowledge you can build a presentation completely in Ren'Py. It makes no big different.
With this separation we can look at some code snippets of the Ren'Py documentation.

label start:
  "Peter" "Good day! My name is Peter and I'm your contact person for all your questions about our software. How can I help you with our software?"
  menu:
    "Installation":
      "Me" "How can I install the software?"
      jump installation_guide
    "Pricing list":
      "Me" "How is the pricing list for the software?"
      jump pricing_list
    "Save progress":
      "Me" "How can I save my work progress?"
      jump save_files

This simple example show a conversation. You can see two characters, Peter and Me. Peter ask the user something and the user can response the question with different options. Each answer start a different section of the script. The sections are called 'label'. Behind each of the options the user can find a dialog with the exact information he or she is looking for.
This is one part of Ren'Py. It can go very deep so you can do much more than showed in the example. But let us going forward to the next example. It will show us animations.

label start:
  scene bg office
  show peter at left
  with fade

How you can see first the script will show a new background named 'bg office'. After this the image of the character 'peter' will be show at the left side of the screen with a fade animation. This are the basic keywords to animate your program. You can find a lot more keywords in the documentation to animate your interactive documentation.

Goal

Now you have a kind of an idea how Ren'Py can work. With this we can take a look at a finished game which shows our goal. If you download the Ren'Py launcher and start the project 'Tutorial' you can see the following view:

You can see a kind person who want to help you with your questions. All options in the menu guide you to other sections of the documentation.There are some vibes of a chat bot but without any kind of intelligence.
The launcher give you the ability to jump into the source directory. So you can see the source code of their tutorial and can use this as inspiration. You don't must use Ren'Py to write a deep documentation like it is common for framework or library documentations but can use it for a FAQ.

Conclusion

Now it's your turn. You have a quick overview how Ren'Py work and saw how a documentation made by Ren'Py can look like. For a deep dive the Ren'Py documentation is the right place to begin. Furthermore there are so many tutorials and forums where people share their knowledge and projects.
Do you think that a user will have more fun with a documentation in this style?
Are you ready to invest time to learn and practice Ren'Py for your next documentation or FAQ?
Can it be a good marketing move to introduce your product with a short game which explain the main features?

Choose technologies for your project - A brief report

PythonIsNotASnake — Tue, 20 Jun 2023 18:51:37 +0000

For your interest this is a post about my own experience with my private project and how the process of development has chosen my used technologies. This shows how important it is to know which technology is the right for your purpose.

Conditions

I have chosen much conditions which my software project should meet. First of all I want access from every web device of my home network. Second it should be deploy-able on a raspberry pi. And at last it should start automatically on boot up of the raspberry without any action by my side.
So we can see the three conditions which I had for my software project.

Run on every OS
Raspberry Pi deployment
Automatic start on device boot

Choose of the tech stack

First of all my decision was a web app because of condition one. A web app run on every device which has a internet browser. For the framework I have chosen Vue.js because it looks very interesting and I had play around a little bit with Vue.js version 2 in the past. But I needed a possibility to save the data the users will produce by use of the app. So I have chosen Java Spring Boot because I am a java dev and wanted to see how my code style has changed by the few years of job experience. As database I have chosen MongoDB because of the design as an document oriented database. To fix my condition number 3 I wanted to use docker for deployment. With an argument I can give a docker container the command to restart on every stop of himself.
But for sure this should not be the tech stack of the final project.

Euphoria gives way to problems

After my first euphoria for the new project and the detailed tech stack the reality has kicked me. In every project will be conditions by environment which let you overthink your decisions. First of all there were many time since I used Vue.js for the last time. At start of my project version 3 of Vue.js was just released. My Vue.js experience based on version 2 of the framework. What are you doing now? Go with the old version and upgrade later or start learning to use the new version? At this moment all tutorials of Vue.js were written for version 2. After that I have chosen to use Angular instead of Vue.js. This decision was easy because I had much more experience with Angular as web framework than vue.js. After that the first of my planned tech stack components was changed. But it wasn't the last one.

ARM is not x86

No much time since the next problem was coming. As database I have chosen MongoDB. For the deployment I needed an docker image of it. But the support for the MongoDB docker image for ARM32 architecture has ended. You will remember. One of my conditions was to run the software on a raspberry pi. To have less problems with this or other database images I have decided to use an h2 database. This database can be run in the same docker container as the java server. As a java developer I know that my software can run on every architecture as long as it has a java runtime environment. But this kind of luxury let me forget that in other cases the architecture of the host system is very important for the whole parts of a project.

Apply a web server for the angular web app

After this I had a stable backend based on a docker container containing a java spring boot server and a h2 database. The last I needed was a web server respectively a http server. To archive this goal I have read many tutorials to build a docker image and docker container for the angular app. The web app runs. Fine. But there was a bug on it. If anyone types a specific route in the url bar of the browser there was an error that the path can not be found. This was happening because the web server layer try to find a specific file or directory like the route in the browser. But angular works in another way. Angular has there own scripts to process routes. So I have needed to tell the web server layer to pass on the task to angular. But to configure the docker container required a lot of deep knowledge about docker. Knowledge that I was not ready to learn for this project. Instead I have used the classic apache web server. For the apache web server I could write rules to pass on the routing tasks to angular. This was very easy on the one hand and on the other hand the apache web server started automatically on every system boot.

What have I learned?

Through this amount of problems and solutions I have learned to go other ways if your way is blocked. Be flexible in use of technologies. Try something new so you can choose the right technology from your knowledge stock. Have the brave to learn different technologies like different frameworks for web apps, desktop guis, smartphone apps, backend server and so on. So you can make the right choice to solve a specific use case on the most efficient way.
What are your experiences in choosing a tech stack for projects? Let it me know.

Keep coding.

Java records und wieso du sie nutzen solltest [German]

PythonIsNotASnake — Sat, 27 May 2023 12:31:38 +0000

Falls du ein Einsteiger bist, welcher aktuell Java lernt, kennst du bereits die Basiselemente wie Klassen, Methoden, Enums und so weiter. Jedoch gibt es seit Java 16 fest im Java Funktionsumfang verankert records. Dieses kurze Tutorial wird dir erklären, was records in Java sind, sowie einige Tipps dazugeben, wie du sie in deinem nächsten Projekt verwenden kannst.
Alle Informationen in diesem Tutorial basieren auf der Java 16 records Dokumentation, sowie meinen eigenen Erfahrungen.

Was sind record?

Einfach erklärt sind records eine Abstrahierung von Java Beans. Ein record definiert automatisch einen All arguments Konstruktor und gibt public Zugriff zu allen properties des records. Ein record hat von sich aus keine weiteren Methoden. Es ist schlicht ein dummes Java Objekt ohne weitere Funktionalität.

Wie wird ein record implementiert?

Ähnlich zu Enums kann ein record Bestandteil einer Java Klasse sein oder eine eigenständige Datei darstellen.
Als Beispiel möchten wir einen Bruch (engl. fraction) definieren. Ein Bruch besteht aus einem Zähler (engl. numerator) und einem Nenner (engl. denominator). Möchten wir dieses Objekt nun als Java Klasse schreiben sieht es wie folgt aus:

public class Fraction {
  private double numerator;
  private double denominator;

  public Fraction() {
    this.numerator = 0.0;
    this.denominator = 1.0;
  }

  public Fraction(double numerator, double denominator) {
    this.numerator = numerator;
    this.denominator = denominator;
  }

  public void setNumerator(double numerator) {
    this.numerator = numerator;
  }

  public double getNumerator() {
    return this.numerator;
  }

  public void setDenominator(double denominator) {
    this.denominator= denominator;
  }

  public double getDenominator() {
    return this.denominator;
  }
}

Wie du erkennen kannst ist dies ziemlich viel Code um lediglich eine Klasse mit zwei Attributen zu beschreiben. Und nun lass uns dasselbe als record geschrieben betrachten:

public record Fraction(double numerator, double denominator) {}

Kurz, oder? Und das ist der wichtigste Grund für die Verwendung von records. Diese einzelne Zeile bündelt einen All Arguments Konstruktor und die beiden public Attribute numerator und denominator.
Möchtest du eine neue Instanz dieses records erzeugen, so tust du dies wie für gewöhnliche Klassen auch.

Fraction fractionAsRecord = new Fraction(0.0, 1.0);

Override von Konstruktoren und Getter/Setter

Falls der vordefinierte Konstruktor und die Getter/Setter Methoden deinen Use Case nicht sinnvoll abdecken, kannst du diese auch überschreiben. Für einen Konstruktor würdest du es wie folgt machen:

public record Fraction(double numerator, double denominator) {
  public Fraction(double numerator, double denominator) {
    if (numerator == 0 && denominator == 0) {
      throw new java.lang.IllegalArgumentException(
        "Invalid fraction: " + numerator + "/" + denominator
      );
    }
    this.numerator = numerator;
    this.denominator = denominator;
  }
}

Wie du siehst, wird hier nicht wie üblich die Override Annotation benötigt. Dasselbe kann ebenfalls für die Methoden double numerator() oder void numerator(double numerator) getan werden.

Statische Attribute und Methoden

Nun kommen wir zu einer erweiterten Funktion von records. Records geben dir die Möglichkeit statische Attribute und statische Methoden zu definieren. Für unser Beispiel möchten wir unseren Bruch durch den Wert zwei dividieren. Dafür können wir ein statisches Attribut static double half = 2.0 und eine statische Methode static Fraction divideByTwo(Fraction fr) implementieren.

public record Fraction(double numerator, double denominator) {
  static double half = 2;

  public static Fraction divideByTwo(Fraction fr) {
    return new Fraction(fr.numerator(), fr.denominator() * half);
  }
}

Die oben aufgeführte Methode kann mittels Fraction.divideByTwo(fraction) aufgerufen werden. Wie du sehen kannst, kannst du Records um deine benötigten Methoden erweitern, vorausgesetzt diese sind statisch. Dies gibt dir etwas mehr Flexibilität beim Einsatz von Records.

Andere nützliche Funktionen

In der java 16 Dokumentation sind eine Anzahl weiterer erweiterter Funktionalitäten, welche ich hiermit kurz erwähne aber nicht detailliert auf alle eingehe. Du kannst diese im eben erwähnten Link im Abschnitt "Features of Record Classes" finden.
Für mich persönlich ist die Option, dass Records Interfaces implementieren können am nützlichsten. Beispielsweise kannst du einige Basis Methoden für eine Gruppe von Records definieren. Ich gebe dir ein kurzes Beispiel mit dem Interface Mathobject:

public interface Mathobject {
  public Mathobject divideByTwo();
}

Wenn wir unseren Fraction Record dieses Interface implementieren lassen, können wir unsere statische Methode divideByTwo umschreiben. Dies sieht dann wie folgt aus:

public record Fraction(double numerator, double denominator) implements Mathobject {
  static double half = 2;

  @Override
  public Fraction multiplyByTwo() {
    return new Fraction(numerator, denominator * half);
  }
}

Der Record überschreibt die Methode des Interface Mathobject und lässt uns die beiden Attribute von Fraction innerhalb der Methode nutzen, da diese nicht mehr statisch ist.

Abschluss

Was macht Records am Ende so nützlich?
Sie produzieren signifikant weniger Boilerplate Code.
Zudem kennt jeder erfahrene Java Entwickler das Prinzip von Records und kann somit diesen übersichtlichen Code sehr leicht verstehen. Somit wird dein Code verständlicher und orderntlicher.
Und das allerwichtigste ist der Aspekt, dass du weniger Code schreiben musst, was zu einer Zeitersparnis führt.

Keep coding.

Here you can find the english version.

Java records and why you should use them

PythonIsNotASnake — Mon, 15 May 2023 19:26:42 +0000

If you are a beginner in learning java you have heard of the basics like classes, methods, enums and so on. But since java 16 records are permanently added to the java feature set. This short tutorial will give you explanation what records in java are and some tips how to use them in your next project.
All informations in this tutorial are from the java 16 records documentation and my own experience.

What are records?

Easily explained records are an abstraction of java beans. A record defines automatically an all arguments constructor and give public access to all properties of the record. A record does not have any other methods. It is only a stupid java object without any functionality.

How to implement a record

Similar to enums a record can be part of a java class or a file by its own.
As example we want to define a fraction. A fraction consists of a numerator and a denominator. If we want to write it as a classic java class it would look like this:

public class Fraction {
  private double numerator;
  private double denominator;

  public Fraction() {
    this.numerator = 0.0;
    this.denominator = 1.0;
  }

  public Fraction(double numerator, double denominator) {
    this.numerator = numerator;
    this.denominator = denominator;
  }

  public void setNumerator(double numerator) {
    this.numerator = numerator;
  }

  public double getNumerator() {
    return this.numerator;
  }

  public void setDenominator(double denominator) {
    this.denominator= denominator;
  }

  public double getDenominator() {
    return this.denominator;
  }
}

As you can see this is many code only to define a class with two attributes. And now let us see how this will be look as a record:

public record Fraction(double numerator, double denominator) {}

Short right? And this is the most important reason to use records. This single line bundles a all arguments constructor and the two public attributes numerator and denominator.
If you want to create a new instance of this record you will do this as you do it for regular classes.

Fraction fractionAsRecord = new Fraction(0.0, 1.0);

Override constructor and getter/setter

If the default constructor and getter/setter methods do not match your use case you can override them. For a constructor you will do it like this:

public record Fraction(double numerator, double denominator) {
  public Fraction(double numerator, double denominator) {
    if (numerator == 0 && denominator == 0) {
      throw new java.lang.IllegalArgumentException(
        "Invalid fraction: " + numerator + "/" + denominator
      );
    }
    this.numerator = numerator;
    this.denominator = denominator;
  }
}

How you can see it does not need the override annotation as usual. The same can be done with the methods double numerator() or void numerator(double numerator).

Static attributes and methods

Now we came to a advanced function of records. Records give you the ability to define static attributes and static methods.
For our example we want to divide our fraction with the number two. So we can declare a static attribute static double half = 2.0 and a static method static Fraction divideByTwo(Fraction fr).

public record Fraction(double numerator, double denominator) {
  static double half = 2;

  public static Fraction divideByTwo(Fraction fr) {
    return new Fraction(fr.numerator(), fr.denominator() * half);
  }
}

The method above can be called by Fraction.divideByTwo(fraction). As you can see you can expand records with your needed methods as long as they are static. This will give you a little more flexibility in use of records.

Other useful features

In the java 16 documentation are a number of advanced features that I will mention but not explain in all details. You can find them in the link above under the section "Features of Record Classes".
Personally the aspect to let a record implement some interfaces is the most useful for me. For example you can define some basic methods for a group of records. I give you an easy example with the interface Mathobject:

public interface Mathobject {
  public Mathobject divideByTwo();
}

If we let implement our fraction this interface we can rewrite our static method divideByTwo. This looks like this:

public record Fraction(double numerator, double denominator) implements Mathobject {
  static double half = 2;

  @Override
  public Fraction multiplyByTwo() {
    return new Fraction(numerator, denominator * half);
  }
}

The record override the method of the interface Mathobject and let us use the two attributes from fraction directly inside of the method because this is a non-static method.

Conclusion

What makes records so useful at the end?
They produce significantly less boilerplate code.
Every experience java developer knows records and can understand the short code very easily. So it makes your code more understandable and cleaner.
And the much important aspect of all is the significantly less code to write which save you time.

Keep coding.

Hier gelangst du zur deutschen Fassung.

Dockerize your Spring Boot Server

PythonIsNotASnake — Sat, 13 May 2023 11:57:08 +0000

There are many reasons why you want to run your spring boot server in a docker container. For example a capsuled environment, the comfort to delete and rebuild your application or a easy way to autostart your service on every reboot. I hope I have wake up some motivation in you to dockerize your spring boot server so we can start.
But before let me tell there exists many different ways to structure the dockerfile and my way must not be the best way in your specific case.

Docker vs VMs

When you search for a way to dockerize your application you have been hear something about VMs by sure. If not a VM, short for virtual machine, is a virtual operating system on your real operating system. You can give them some resources like process units from your processor, some ram and storage. Further you can install a operating system of your choice. This call like a lot of configuration by your own. Docker is easier in that way. If you have written a dockerfile (a blueprint of your docker container) you can easily build your whole docker container on any machine with a few CLI commands. That's all. Now let us learn something about the basic component of a dockerized app.

Docker components

First we have the dockerfile. A dockerfile is the blueprint to tell docker how your app should be build and which third-party services your application will be need.
Secondly there is the docker image. The docker image is the builded package of your application. Similar to an .jar, .exe or .deb file but you can capsule other images in your image like a java runtime environment. The best way to find docker images is to take a look on docker hub.
The third and last component is the docker container. The docker container is like a vm but needs lower resources to run. In the docker container runs your application. You can start and stop the container. On every start of it the applications in it are restarting too.
So after we know the core components of docker we can start to write the dockerfile for our spring boot server.

Writing a dockerfile

Create a new file called 'Dockerfile'. Then open the file with a text editor.
We started with the first line FROM eclipse-temurin:latest. The statement FROM means that a docker image will be used. In our case we are using the image of a java runtime environment. latest in this case means that we will use the latest release of the image at every time we are executing the dockerfile to build an image. The official wording for the release version is tag. If you want to use a specific tag for example '17.0.7_7-jdk' write FROM eclipse-temurin:17.0.7_7-jdk.
The next line is the EXPOSE statement to define a port your application want to use. Also write EXPOSE 8080 if your spring boot application is using the default port 8080. Otherwise replace 8080 with the correct port of your application.
The next step is a little more complex than the steps before. For this tutorial you will need your spring boot server as compiled .jar file. If you have a gradle project you can do it with the CLI command ./gradlew build.
After you have your jar file we can continue to add your jar to the image. For this we need to expand our dockerfile by two new lines. With the line ARG JAR_FILE=target/*.jar we define an argument that we call 'JAR_FILE'. If now argument is provided in the build command docker will use the provided default value target/*.jar. But this line is only one half. Further we need the next line ADD ${JAR_FILE} app.jar. This add your provided jar file to the builded docker image with the new name 'app.jar'.
Coming to the last line we only need the ENTRYPOINT statement to start the spring boot application inside of the container. Also we add the line ENTRYPOINT ["java", "-jar","app.jar"]. Translated this means simply use java to run the jar with name app.jar.
And this is it. You have written your first dockerfile. Your dockerfile should look like this now.

FROM eclipse-temurin:latest
EXPOSE 8080
ARG JAR_FILE=target/*.jar
ADD ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar","app.jar"]

Build the docker image

After you have your dockerfile ready we can start to build the docker image. For this open a terminal and check if docker is running. For example use the command docker ps -a to list all docker containers. If docker is running you can start to build your image with the following command:

docker build --build-arg JAR_FILE=build/libs/example.jar -t springboot:latest .

Replace the jar path after JAR_FILE= with the path to your own jar file, springboot with the name of your new docker image and latest with tag of your choice but you can also leave it as latest.
Important! Don't forget the dot at the end of the command.
Now docker will build your image. At this process some third party docker images like the jre will be downloaded by docker.

Run the docker container

Finally you can run your docker image in a docker container. Use the following command to do that:

docker run --name springbootcontainer -d -p 8080:8080 springboot:latest

Like in the steps before replace springbootcontainer by the name of your new container and springboot:latest by the name of your image and your tag. With the -p parameter you can define which port from inside of the container should forwarded to which port of your local machine. In common situations you forwarded the application port to the identical port of your local machine.
Hint: If you want automatically restarts of your docker container use the additional parameter --restart always in the docker run command.

Conclusion

Congratulation! You have build your first docker container of an java spring boot application. Now you can start to experiment with the dockerfile elements and try other ways to deploy your docker container to match your case perfectly.
If you need more input try the documentation of docker.