As a front-end developer, I work with a lot of tools to develop code. There are a few popular tools that I use and recommend for programming better front-end applications. Also, I would like to describe what I do to manage applications and how to simplify the process. It can be a really difficult process when you are building a bigger front-end application. I will explain the tooling that I use in this article.

Find and fix problems in your JavaScript code

The first recommended tool is ESLint. Most of the newest JavaScript applications are using Typescript. With the combination of ESLint and Typescript, the code quality will improve. When you are using this tool, it is possible to enforce standards for your team, but also for yourself. On the other hand, it helps you to think about your code and will help you when you forget something. For example, if you forget a type definition for one of your methods.

You can start with ESLint by installing it via npm. After installing ESlint you will find a configuration file in the root of your folder directory called eslintrc.json. The recommended way is to use a config like this:

"extends": [
  "eslint:recommended",
  "plugin:prettier/recommended",
  "plugin:@typescript-eslint/recommended"
],

I do not like to have a lot of custom configuration. This helps to prevent discussion within the team about specific rules. There are some rules that I do recommend. One of these is a simple rule to give an error for unused imports. To enable this rule, you will need a plugin.

In your rule configuration can you define what you should do in case of unused imports.

"@typescript-eslint/no-unused-vars": ["error"],
"unused-imports/no-unused-imports": "error",

In addition to these rules, I have a few other rules. I always want to give a type definition for a return function and do not allow the use of the any type. You can read the complete documentation of ESlint on the website.

An example eslint configuration can be found here.

One of the biggest frustrations, when I start at an existing project, is having no code standards. You want to talk about the function of the new code when somebody has opened a pull request and not about its formatting. That is why code standards are important. Of course, both are important, but formatting should be consistent across files. That is pretty hard when you do not have rules or principles. We cannot automate everything, but some tools can help us. One of these tools is Prettier.

Prettier is a tool that you can use in your codebase to format your code. It supports a lot of programming languages. You do not need to discuss style in your code review and this will save you time and energy. After you install it with npm, you also have a simple configuration file called prettierrc.json. I use a configuration like this:

In the above example, you can see a few options. I want to use a maximum of 140 characters per line, not use double quotes, and format with spaces instead of tabs. The complete list of the Prettier options can be found on their website.

An example Prettier configuration can be found here.

Automate your code standards before you commit

The next step would be automating the tools above. I prefer to do two different things. The first one for Prettier is to implement an auto-save functionality for your code editor. For example in Visual Studio Code, you can create a settings.json in a .vscode folder at the root of your codebase. You can set a default formatter and a format on save boolean for the whole project. The default formatter below can be installed as a plugin.

"editor.defaultFormatter": "esbenp.prettier-vscode",
"editor.formatOnSave": true,

The other step is to implement a pre-commit hook before you commit definitively to your repository. I use the tool Husky for that part. Husky is a tool to lint your commit messages, run tests, and in my case run the lint rules above. Also, it is possible to combine those. I often use it for linting code and running unit tests.

You can install Husky via an automatic command. It will give you everything you need for your first pre-commit hook, including an example to run your test. You can also install Husky manually. The steps to do this can be found here. After installing you will find a .husky folder in the root of your codebase. Inside this folder, you will find the commit hooks that are used. 

The latest step to prevent adding bad code in your codebase is to use the tool lint-staged. With this tool, it is possible to run linters over staged git files. By using this tool you can have control before you push code into the repository. To use lint-staged you need to install it via npm. After that part, you can configure which files are checked while using the lint-staged command. You can do this via a lint-staged part in your package.json or via .lintstagedrc.json file in the root of your directory. The recommended way is to use a config like this:

{
  "*.{ts,tsx,html}": "eslint --cache --fix",
  "*.{ts,tsx,html,scss}": "prettier --write"
}

The example above also includes a fix flag for eslint and a write flag for prettier. During the pre-commit phase, files are changed automatically when possible. To use lint-staged in your pre-commit hook, add a file like this:

#!/bin/sh
. "$(dirname "$0")/_/husky.sh"
 
npx lint-staged
npm run lint

It does not always stop everything, but it does help. To get control over your application, I can recommend running linters and tests to your pipeline. In that case, you know for sure that your code has been checked.

An example Lint-Staged / Husky configuration can be found here.

It can be difficult to produce quality code when the business is waiting for new functionality. To improve code quality, I use SonarQube. This tool helps you to find bugs, code smells, vulnerabilities, and duplications. It is available in a lot of languages including JavaScript, TypeScript, HTML, and CSS. For brevity, I will not explain how you should install SonarQube in this article, but I hope you see the added value.

SonarQube does scan your static code. For me, the greatest benefit is the simplicity of the code, which helps to better understand other developers' code and make fewer mistakes in the code. After the scan, you see metrics of complexity, vulnerabilities, and duplications. This information increases your productivity, maintainability, and consistency. I believe that this can help you to increase the lifetime of the application. In addition, it will help to improve your developer skills.

Each front-end application consists of a lot of packages. These are included in the package.json with a specific version. It is important to update these packages regularly. If you do not, you get a big bang upgrade scenario which takes a lot of time, or more importantly, you could get security issues. Furthermore, your application can be outdated for specific devices. It can make future development hard when you postpone this.

Like using hooks you can use a bot to update these packages. Renovate is one of these bots which you can use for automated dependencies updates. It scans your dependency tree for old versions and updates them via a pull request. First, you should connect Renovate to your repository, so it has permission to read your codebase. Then you can create a renovate.json in the root of your directory. There are some configurations that I can recommend to use. One of these is to auto-merge for a minor or patch update.

“packageRules”: [
  {
      “matchUpdateTypes”: [
      “minor”,
      “patch”
    ],
    “automerge”: true
  },
]

By default, Renovate will create a PR for every package that can be updated. There is a rule to group packages so that we get fewer pull requests. You can create groups based on a pattern. With this can you bundle packages. In the example below I created a group for eslint. This combines updates for eslint and @next/eslint to a single pull request.

{
    “matchPackagePatterns”: [
    “^eslint”,
    “^@next/eslint”
  ],
  “groupName”: “eslint”
},

There are many more options to configure. For instance, when Renovate should run and how many pull requests are allowed to be open at the same time. Auto merge is useful if you have a good CI/CD pipeline with linters, tests, and finally deployment. The complete documentation can be found on the website.

An example Renovate configuration can be found here.

A great part of this article goes about consistency and automation. The code must be clear for other developers and yourself. The lifetime of your application will be longer when you have good maintainability. A few simple tools and configurations can make the code a lot better. Why not use it? It will not get any worse.

I am working hard for code consistency. In my experience, I want to discuss what the code should do and do not like to talk about personal preferences of coding standards. By automating and maintaining you avoid the discussion. Hopefully, this article is helpful for your challenges with developing front-end applications.

Which tools do I use for improving front-end applications?

Wanneer je uit je comfort zone stapt, groei je. 🌱 Dat is waar we onze mensen graag bij helpen! Hoe we dat doen?

In deze video vertelt unitmanager DevOps Harmen Weuring hoe hij de mensen uit zijn unit hierbij helpt. Luuk Tersmette stapte uit zijn comfort zone door het geven van een training via Eduvision Opleiding & Training en vertelt je hoe hij dit heeft ervaren.

Werken bij CINQ - Uit je comfort zone!

Werken bij CINQ - Uit je comfort zone

Eén van de meest gestelde vragen tijdens een sollicitatiegesprek bij CINQ is: 'Hoe gaat dat dan als je een nieuwe opdracht wil?' 


In onderstaande video vertellen Eric Cornet (DevOps engineer) en Marc Jacobs (Directeur HR) hoe CINQ ervoor zorgt dat onze medewerkers blij zijn (of worden) met hun opdracht.

CINQ - De perfecte match - Promo

Ben jij benieuwd geworden naar CINQ en of wij de perfecte match voor jou zijn? 
Bekijk hier onze vacatures of neem direct contact op met Iris Noorman (06-13838845 / iris@cinqict.nl).

Werken bij CINQ - Een perfecte match

Deze presentatie gaat over het verbeteren van je debugging game. De meeste ontwikkelaars gebruiken alleen het spreekwoordelijke topje van de ijsberg bij het werken met de debugger. Er valt nog zoveel meer te leren, dus laten we eens kijken naar interessante mechanismen zoals:

frames laten vallen ("teruggaan in de tijd")

foutopsporing op afstand (waarom op uw lokale computer blijven?)

hot code swapping (sneller dan het opnieuw implementeren van de code)

stream debugging (voor die moeilijk te debuggen streams)

De hele presentatie zal in IntelliJ zijn. Sommige delen zijn specifiek voor IntelliJ, maar de meeste delen zijn van toepassing op alle IDE's.

Improving your skills with the debugger by Bouke Nijhuis

Bouke Nijhuis
Bouke Nijhuis is CTO bij CINQ ICT. Hij vindt het leuk om nieuwe dingen te leren en hij vindt het nog leuker om die aan andere mensen uit te leggen. Verder is hij een internationaal spreker en een committer van open source projecten. Je kunt hem bereiken op Twitter via @BoukeNijhuis.

Bouke Nijhuis op Devoxx 2022 - Improving your skills with the debugger

Site Reliability Engineering (SRE) is a new discipline which is quickly gaining traction within the IT landscape. First conceived by Google, it is now adopted mainly by large enterprises such as Netflix, LinkedIn, Target, Tesla and many more. It is known for a focus on automating manual tasks without enduring value (toil), treating operations as a software problem and its unique approach to systems reliability.

There are many ways to implement SRE. SRE is a multi-faceted discipline. You can create Service Level Objectives to define the level of service to deliver to users, focus on reducing toil with targeted measures, define a risk tolerance for a service and do release engineering to make releases streamlined and consistent.

These, amongst some other practices, primarily dictate a certain way of working. However, some practices are more focused on designing systems to be reliable, highly available and robust. In other words, I see two categories:

Practices which are primarily ways of working; They also have technical implications, but the largest part is how we interact as employees and/or set priorities in what we find important to work on.

Practices which are primarily ways of designing systems; The key aspect of these are designing an application according to certain guidelines such as reliability, availability, robustness, etc. Subsequently the application is created to function to reach these goals.

Not all practices are as easy to apply for a given business. A lot of Googles practices which it has written about in its SRE Handbook has stemmed from dealing with its growing pains. As the organization grew it required cleverer solutions so it could continue to deliver a good service while using resources effectively. Small to medium businesses however do not have some of the challenges and use resources differently. Some examples:

They often use off-the-shelf software as opposed to tailor-made solutions

Teams are more converged. They often operate within one region and have a smaller selection of services to deliver

They have a lesser variety of roles in a team

They have less resources to their disposal

Very highly skilled people tend to flock to large prestigious enterprises as opposed to smaller companies

Given the above differences, the way small to medium business can implement SRE differs. For example:

While using off the shelf software, everything comes at it is. Some practices of SRE dictate how to design and build applications according to certain standards but this is not something you do in this case

Even when software is written for systems administration, it is likely either a smaller application or a script, as opposed to larger complicated systems

Some of these system design principles can be complicated to grasp and to implement, such as distributed consensus and distributed periodic scheduling. The employees working at the company might not have the skills necessary to work with these principles

These kinds of businesses might not scale as fast and investments to a high degree of scalability might not pay off for them

Even though mostly off-the-shelf software is used, you can still apply a lot of the principles in SRE. Instead of using them to design your own software, try to understand the principles and buy software which is built with these principles in mind. For example, you can buy software which has high availability as a feature. 

Having the ability to create your own software gives more opportunities to reduce toil as you have more control over the way your infrastructure is managed. However, you can do a lot with scripts, pipelines or small applications. Doing a routine clean-up in an external system could easily be encapsulated in a Python script ran by a cronjob.

Many principles can be implemented with off-the-shelf software and widely available documentation. Service level objectives can be monitored in many monitoring solutions such as DataDog and Splunk. Having engineers be on-call effectively can also be done with tools such as VictorOps.

Your business might not benefit from all the scale advantages of companies like Google, but investments in scalability can still pay off. Using container orchestration for workloads means scaling applications happens in a consistent and controlled manner. Cloud solutions offer comparable solutions for VMs. Having good control over scaling also helps during maintenance as you can easily scale down a node and perform maintenance temporarily.

Google describes a lot of principles in their SRE Handbook. The base principles upon which they are based are universally applicable but the degree to which they can be implemented and how it is done is likely very different when comparing smaller businesses to large enterprises such as Google. Still, by choosing software which adheres to the principles described and provides features for utilizing SRE, using smaller pieces of software for automation and implementing practices to the appropriate degree, your business can also benefit from SRE.

Challenges of implementing SRE in small to medium businesses

Sinds ongeveer een jaar werk ik met Kotlin, een taal die ik persoonlijk zie als de spirituele opvolger van Java. Het wordt ontwikkeld door JetBrains, de ontwikkelaars van de populaire editor IntelliJ, en heeft een hoop voordelen ten opzichte van Java. Deze voordelen zijn ook niet dusdanig obscuur dat ze niet opvallen - ik gebruik ze bijna dagelijks. In deze blogpost wil ik een blik werpen op welke onderdelen van Kotlin mij helpen, en in sommige gevallen hoe ze zich verhouden tot Java.

Het belangrijkste voordeel wat Kotlin tegenover Java heeft is misschien een valse start, maar het is de reden dat Kotlin zo groot aan het worden is denk ik, en dat is de Java interoperability. Dit houdt in dat Kotlin vlekkeloos samen kan werken met Java in dezelfde codebase. Nog beter, wij kunnen Java-code aanroepen vanuit Kotlin en omgekeerd Kotlin code aanroepen vanuit Java. De compiler heeft hier geen problemen mee en zal zijn werk doen zoals altijd.

Het grote voordeel hieraan is dat Kotlin overal geadopteert kan worden waar Java wordt geschreven. Als een team niet comfortabel is met Kotlin kunnen zij kiezen om kleine stukken van de code te pakken en die om te schrijven naar Kotlin, om zo gaandeweg meer ervaring op te doen met Kotlin en comfortabeler te worden met de taal.

Voortbouwend hierop is dat de ontwikkelaars bij JetBrains er alles aan hebben gedaan om de conversie van Java naar Kotlin zo makkelijk mogelijk te maken. In hun IDE, IntelliJ, hebben zij de functionaliteit ingebouwd om Java-code in een Kotlin bestand te plakken (via copy-paste) om een popup te tonen die vraagt “Wil je deze code omzetten naar Kotlin?”. Als er akkoord wordt gegeven zal IntelliJ zelf de Java-code converteren naar Kotlin code dat in 99% van de gevallen klaar is voor productie. Dit kan een software engineer helpen om bekende Java-code automatisch te converteren en het resultaat te bestuderen om Kotlin beter te leren begrijpen. Er wordt immers vanuit een bekende basis gewerkt in dat geval.

Nu voor de echte start, en mijn persoonlijke favoriet: data classes. In Java bestaan de zogeheten POJO’s, of Plain Old Java Objects. Het zijn simpele objecten met een aantal velden, en methodes om de waardes van die velden op te halen of te veranderen. Een voorbeeld hiervan voor een boek klasse is als volgt:

public class Book {
     private String title;
     private String author;
     private int amountOfPages;
 
     public Book(
         String title,
         String author,
         int amountOfPages
     ) {
         this.title = title;
         this.author = author;
         this.amountOfPages = amountOfPages;
     }
 
     public String getTitle() {
         return this.title;
     }
 
     public String getAuthor() {
         return this.author;
     }
 
     public int getAmountOfPages() {
         return this.amountOfPages;
     }
 
     public void setTitle(String newTitle) {
         this.title = newTitle;
    }
 
     public void setAuthor(String newAuthor) {
         this.author = newAuthor;
     }
 
     public void setAmountOfPages(int newAmountOfPages) {
         this.amountOfPages = newAmountOfPages;
     }
 }

De bovenstaande klasse bestaat uit 38 regels code en is erg simpel. Er zijn drie velden, title, author, en amountOfPages, een enkele constructor, en de getters en setters. Kotlin kan dezelfde code genereren door een data class aan te maken. In het geval van een Book klasse gaat dit als volgt:

data class Book(
     val title: String,
     val author: String,
     val amountOfPages: Int
 )

Dat is alles! Vijf regels code en hetzelfde resultaat is bereikt als de 38 regels van Java code. De Kotlin code beschrijft een constructor tussen de gewone haakjes, en daarbinnen de drie datavelden die wij willen. De compiler zal begrijpen wat nodig is voor de data class en daarmee alle getters en setters genereren.

Het bestaan van de data class maakt het zoveel eenvoudiger om een POJO (of eigenlijk POKO in dit geval) te maken dat het erg aantrekkelijk is om “even gauw” een data class ergens voor aan te maken omdat dit simpelweg eenvoudiger is dan ingewikkeldere constructen zoals een tuple of pair.

De data class is niet de enige soort nieuwe klasse. Kotlin kent voor de visibility van classes naast de private, protected, en public types ook de types sealed en internal.

Een sealed class is een klasse of een interface waarbij alle subklassen en implementaties bekend moeten zijn tijdens het compileren van de code. Dit zorgt ervoor dat een derde partij niet nog een extra subklasse later toe kan voegen als er bijvoorbeeld een library geschreven is (de klasse is “sealed” voor verdere subklassen). Sealed classes hebben hun weg wel gevonden naar Java als een preview sinds Java 15, en als volwaardig onderdeel sinds Java 17. Echter, ze zijn langer aanwezig in Kotlin en hebben betere support. In Kotlin is het bijvoorbeeld mogelijk om een sealed class in een switch statement te gebruiken - Java staat dit als preview functie toe in Java 17, maar er is nog geen officiële support. Ook is Java stricter in het gebruik van sealed classes. De sealed class zelf moet expliciet aangeven welke subklassen toestemming hebben om een extension te maken via het keyword permits.

In mijn optiek zorgt dit voor meer verbose code en ligt mijn voorkeur bij de aanpak van Kotlin. Daarbij mag elke klasse een subklasse zijn, maar de subklassen moeten in dezelfde file als de sealed class staan. Een voorbeeld daarvan staat hieronder. Het werken met sealed classes vind ik zelf erg fijn in Kotlin doordat de code compact is, en ik weet dat ik klassen kan schrijven die alleen de subklassen heeft die ik wil, wanneer dan ook. Dit kan recente versies van Java inmiddels ook.

sealed interface Error
 
sealed class IOError(): Error
class CustomError(): Error

Een companion object is een manier in Kotlin om statische variabelen te maken die onderdeel zijn van een klasse, maar gebruikt kunnen worden zonder de klasse te instantiëren. Doorgaans gebruik ik een companion object zelf om statische variabelen aan een klasse toe te wijzen zoals normaal in Java gedaan zou worden. Dit gaat heel eenvoudig op de volgende manier:

class Coffee {
     companion object {
         const val optimalTemperatureInCelsius: Int = 140
     }
 }

Belangrijk hierbij is dat er een annotatie extra nodig is voor goede Java interoperability. Door @JvmStatic boven de companion object variabele te plaatsen kan dit bereikt worden. Dit is nodig omdat een companion object in Kotlin kan overerven van klassen of interfaces, maar in Java is dit niet mogelijk.

Er zijn nog andere manieren waarop nuttig gebruik gemaakt kan worden van een companion object. Een voorbeeld hiervan is het Factory design pattern. Door gebruik te maken van een named companion object kan een Factory heel eenvoudig opgezet worden:

class Coffee {
     companion object Brewer {
         fun brew(): Coffee = Coffee()
     }
 }

De factory is Brewer genoemd in dit voorbeeld, en de gebruikelijke createInstance is nu brew genoemd om in het thema van de klasse te blijven. Vervolgens kan de factory gebruikt worden op de volgende manier:

Ik vind persoonlijk null safety erg belangrijk in code, en ik ben erg blij met het type system in Kotlin. Het type system probeert namelijk om null referenties te voorkomen. Dit wordt gedaan door variabelen niet standaard een null mogelijkheid te geven, maar dit expliciet af te laten dwingen. Bijvoorbeeld, bij het aanmaken van een String moet de String een waarde toegewezen krijgen, anders compileert de code niet. Door gebruik te maken van een ? bij de variabele vertel je de compiler dat null toegewezen mag worden aan de variabele.

val someString: String = "Hello There" // mag geen null zijn
val anotherString: String? = null      // mag null zijn

Helaas zie ik in mijn dagelijks programmeerwerk een hoop mensen die denk ik uit gemak toch vaak met null willen werken. Ik zie dit als een soort “Java-isme” wat over is gekomen naar Kotlin. Hierdoor is de code al vrij snel bezaaid met ?s en de bijbehorende if-statements die op null controleren. Gelukkig is Kotlin hier op voorbereid en is er een shorthand voor de null checks in de vorm van, alweer, een vraagteken ?. Dit werkt als volgt:

Kotlin controleert hier of de waarde van anotherString null is of niet. Als er null geconstateerd wordt dan gebeurt er verder niks - de check heeft gefaald. Als er geen null wordt geconstateerd dan heeft anotherString dus een waarde gekregen. In dat geval voert Kotlin het let deel uit en wordt de waarde van anotherString geprint.

Een andere manier van nullable variabelen gebruiken is minder veilig dan de ?, maar kan soms zijn nut hebben. Het kan namelijk gebeuren dat Kotlin een variabele als een mogelijke null ziet, maar als software engineer is duidelijk in de code te zien dat dit nooit kan gebeuren. In zulke gevallen kan gebruik gemaakt worden van een dubbele bang (!!). Dit dwingt af dat de waarde van de variabele gebruikt wordt - ook als dit alsnog null zou zijn. Het gebruik van !! moet dan ook, vind ik, minimaal blijven en het liefste voorkomen worden. Helaas heeft het vele gebruik van nullable variabelen met ? als gevolg dat de code ook al snel bezaaid is met !!s, waardoor de null safety van Kotlin in mijn ogen onderuit wordt gehaald. Dit neemt alleen niet weg dat de null safety van Kotlin een welkome functionaliteit is die goed werkt.

Named arguments neem ik tegenwoordig dusdanig voor lief dat ik verbaast was toen ik (her)ontdekte dat Java deze feature niet ondersteunt. Het is een kleine toevoeging in de code, maar het maakt (in ieder geval voor mij) echt een wereld van verschil. Bij het gebruiken van een functie met argumenten kunnen de argumenten namelijk een toegewezen naam krijgen, zoals gedefinieerd in de functie zelf, maar nog belangrijker is dat ze ook een eigen plek toegewezen kunnen krijgen.

Normaal gezien zou een functie in Java gedefinieerd en gebruikt worden als volgt:

public static Coffee create(String name, int temperature, BeanType beanType) { ... }
 
Coffee.create("Cappucino", 95, BeanType.DARK_ROAST);

In bovenstaand voorbeeld is impliciet duidelijk waar de argumenten voor staan, maar om zeker te zijn moet toch naar de functie definitie gekeken worden. Dit kan nog omzeild worden door de argumenten eerst te definiëren:

String name = "Cappucino";
int temperatureInCelsius = 95;
BeanType beanType = BeanType.DARK_ROAST;
 
Coffee.create(name, temperatureInCelsius, beanType);

Echter, dit zorgt voor meer regels code en is een manier van werken die ik tegenwoordig niet mooi meer vind. De zojuist gegeven voorbeelden kunnen met behulp van named arguments in Kotlin geschreven worden op een mooiere manier.

class Coffee(name: String, temperature: Int, beanType: BeanType)
 
Coffee(name = "Cappucino", temperature = 95, beanType = BeanType.DARK_ROAST)

Nu is direct bij het aanmaken van een Coffee object te zien waar de argumenten voor staan. In dit geval staan de argumenten nog in dezelfde volgorde, maar stel dat we de argumenten in een andere volgorde willen, bijvoorbeeld om extra focus te leggen op het type boon. Dit kan eenvoudig opgelost worden door beanType naar voren te plaatsen. Of stel dat name een standaard waarde heeft die wij willen gebruiken. In dat geval slaan wij het hele argument simpelweg over.

// Andere volgorde
Coffee(beanType = BeanType.DARK_ROAST, temperature = 95, name = "Cappucino")
 
// Argument overslaan. Eerst wordt een klasse definieerd met een standaard waarde voor 'name'.
class Coffee(name: String = "Black", temperature: Int, beanType: BeanType)
 
Coffee(beanType = BeanType.DARK_ROAST, temperature = 95)

Als laatste functionaliteit wil ik de string templates van Kotlin in het licht zetten. Strings zijn in Java lastig om mee te werken, of in ieder geval om te manipuleren. In Kotlin kunnen argumenten direct in de String zelf worden geplaatst. Deze functionaliteit is ontzettend eenvoudig maar voegt zoveel plezier in het programmeren toe, simpelweg doordat een complexe String opbouwen zo makkelijk gaat.

Als voorbeeld, stel dat wij een rekensom uitgeprint willen hebben als String. Dit is in Kotlin direct uit te voeren:

val firstNumber = 25
val secondNumber = 5
 
println("First number is $firstNumber. Second number is $secondNumber.\n$firstNumber / $secondNumber = ${firstNumber / secondNumber}")

De argumenten kunnen direct in de String gebruikt worden door er een $ voor te plaatsen. Bij complexe onderdelen van de String kunnen simpele berekeningen gedaan worden door de berekening te plaatsen binnen haakjes {}. [String templates zijn in versie 19 ook aan Java toegevoegd - red.]

Ik hoop dat deze blogpost meer was dan een simpele vergelijking tussen Java en Kotlin. Kotlin is een programmeertaal die dagelijks het programmeren makkelijker en leuker maakt voor mij dankzij het gemak van de features die het heeft. Het voelt op zijn minst als een goede toevoeging aan het JVM-ecosysteem, en uiteindelijk als een oprechte opvolger voor Java. Als je Kotlin nog nooit hebt gebruikt, geef het een keer een kans!

De dagelijkse voordelen van Kotlin

We all have to deal with it, static, boring email alert notifications. This while the content is about business-critical processes or applications. Unfortunately, this also happens with most of Splunk's alert emails.

The following approach should be familiar, if you have ever created alerts in Splunk. It starts with a need in the organization. Someone wants to be alerted when there’s a problem regarding availability, performance, or on the increase or decrease of a certain figure. 

As a Splunk Consultant you will work with the customer demand and translate this need into a concrete solution. You create a search that provides the right data and save that as an alert in Splunk. In the alert settings you set your trigger conditions, and make sure that the alert is send by email to your recipients. In this email you put the required values from your Splunk search through tokens and that's it. 

The result is like below, valuable information in a boring email with a piece of text. That being said, there are some good standard options to put the results in the attachments, or to display them as a table and/or add a link to the results. Still, this had to be done differently and is also very easy to achieve.

To stop boring alert emails like above, we are going to make use of HTML and CSS email templates. And that’ what this blog is all about. This blog is divided into two parts. The first part focusses on how to customize Splunk so that HTML is supported. The second part will be an example of how to use and create HTML e-mails with a working example.

Modify Splunk to support HTML in email alerts.

When a Splunk environment sends out an email, a Python script called sendemail.py is used in the background. The script itself resides in the location Splunk/etc/apps/search/bin/sendemail.py. To support HTML, we’re going to modify this script slightly so that html is allowed in the body section of the emails.

For the actual modification of the script there are 2 options:

Option 1, modify the existing script in the existing place. Then the change is implemented for the entire Splunk environment, and all e-mails will support HTML. 

Option 2 copy the python script to your own custom app, then the HTML email templates are only implemented and supported in this app.

In this blog, we’ll go for the second option. This is also the most likely option, since this change will not affect the rest of the Splunk environment, and will just be applied and work for 1 app. Hence, if you want to go with option 1, you would only have to alter the script (see below second bulletpoint) and save the changes to the Splunk environment.

Copy the existing python script Splunk/etc/apps/search/bin/sendemail.py to your own splunk app (in this tutorial named myApp). Save it in the same app/folder location and rename the script (my_sendmail_html.py). If done correctly it should be in the following location: Splunk/etc/apps/myApp/bin/my_sendmail_html.py

Open the python script (original one for option 1, mysendemail.py for option 2) with a text/code editor and look for the text ${msg|h}. remove the |h so it becomes just ${msg} and save the script again.

Create a commands.conf in the local folder of the myApp app, which assigns the command to the mysendemail.py script just created.
❖   Filename and location: 
▪︎  Splunk/etc/apps/myApp/local/commands.conf
❖   contents commands.conf:


[sendemail]
filename = my_sendmail_html.py
streaming = false
run_in_preview = false
passauth = true
required_fields =
changes_colorder = false
supports_rawargs = true
undo_scheduler_escaping = true
is_risky = true
local = true

Upload the myApp app to the Splunk environment. From now on. HTML is supported in email alerts sent from this app. If you do not apply html in the alerts, the email will be sent as usual.

With the myApp in place we will create an alert as we normally would. So we begin with running a search that would trigger an alert.

| makeresults
``` send alert only if set to 1, this so we have a trigger mechanism ```
| eval sendalert=0
``` alert header will be used as subject ```
| eval HEADER="HTML Splunk Alerting CinqICT."
``` fields that will be used in the email ```
| eval SUMMARY="A Positive Normal Performance alert for department Data Businessunits and test HTML Email Alerting at step Send Fancy Email was triggered."
| eval DEPARTMENT="Data Businessunits"
| eval TEST="HTML Email Alerting"
| eval STEP="Send Fancy Email"
| eval LOCATION="Burgemeester Stramanweg 101, 1101 AA Amsterdam."

After running the above search, we will click “Save As”, “Alert”.

Next we fill out the form as shown below.

What we have now created is an alert that runs via CRON schedule once a minute, and triggers when sendalert=1 is set. Once triggered it sends an email to tom.de.bruijn@cinqict.nl.  Then as a subject the field HEADER is used by calling $result.fieldname$. In the message section several fields are used to compose the email body.

1)    Now that the alert is active, we can start testing the alerting, we will go back to the search and change sendalert=0 to sendalert=1, we run the search and afterwards save the alert. Then we wait a minute until the CRON triggers the alert. After an email is received change it back to sendalert=0 and save the alert again, to stop receiving e-mails every minute.

2)   We will end up with below a-mail alert, that was also shown at the beginning of this blog.

3) Now let’s go back to the alert search and change the text in the MAIL token to an HTML and CSS styled text.

In this blog I’m using a template I created earlier myself. The actual building and styling of a HTML template I left out of this demo. However, to get started and get some ideas, I looked at existing email templates in my mailbox and looked on the internet for email templates. I also use the company branding to match my own template. I built and test the templates by using Jsfiddle, as I found that easy for debugging. Note that your CSS must be embedded in your html and not be a separate file. Get started with just some simple html and when that works expand. And as a final tip, you could use red/orange/green color indications, or images, via tokens to emphasize the different severities of your alerts.

Once you have tested your HTML template in your browser, we need to change it so it becomes a Splunk string. Therefore, we have to escape the double quotes with a leading backslash and once done put a double quote (not escaped) at the beginning and end of the html. Please note, that all fields like DEPARTMENT, TEST, STEP and LOCATION have been submitted as a token input in the EMAIL string.

| makeresults
``` send alert only if set to 1, this so we have a trigger mechanism ```
| eval sendalert=0
``` alert header will be used as subject ```
| eval HEADER="HTML Splunk Alerting CinqICT."
``` fields that will be used in the email ```
| eval SUMMARY="A Severe Performance alert for department Data Businessunits and test HTML Email Alerting at step Send Fancy Email was triggered."
| eval DEPARTMENT="Data Businessunits"
| eval TEST="HTML Email Alerting"
| eval STEP="Send Fancy Email"
| eval LOCATION="Burgemeester Stramanweg 101, 1101 AA Amsterdam."
``` html email template ```
| eval MAIL="<body style=\"background-color: #f1f1f1; \"><header>   <div class=\"panel-body html\" style=\"max-width:1000px; margin: 10px auto auto auto;\">     <div style=\"min-height:130px; height:auto;border-radius: 5px; text-align: left; background-color: #545454;\">        <img src=\"https://media-exp1.licdn.com/dms/image/C4E0BAQHp5PH21idHPg/company-logo_200_200/0/1652183310444?e=1667433600&v=beta&t=B0VuCkIHaYp2J_YOzNJjbTnZQWnR0qQ9g7vp6w6Pv7w\" width=\"125px\" style=\"padding: 0px 20px 0px 0px;\" align=\"right\">       <table>         <tbody>           <tr>            <td height=\"10%\" width=\"750\" style=\"padding:0cm 0pt 0cm 5.4pt\">            <span style=\"font-size: 35px;font-weight: bold; color: #ffffff; \">".HEADER."</span>            </td>           </tr>           <tr>            <td height=\"1\" width=\"750\" style=\"padding:0cm 0pt 0cm 5.4pt\">            <span style=\"font-size: 16px; color: #ffffff; color: #FBD913;\">".SUMMARY."</span>            </td>           </tr>          </tbody>         </table>         </div></div></header><section><div class=\"panel-body html\" style=\"max-width:1000px; margin: 10px auto auto auto;\">   <div style=\"line-height: 25px; height:25px;border-radius: 5px; text-align: left; background-color: #545454; \">   <span style=\"font-size: 14px; font-weight: bold; color: #FBD913; padding-left: 0.5em; margin: 0; position: relative;\">Details listed</span>   </div></div><div class=\"panel-body html\" style=\"background-color: #DFDFDF;border-radius: 5px; max-width:1000px; margin: 10px auto auto auto;\">     <span style=\"font-size: 13px; color: #000000; position: relative; left: 2%;\">     <table cellspacing=\"0\" cellpadding=\"0\" style=\"border-spacing: 0;border-collapse:collapse;border:none\"> <tbody> <tr>  <td width=\"142\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 0pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Department</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">".DEPARTMENT."</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Test</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">".TEST."</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Step</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">".STEP."</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Event Type</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">Response Time</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Location/Nodes</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span lang=\"EN-US\" style=\"font-size:11.5pt;font-family:  &quot;Segoe UI&quot;,sans-serif;color:#201F1E\">".LOCATION."</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Responsetime Message</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span lang=\"EN-US\" style=\"font-size:11.5pt;font-family:  &quot;Segoe UI&quot;,sans-serif;color:#201F1E\">Performance restored from warning to  normal threshold!</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Thresholds</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">Warning = 5, High = 8</span></b></p>  </td> </tr> <tr>  <td width=\"142\" valign=\"top\" style=\"width:106.35pt;border:none;border-right:solid windowtext 1.0pt;  padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><span style=\"font-size:11.5pt;font-family:&quot;Segoe UI&quot;,sans-serif;  color:#201F1E\">• Alert Time</span></p>  </td>  <td width=\"434\" valign=\"top\" style=\"width:325.4pt;border:none;padding:0cm 5.4pt 0cm 5.4pt\">  <p class=\"MsoNormal\"><b><span lang=\"EN-US\" style=\"font-size:11.5pt;font-family:  &quot;Segoe UI&quot;,sans-serif;color:#201F1E\">Alert Start Time: 2022-07-25 11:44:44<br>  Alert End Time: 2022-07-25 12:59:00<br>  Total Alert Time: 1 hour, 14 minutes and 16 seconds.</span></b></p>  </td> </tr></tbody></table></span>   </div></section><footer><div class=\"panel-body html\" style=\"max-width:1000px; margin: 10px auto auto auto;\">   <div style=\"line-height: 25px; height:25px;border-radius: 5px; text-align: left; background-color: #545454; \">   <span style=\"font-size: 14px; font-weight: bold; color: #FBD913; padding-left: 0.5em; margin: 0; position: relative;\">Extra Information</span>   </div></div>   <div class=\"panel-body html\" style=\"background-color: #DFDFDF; height: auto; border-radius: 5px; max-width:1000px; margin: 5px auto auto auto;\">   <a href=\"https://www.linkedin.com/in/tcdebruijn/\">     <span style=\"font-size: 13px; color: #000000; position: relative; left: 2%;\">Confluence Splunk Dashboards</span>   </a>   </div>        <div class=\"panel-body html\" style=\"background-color: #DFDFDF; height: auto; border-radius: 5px; max-width:1000px; margin: 5px auto auto auto;\">   <a href=\"https://www.linkedin.com/in/tcdebruijn/\">     <span style=\"font-size: 13px; color: #000000; position: relative; left: 2%;\">Jira Servicedesk</span>   </a>   </div></footer></body>"

We save this alert search once again and upon editing the alert we change the MESSAGE section to $result.MAIL$ only, keep Subject and everything else as is.

We can start testing the alert with changing sendalert=0 to sendalert=1 in the alert search again, and off course save it once more. Once a minute has past, an alert will be sent and the HTML in your search will be transformed to HTML in your email Template.

Enthusiastic? Or still need some extra assistance with this? Please let us know, we are happy to help!

Stop boring email alerts!

Simpel, eenvoudig en snel. Je wil snel aan de slag en dat is wat je als frontend developer maar al te graag wil. Bij verschillende projecten heb ik al meegemaakt dat je meermaals (lang) bezig bent met het configureren van de build tool, zonder dat je ook maar toe komt aan een regel programmeren. Dat hoeft niet erg te zijn, maar er zijn leukere dingen om je mee bezig te houden. Vite stelt zich voor als de volgende generatie frontend tooling.

Vite heeft een ecosysteem neergezet waarbij je snel kan beginnen met het ontwikkelen van een project. Hierbij is het mogelijk om direct gebruik te maken van de populaire frameworks als React en Vue, maar ook vanilla JavaScript is een kwestie van je ogen dicht doen. Met zero configuration heb je snel een tooling gereed waarbij je gebruik kan maken van SASS, TypeScript of wat dan ook. 

Vite richt zich op snelheid en performance door de development ervaring te verbeteren. Zo maakt het niet uit hoe groot je applicatie is, de applicatie start altijd snel op. Hot Module Replacement (HMR) zit eveneens in de core configuratie. Hiermee wordt dus alleen herladen wat je op dat moment hebt aangepast. De laatste belangrijke pijler is het compileren/bundelen van JavaScript door middel van ESBuild, welke bekend staat als een van de snelste bundlers van dit moment.

Onder de motorkap maakt Vite gebruik van zowel ESbuild als Rollup. Een van de redenen om gebruik te maken van ESbuild is omdat deze slim overweg kan met dependencies. Doordat deze niet frequent veranderen hoeft deze niet bij elke build opnieuw gecontroleerd te worden. Rollup wordt gebruikt zonder dat je daarvoor iets extra’s hoeft in te stellen. Dat kan natuurlijk wel, net als een heleboel andere dingen.

Vite omschrijft zichzelf dus als de tool die gebruikt maakt van de nieuwe ontwikkelingen van het ecosysteem; de beschikbaarheid van native ES-modules in de browser en de opkomst van JavaScript tools die compilen tot native languages. 

Nu de theorie veel belovend klinkt ben ik benieuwd hoe dit in de praktijk zal uitpakken. Begin een Vite project met het volgende commando in de terminal:

Bij de eerste keer van dit commando krijg je de vraag om de laatste packages te installeren, waarna je het project van een naam en framework moet voorzien. 

npm create vite@latest
Need to install the following packages:
  create-vite@latest
Ok to proceed? (y) y
✔ Project name: … vite-cinq
✔ Select a framework: › react
✔ Select a variant: › react-ts

Scaffolding project in /Users/jeroen/Development/_temp/vite-cinq...

Done. Now run:

  cd vite-cinq
  npm install
  npm run dev

Na een npm install en npm run dev is mijn lokale omgeving tussen 350-500 ms opgestart. Dat is best snel en dat zonder enige configuratie. Om het wat spannender te maken heb ik het React TypeScript TodoMVC 2022 project uitgecheckt en in mijn Vite project geplaatst. De conclusie was al vrij snel dat ik tot hetzelfde resultaat kwam als bij de initiële setup. Ook de standaard beloofde Hot Module Replacement (HMR) deed wat het moest doen. Ik heb op geen enkel moment een harde refresh van de hele applicatie nodig gehad. 

Het bouwen van productiecode gaat even makkelijk als het starten in de development mode. Hoewel dit bij andere tooling ook wel te doen is, lijkt het voor mijn gevoel sneller te gaan. Een mooie toevoeging is dat je na het commando npm run build ook een commando npm run preview hebt om het eindresultaat snel te kunnen zien. Dat vind ik een leuk pluspunt.

Zo zijn er nog meer dingen die out of the box al standaard werken, bijvoorbeeld:

het toevoegen environment variables volgens de dotenv structuur; 

het gebruiken van CSS modules en/of CSS Pre-processors;

het instellen hoe je assets ingeladen moeten worden en;

het gebruiken van global en dynamic imports.

Of Vite de vervanger van Webpack gaat worden durf ik niet te zeggen. Net als met veel andere tools en frameworks gebeurt er veel onder de motorkap, waardoor je niet zelf inzicht hebt over hoe en wat er gebeurt. Je hebt alleen zicht op de input en de output. Bij Vite vind ik het verschil tussen development (esbuild) en productie (rollup) niet prettig.

Al met al krijg ik over Vite als tool een goede indruk, omdat het mij – na een paar uurtjes ermee spelen – een positieve vibe geeft aan de developer experience. Je krijgt veel out of the box om een snel een project te kunnen starten. Dit maakt het voor mij toegankelijk om hier bij een greenfield project voor te kiezen. Of je ook echt moet willen dat een tool je (snel) alles geeft betwijfel ik. Graag zou ik wat meer controle willen hebben.

Wordt ViteJS de opvolger van Webpack?

In this blog I would like to talk about Cribl and what its possibilities are and what their certification track currently looks like. 

After seeing a demo of the possibilities of Cribl I wanted to learn more about the product and how we could use it. I have been a Splunk administrator for a few years now and while following the demo I could see how Cribl solves some of the issues and struggles I face as a Splunk administrator. 

Cribl positions itself as a layer between your data sources and your data analytics tools like Splunk, Elastic, Databricks & more.

They call this layer: Cribl Stream. It can receive data and then change, transform and reduce the data before sending it off to different destinations. Below are a few of the options that Stream offers:

Change the data format of the data going out, for example you could change it to JSON.

Drop all the empty/null value fields in the data.

Sent a portion of the event to your SIEM and store the raw log event into a S3 bucket as an archive.

Replay that archive S3 bucket to load the full events into your SIEM when you need to investigate/troubleshoot an issue.

Mask sensitive information for 1 destination but send all data to a 2nd data analytics tool.

Receive data from existing agents as the Splunk forwarder or Elastic Beats.

All of these options are available in a GUI and you can see the effects of changes you are making before actually applying them. After learning about the possibilities I decided it was worth to do a proof of concept in my local test environment.

The goal of the proof of concept was to see how I could send data from a network appliance, and get it into Splunk in a JSON format while also reducing the noise in the events.

There are several options for installing Stream. You can install it on your local machine, use Docker containers or you can make use of their free cloud environment to test things. I installed Stream on a Linux virtual machine and after a few minutes it was already up and running.

The first thing I needed to do was to send data to Stream. Since it is able to receive syslog data, I logged into my router/firewall and started to send my network traffic information to Stream using syslog. In the Stream GUI I started to look at the data coming in, there were a few fields to remove and I wanted to rename some of the other fields. 
After a few minutes I had prepared the changes and could see what would happen if I pushed the change out. The data was almost ready, I only needed to change the format to JSON and add an index and sourcetype field since I was going to send the data to my local Splunk HEC endpoint. 
All in all the entire POC cost about an hour to do and I was really happy with the results.

Besides Stream they also offer the edge software, which is an agent you can install on Linux or Windows servers. The main point of the agent is that it can be used to discover data and also route the data to different types of receivers like, Splunk, Elastic or Databricks. This could help to reduce the amount of agents needed on endpoints and have 1 agent to get the data from your endpoints.

To learn more about Stream, I went to https://cribl.io/university/ and saw that they offer the certification tracks for free. Currently there are two certifications that you can acquire:

For anyone wanting to learn more about Stream, I highly recommend to start with Stream User. It is a combination of video’s, questions and their own sandbox environment which lets you make the changes in the actual product. You really get a good sense of the possibilities of Stream and how you should use the product. 

After finishing the Stream User I went along and followed the Stream Admin track, they really go in depth and help you understand what is happening inside of Stream. If you are thinking about doing a Proof of concept in an enterprise environment this will really help you understand how to set it up. 

I hope this blog gives a feel of what Cribl is and does, and if you have any questions please feel free to reach out to me on LinkedIn.

In this blog we introduce you to the Cribl product. What does it do and what does it's certification track look like?

The Cribl product and their certifications

CINQ ICT is door de Cloud Native Computing Foundation uitgeroepen tot Kubernetes Training Partner. Hiermee erkent CNCF dat CINQ zich heeft bewezen als betrouwbare partner voor het geven van Kubernetes trainingen, workshops én examentraining. 

Voor een introductie in Kubernetes of deep-dive in de meest geavanceerde functies staan onze Certified Kubernetes Administrators klaar om organisaties, teams en jou als engineer verder te helpen in de wereld van Kubernetes. We brengen je de basis bij of stomen je klaar voor het Certified Kubernetes Administrator examen of Certified Kubernetes Application Developer examen. 

Door jarenlange ervaring met Kubernetes op enterprise-level, weten onze trainers als geen ander wat belangrijk is om Kubernetes succesvol te implementeren en beheren. De trainers van CINQ zijn CKA en/of CKAD gecertificeerd en brengen met hun praktijkervaring een mooie verdieping aan op de bestaande theorie. Zo weet jij zeker dat je echt wat opsteekt van onze trainingen, en kun je dit ook direct in de praktijk toepassen.

Bekijk het volledige aanbod van onze Kubernetes trainingen of neem contact op voor een training op maat. We helpen je graag!

CINQ ICT is uitgeroepen tot Kubernetes Training Partner in Nederland.

Kubernetes Training Partner

CINQ ICT uitgeroepen tot Kubernetes Training Partner

Op woensdag 11 mei heeft onze managing consultant Bouke Nijhuis op Devoxx UK 2022 mogen spreken over één van zijn favoriete Java tools: de debugger. 

Niet alleen gaf Bouke uitleg en tips, maar tijdens een live demo onthulde hij enkele verborgen pareltjes van de debugger en liet hij zien wat je er precies mee kan. 

remote debugging (why stay on your local machine?)

inline watches (interesting values directly in the code)

hot code swapping (faster than rewriting the code)

stream debugging (for those 'hard to debug' streams)

Natuurlijk willen wij deze tips graag met je delen, mocht je het gemist hebben. 

Op woensdag 11 mei heeft onze managing consultant Bouke Nijhuis op Devoxx UK 2022 mogen spreken over één van zijn favoriete Java tools: de Debugger. Bij deze delen wij graag de video van zijn presentatie 'Improving your debugging skills'.

Onze laatste blogs