Op dinsdag 22 juli organiseren we samen met onze vrienden van Sysdig een AI Meetup bij ons op kantoor. Dit event staat volledig in het teken van AI. De eerste workshop gaat over hoe je LLMs kan gebruik om K8s te troubleshooten. De tweede workshop zal gaan over het maken van workflows binnen n8n waarin we gebruik maken van AI-agents. Beide workshops zullen gebruiken maken van een lokale LLM. De afsluiting is een spannende hands-on Capture the Flag workshop waarin je als team met behulp van Sysdig’s AI assistant Sage probeert een hack te voorkomen en als eerste de kluis moet zien te kraken om te zegevieren.

Voor wie is deze workshop?
Voor iedereen met interesse in AI en enige ervaring in de IT.

Hoe kan ik me voorbereiden?
Deze informatie vind je binnenkort op deze Meetup pagina.

18:00 | Workshop - Mastering K8s Troubleshooting with K8sGPT door Sander Lambrechts (CINQ)

18:30 | Workshop - Building Agentic Workflows with n8n door Dennis Vermeulen (CINQ)

19:15 | Workshop - AI Security Challenge: Capture the Flag met Sysdig Sage door Roald Ruchti en Marcel Claassen (Sysdig)

Op dinsdag 22 juli organiseren we een Meetup in het teken van AI. In drie hands-on workshops verkennen we verschillende LLM's en toepassingen van AI.

Meetup door Sysdig & CINQ: AI workshops

Java has come a long way since its early days as an object-oriented, imperative programming language. Over time, it has steadily adopted features inspired by functional programming, a paradigm focused on immutability, pure functions, and type safety—principles long embraced by languages like Haskell.

From lambda expressions and functional interfaces in Java 8 to records in Java 11, Java has been evolving to make functional programming more accessible. However, one crucial feature has been missing—the ability to define algebraic data types (ADTs) in a concise and type-safe way. With the introduction of sealed classes, Java now fills this gap, enabling developers to write code that mirrors the expressiveness and immutability of functional languages like Haskell.

In this blog, I’ll explore how Java is embracing functional programming principles and demonstrate why sealed classes are the missing piece of the puzzle for writing fully functional code in Java, using the purely functional language Haskel as an example.

A sealed class in Java restricts which other classes or interfaces can extend or implement it, enabling developers to define a controlled hierarchy and enforce inheritance rules. This restriction is explicitly enforced by the Java compiler, ensuring that only specified, predefined subclasses are allowed to inherit from the sealed class. 

To declare a sealed class (or interface), you use the `sealed` keyword on the class definition, followed by a `permits` clause that lists all allowed subclasses:

public sealed class Shape permits Circle, Triangle, Rectangle {
    // class contents
}

In this example, `Shape` is a sealed class that is extended by `Circle`, `Triangle`, and `Rectangle`.

When a sealed class defines its permitted subclasses, those subclasses must be declared within the same module or package as the sealed class and compiled together. Each subclass of a sealed class must include one of the following modifiers. The final modifier indicates that the subclass is the last type in the hierarchy and cannot be extended further. The sealed modifier allows the subclass to define its own permitted subclasses, continuing the sealed hierarchy. The non-sealed modifier removes inheritance restrictions, allowing any class to extend this subclass.

public sealed class Shape permits Circle, Triangle, Rectangle {}

final class Circle extends Shape {}
sealed class Triangle extends Shape permits Pyramid {}
non-sealed class Rectangle extends Shape {} 
final class Pyramid extends Triangle {} 

// And an unknown, at runtime, number of children of Rectangle e.g.
final class Square extends Rectangle {} 

In this example, Shape is the sealed class that is extended by ‘Circle’, ‘Triangle’ and ‘Rectangle’. Circle is final and cannot be subclassed. Triangle is defined as sealed, and therefore must declare permitted subclasses. Rectangle is non-sealed meaning it can be subclassed, meaning it can be subclassed without restriction.

Haskell is a purely functional programming language that emphasizes immutability, lazy evaluation, and strong static typing. It supports higher-order functions, allowing functions to take other functions as arguments or return them—similar to lambda expressions and functional interfaces introduced in Java 8. Haskell also includes algebraic data types (ADTs), which enable expressive and type-safe data modeling. Its product types resemble records introduced in Java 11, while its sum types are similar to Java’s sealed classes introduced more recently.

Java has increasingly adopted features inspired by functional programming, particularly to address challenges in concurrency. Functional programming minimizes the use of variables and promotes immutability by default, ensuring computations are thread-safe. This makes functional programs highly scalable and reduces the risk of bugs caused by shared mutable state, offering significant advantages for modern, parallel systems.

In the following sections, I’ll walk you through how a (simple) List is implemented in Haskell, followed by its functional equivalent in Java. I chose the List because it’s often considered the "Hello, World" of Haskell programming—simple, fundamental, and a great starting point for understanding functional concepts. 

-- Define a List data type 
data List a = Empty             -- Represents an empty list 
            | Cons a (List a)   -- Represents a non-empty list 
                                -- (head + tail) 

-- Add an element to the list 
addElement :: a -> List a -> List a 
addElement element list = Cons element list

In the first two lines, the List type is defined with two constructors: Empty, representing an empty list, and Cons (Constructor) , representing a value (the head) followed by the rest of the list (the tail). Notice the use of recursion. The letter ‘a’ is used in the same way as ‘T’ in Java to represent a generic type.

Next, a single global function called addElement is declared to add an element to the beginning of a list. This function is defined in two parts. The first line specifies its type signature—it takes a value of type a and a List of type a, then returns a new List of the same type. The second line provides the implementation, which is notably concise. It creates a new Cons entity, setting the provided value as the head and the existing list as the tail.

In the following code, a list is declared, and a new list is created by prepending an element. Notice that addElement returns a new list object, leaving the original list unchanged. This design ensures that the list is immutable by definition.

myList :: List Int
myList = Cons 1 (Cons 2 (Cons 3 Empty))       -- [1 2 3]

let newList = addElement 0 myList             -- [0 1 2 3]

Now let's write the same code in Java, in a pure functional way.

// Define the sealed class hierarchy
sealed interface List<T> permits Empty, Cons{} 

// Represents an empty listrecord 
Empty<T>() implements List<T> {}

// Represents a non-empty list (head + tail)record  
Cons<T>(T head, List<T> tail) implements List<T> {}

// Utility class to work with the List ADT
class ListUtils {
    // A useful to String method
    public static <T> String toString(List<T> list) {
        return switch (list) {
            case Empty<T> ignored -> "";
            case Cons<T> cons -> cons.head().toString() + " " 
               + toString(cons.tail());        
    };    
}    
    // Add an element to the list    
    public static <T> List<T> addElement(T element, List<T> list) {     
        return new Cons<T>(element, list);    
    }
}

By using a sealed interface List that only permits the records Empty and Cons, we can create an immutable algebraic data type (ADT) in Java. While some of Haskell’s compactness and conciseness is lost in translation, the result is still quite readable and maintains the functional programming style.

The global functions, toString and addElement, are defined in a utility class, although they could also be implemented directly within the List interface. Notably, the toString method uses pattern matching and ensures exhaustiveness in the switch statement, making the code both safe and expressive. This design maintains immutability and type safety, showcasing how Java can incorporate functional programming concepts inspired by languages like Haskell.

public class Main {
    public static void main(String[] args) {
        // Create a list: [ 1 2 3 ]
        var myList = new Cons<>(1, new Cons<>(2, 
                     new Cons<>(3, new Empty<>())));
        var newList = ListUtils.addElement(0, myList);

        // Will print: [ 0 1 2 3 ]
        System.out.println("[" + ListUtils.toString(newList) + "]"); 
    }
}

This code closely mirrors the previous Haskell example. It demonstrates how to initialize a List and create a new one by prepending a zero to the beginning. While Java already offers a variety of predefined thread-safe data structures, this example highlights how Java has taken further steps toward embracing functional programming.

In this blog, I demonstrated how Java has steadily adopted features from functional programming languages like Haskell. With the introduction of lambda expressions, records, and most recently, sealed classes, Java has evolved to support immutability, type safety, and expressive data modeling.

I also showed that Java can achieve many of the same benefits as Haskell—such as thread safety andscalability—while retaining its object-oriented foundation. With sealed classes filling the final gap, Java is now fully equipped to support a functional programming style, allowing developers to write cleaner, safer, and more maintainable code.

Sealed classes and functional programming in Java

Haskell Did It First: Sealed classes and functional programming in Java

Cribl Stream is recognized for its ability to efficiently structure data flows while providing capabilities to mask, transform, reduce, and route data. The platform's straightforward implementation and operation make it particularly suitable for enterprise environments, which has contributed to Cribl’s rapid adoption among Fortune 100 companies globally. Cribl Stream offers immediate functionality that many organizations have desired to incorporate for a long time.

Our experience with this solution spans several years, during which we have consistently been impressed by its organizational impact. As a partner we are working together with Cribl to enhance the products themselves and for the features outside of the core functionality we have developed an open-source solution: CriblUtilities - A comprehensive tool to streamline migrations and validate configurations. Our open source solution ensures a smooth implementation of Cribl Stream within your organization.

We started our development with the core functionality of database migration. Splunk provides DBConnect as a supplementary application for Splunk Heavy Forwarder. However, the architecture of the Heavy Forwarder does not support high availability. While it is possible to construct a high-availability solution around it, Cribl Stream natively supports database queries at defined intervals with built-in high availability. Making this a quick win for organizations that are starting their Cribl Stream implementation.

All you need is a user on your Cribl API and the three configuration files from Splunk and our CriblUtilities solution takes care of the rest.

The development process required substantial testing and coding efforts. Splunk utilizes a modified implementation of TOML (Tom's Obvious, Minimal Language). The standard Python TOML module proved to be incompatible with this implementation, and requires data reformatting to ensure compatibility. The migration process transforms three distinct Splunk files (db_connections.conf, identities.conf, and db_inputs.conf) into two Cribl outputs (Database Connection Knowledge items and Database Collectors). Followed by verification and additional configuration adjustments, such as schedule activation, the new configurations are deployed to Cribl via the Cribl API.

Currently, this represents the sole migration path incorporated into the utility. It serves as a foundation for the continued expansion of migration capabilities in future development.

Above is a picture shown with a couple of steps. In step 1 the setup of CriblUtilities is started. A few required parameters are asked from the user via the prompt, this results in a ".env" file. Alternatively, you can also set this file manually. In step 2 the empty screens are shown to prove the environment is empty. In step 3 the actual migration is done. The script gives insight into what is done. In step 4 the proof is shown that the database connections and collectors are created in Cribl Stream.

Cribl Stream provides native support for GitOps, which we consider very beneficial as it facilitates a unified approach to configuration promotion, testing, and administration. The implementation process is straightforward, requiring only a single API command. Our clients typically establish a workflow wherein designated individuals review merge requests between environments to identify potential configuration anomalies.

CriblUtilities does not aim to replace these manual reviews but rather to reduce their scope. The utility can be integrated into the pipeline to perform configuration verification prior to manual review, thereby reducing reviewer workload and implementing consistent validation procedures.

Our initial development focused on YAML file linting. As Cribl utilizes standard YAML formatting, we leverage the Python YAML module to identify unsupported modifications, such as improperly formatted local changes. The prevention of improperly formatted YAML files is critical, as they may compromise Cribl Stream in production.

Establishing naming conventions for Cribl Stream configuration elements is considered best practice. We have implemented naming convention verification as an additional feature in CriblUtilities. Organizations typically maintain conventions for worker groups, sources, destinations, data routes, pipelines, and packs. As configuration types store naming information in various locations, our utility simplifies verification through commands such as:

cribl-utilities check naming --conf /opt/cribl --field sources --regex "src_.*"

For pipeline configurations, similar verification can be performed with:

cribl-utilities check naming --conf /opt/cribl --field pipelines --regex "ppl_.*"

In this example there are four worker groups created. Only one applies to the new naming convention. Which states that the name of a worker group should start with "wgp_".

In this example you see the default worker group. We created an exception for this worker group in the naming convention since this group is always there. This gives two workers groups that do not apply to the naming convention:

Use the debug tag to check whether this checks all configurations you expect. Especially filtered_fields are interesting in this case:

We have decided to launch this initiative as an open-source project due to our commitment to transparency. CriblUtilities does not transmit data to external sources with the exception of your designated Cribl environment. Our open approach enables verification of these assurances. We encourage developer participation to enhance functionality, and welcome issue reports from all users to facilitate ongoing improvement.

CribUtilitites is a comprehensive tool to streamline migrations and validate configurations.

Streamline migrations and validate configurations with CriblUtilities

In early 2024, the 1 Billion Row Challenge (1BRC) went viral. The goal was simple yet daunting: process a file with 1 billion rows of temperature measurements and calculate the minimum, maximum, and mean temperatures for each weather station in the dataset. This benchmark pushed developers to explore extreme optimization techniques. The winning solution completed this challenge in just a mere 1.535 seconds, decisively debunking the long-standing myth that Java is inherently slow.

The question I aim to answer in this blog is: how was this incredible feat achieved, and what techniques can we apply to make Java code faster?

The first and simplest approach is to leverage the ability of modern processors to handle multiple tasks simultaneously—also known as parallelization. Parallelization makes work faster by dividing a task into smaller parts that can be completed simultaneously. Instead of processing everything one step at a time (sequentially), parallelization assigns different parts of the work to multiple processors or cores.

Java offers powerful libraries for parallelization, making it easy to divide tasks and process them simultaneously. Key tools include the Fork/Join Framework for divide-and-conquer problems, Parallel Streams for effortless parallel data operations, and the Executor Framework for managing threads. Features like CompletableFuture enable asynchronous parallel tasks, while third-party libraries like Akka and RxJava support advanced concurrency. These tools simplify parallelization, boosting performance by leveraging modern multi-core processors.


The fastest solutions took this approach to the next level. A common bottleneck in parallel processing is that files are often read sequentially, even when the data is processed in parallel. Without delving too deeply into the details, the fastest developers overcame this by writing custom code to split the text into chunks optimized for the number of cores and CPU cache sizes, allowing the file to be read and processed simultaneously across all cores—fully maximizing their utilization. Understanding your architecture is key.

Working hard isn’t enough—you need to work smart. While reading each byte of every line, the data must also be understood. Since they were dealing with a CSV file, this involves identifying the separators and efficiently parsing each line into meaningful pieces for further processing.

A simple way to handle this is by using regular expressions, often the go-to approach in everyday programming. However, for extreme performance, regular expressions are too slow due to their sequential nature. To optimize processing, it’s necessary to break down each line into bytes and process them in parallel, leveraging the capabilities of modern CPUs.

The first approach is using Java’s Vector API, which enables SIMD (Single Instruction, Multiple Data) operations. SIMD allows a single instruction to process multiple bytes simultaneously, significantly boosting performance. For example, instead of checking each character one by one, the Vector API processes entire chunks of data (e.g., 128 bits) in parallel, identifying target values like commas in a single operation. This method is ideal for maximizing CPU core utilization;  however, it does have some limitations, such as incompatibility with GraalVM.

The second approach involves masks, which efficiently process data at the byte level. A mask is an array that marks positions of target values (e.g., 1 for a match, 0 otherwise) using branchless comparisons. Masks avoid the performance penalties of conditional logic, ensuring predictable, high-speed processing. While less abstract than the Vector API, masks provide a scalable and hardware-agnostic solution for parallel data parsing.

3. Efficient Data Structures – Be Organized

When processing data, temporary results need to be stored efficiently while handling the next piece of data. A commonly used data structure for this purpose is the standard Java hash map (HashMap), a reliable solution for key-value storage. However, while HashMap is versatile, it can become a performance bottleneck due to hash collisions and the overhead involved in resolving them.

To address this, some developers explored alternative storage methods. One particularly intriguing approach was creating a custom hash map with forward probing. A standard Java HashMap works by transforming a key into a hash value and storing the value at an index determined by the hash. However, hash collisions occur when multiple keys are assigned the same index. In such cases, the HashMap stores these values in a list. Retrieving a value then requires accessing the list and traversing it to find the desired value, which can slow down performance.

In contrast, a hash map using forward probing avoids storing values with the same index in a list. Instead, it searches for the next available slot in its array and places the value there. This approach is faster, provided collisions are kept to a minimum. Since the set of weather stations in this case was fixed, developers could design a custom hash function optimized to minimize collisions. By fully understanding the constraints of their data, they were able to implement extremely efficient organized data.

This approach is less about optimizing the code itself and more about optimizing how Java runs the code. As you may know, Java source code is first compiled into an intermediate format called bytecode, which is platform-independent. At runtime, the JVM (Java Virtual Machine) uses a Just-In-Time (JIT) compiler to convert this bytecode into native machine code specific to the underlying hardware. This process allows Java programs to achieve performance close to that of native applications.

However, JIT compilation happens during program execution, which can create overhead. The JVM spends time analyzing and optimizing code paths at runtime, leading to initial "warm-up" delays. This can slow down execution, especially for performance-critical or short-lived applications.

To address this, contestants used GraalVM, which improves runtime performance by leveraging an Ahead-Of-Time (AOT) compiler. GraalVM compiles Java bytecode into native machine code before the program runs, eliminating the need for JIT compilation during execution. This reduces warm-up times and improves startup performance. Additionally, GraalVM applies advanced optimization techniques to generate highly efficient native code, resulting in faster execution overall, particularly for applications that demand high performance or quick startup times.

For some developers, even this wasn’t fast enough. As you may know, Java uses a Garbage Collector (GC) to clean up objects that are no longer referenced. Without this process, a program running long enough would eventually run out of memory. However, while the Garbage Collector is working, the CPU is occupied and not running your program, which can cause slowdowns.

To remedy this, some developers simply turned off the Garbage Collector. (Technically, they used the Epsilon GC that just doesn’t do anything.) This is feasible for short-lived programs because all memory is automatically released once the program finishes execution. By disabling the GC, developers eliminated this overhead, allowing the CPU to focus entirely on the program and achieve faster execution times.

One of the key benefits of using Java over languages like C or C++ is its strong emphasis on safety. Java is designed to minimize the risk of causing harm to your system while running code. Each Java application operates within its own dedicated memory space and cannot access or interfere with memory allocated to other processes. This isolation, often referred to as a sandbox, ensures that Java programs cannot disrupt other processes or compromise system stability.

Java is also memory-safe, meaning it prevents unauthorized access to memory. Unlike C or C++, where developers manage memory manually, Java uses built-in mechanisms to handle memory allocation and cleanup. For example, Java’s automatic Garbage Collector ensures that unused objects are safely removed without risking memory leaks or invalid memory references. Combined with its robust runtime checks and strict type system, Java significantly reduces vulnerabilities, making it a highly secure choice for developers.

However, this level of safety comes at a cost: it can slow down your code. To achieve even greater performance, some developers bypassed these safety features by using Java's Unsafe library for direct memory manipulation. The Unsafe library allows developers to perform low-level operations, such as directly allocating and accessing memory, circumventing Java’s built-in memory management and safety checks.

One specific optimization involved bypassing the unmapping of data, which is typically handled automatically by Java’s memory management system. By taking control of these processes, developers were able to reduce overhead and execute operations significantly faster. 

The above-mentioned techniques sacrifice safety for speed and should, therefore, be used only in extreme cases when a developer truly knows what they are doing.

Parallelization – Teamwork: Break tasks into smaller pieces and execute them in parallel to maximize CPU utilization, ensuring no processing power goes to waste.

Efficient Parsing – Work Smart: In programming, solving problems efficiently matters. While there are many ways to achieve a solution, some paths are significantly faster—choose the shortest road to your goal.

Efficient Data Structures – Be Organized: Every data structure has strengths and weaknesses. Understand your data and select the structure that best fits the problem for optimal performance.

GraalVM – Skip Unnecessary Steps: Fast code isn’t everything; how your code is executed matters too. Tools like GraalVM can eliminate unnecessary runtime overhead, allowing your code to run more efficiently.

Unsafe – Don’t Try This at Home: In extreme cases, bypassing Java’s safety features with tools like the Unsafe library can deliver higher performance. However, this approach should only be used with careful consideration and a strong justification.

https://www.morling.dev/blog/one-billion-row-challenge/

Inside the Fastest Solutions of the 1 Billion Row Challenge

Vakmensen, dat zijn we. En wat we doen op het gebied van informatie- en communicatietechnologie helpt organisaties slim verder. Effectief en meetbaar bovendien. Aangenaam, CINQ. Specialisten in Data, DevOps, Development en Quality. Wij geloven in specialisten, vandaar de vier specialismen Data, DevOps, Development en Quality binnen ons bedrijf. Zo zorgen we dat jij excelleert, want je werkt het best waar je je het meest thuis voelt. Logisch, toch?

cinq_logo.png

cinq_logo_square.png

CINQ ICT

Helemaal thuis in de wereld van back-end development? Als specialist breng jij beeldbepalende organisaties in het Nederlandse bedrijvenlandschap naar een hoger niveau. Daar ben jij de aangewezen software engineer voor die zichzelf continu verder ontwikkelt. 

Ooit gedacht om te werken voor een IT-consultancybureau? Niet? CINQ again, zeggen we dan. Want of je nu veel afwisseling in projecten wilt, of juist langer aan een organisatie verbonden wilt zijn: beide opties zijn mogelijk. Je werkt als software engineer voor aansprekende klanten die jouw kennis en inzichten nodig hebben. Ondertussen zijn er je CINQ-collega’s met wie je kennis deelt, functionaliteiten bestudeert en nieuwe technieken onderzoekt. Zo kun jij klanten verrassen en van de vrijheid als software engineer genieten. Een baan uit duizenden, waar je bijvoorbeeld: 

grote of kleine projecten draait, afhankelijk van wat jij wilt.

spreekt op congressen, vakinhoudelijke blogs schrijft en workshops verzorgt.

werkt voor klanten als grote banken, de Politie of Rijkswaterstaat.

Sinds 2013 zetten we onze consultants in op hoogwaardige IT-projecten door heel Nederland. Met de kennis die onze specialisten in huis hebben, adviseren we teams en zetten we koers naar innovatie. Nieuwe tooling helpt ons om klanten keer op keer te verrassen. Tussen alle IT-consultancybureaus vallen we misschien niet direct op in wat we doen. Maar wél in hoe we het doen. Daarmee hebben we naam en faam gemaakt in verschillende sectoren en daar gaan we het liefst nog even mee door.

CINQ is opgesplitst in vier business units met elk een eigen expertise. Niet dat we ervan houden om in hokjes te denken, maar dit werkt in de praktijk nu eenmaal het beste. Ook voor onze klanten die een beroep doen op jou als back-end developer. Onze developers zitten in heel Nederland. We draaien onze hand niet om voor grote projecten met de nodige complexiteiten. Sterker nog, die doen we misschien wel het liefst. Toch zijn we ook te porren voor kleinere opdrachten, zolang we klanten ermee kunnen helpen. En dat doen we het liefst, terwijl jij nieuwe kennis opdoet en verder groeit.

Bij ons krijg je direct een vast contract voor 36 of 40 uur per week. Bij deze vacature horen de volgende arbeidsvoorwaarden: 

een brutomaandsalaris tussen € 4.000 en € 6.500, afhankelijk van je kennis en ervaring.

8% vakantiegeld en 24 vakantiedagen op basis van een fulltime dienstverband.

een ruim ontwikkelbudget voor trainingen en certificeringen

een telefoonvergoeding en een laptop naar keuze.

€ 1.000 budget om je thuiswerkplek goed in te richten

een auto van de zaak óf mobiliteitsbudget met een kilometervergoeding.

bezoek conferenties zoals JavaOne, Devoxx en JFall.

flexibiliteit om thuis, bij ons op kantoor en bij de klant te werken

Gedreven, analytisch en voldoende doorzettingsvermogen om succes te boeken. Jij bent als software engineer niet voor 1 gat te vangen, want voor complexe uitdagingen vind je de beste oplossingen. In deze rol heb je veel contact met de klant en daarom is goed communiceren uiterst belangrijk. Daar mag humor niet in ontbreken. Als er nieuwe ontwikkelingen of tools voorbijkomen, ben jij er als eerste bij om ze te onderzoeken. Het liefst ga je er meteen mee aan de slag. Als software engineer heb jij:

ongekende coding skills. Die heb je je bijvoorbeeld eigen gemaakt in een rol als software developer of Java ontwikkelaar.

minimaal 5 jaar werkervaring met Java en/of Kotlin

ervaring met relevante back-end frameworks zoals Spring Boot

ervaring met Agile softwareontwikkeling in een DevOps-omgeving.

En, hoe lijkt het? Ben jij de nieuwe software engineer die onze klanten verder helpt? Solliciteer dan meteen via de sollicitatiebutton. 

Wil je de details van deze vacature tot achter de komma? Neem dan contact op met Marc Jacobs via marc@cinqict.nl of 06 – 51 08 74 37.

Helemaal thuis in back-end development? Als specialist breng jij beeldbepalende organisaties in het Nederlandse bedrijvenlandschap naar een hoger niveau.

Back-end developer

Helemaal thuis in de wereld van Java of Kotlin? Als specialist breng jij beeldbepalende organisaties in het Nederlandse bedrijvenlandschap naar een hoger niveau.

36 - 40 uur per week

Back-end Developer

Door efficiënt datagebruik help jij onze klanten vooruit. Banken, overheidsinstanties, onderwijsinstellingen: in jouw volgende opdracht krijg je volop de ruimte voor eigen inbreng.

De charme van een IT-consultancybureau als CINQ is dat jij als data engineer over de vloer komt bij meerdere klanten. Soms voor een langdurig project, soms voor een kortere opdracht. Jij helpt ze data te benutten en krijgt de vrijheid om dat te doen op basis van je eigen inzichten. Jij ziet Splunk als de hamer in een gereedschapskist; een onmisbare tool om je werk mee uit te voeren. Meer waarde uit data halen is jouw doel, via proof of concepts verbetertrajecten en implementaties van Splunk-omgevingen. Hierin houd jij je bezig met het:

ontwikkelen, onderhouden en beheren van een Splunk-omgeving voor een optimale performance.

komen met verbetervoorstellen richting de klant.

CINQ is opgesplitst in vier business units met ieder een eigen expertise. Niet dat we ervan houden om in hokjes te denken, maar dit werkt in de praktijk nu eenmaal het beste. Ook voor onze klanten die een beroep doen op data engineers. Bij een klant meedraaien in een Splunk-team tot aan het uit de grond stampen van een splinternieuwe dataomgeving: als dataspecialist komt er van alles op je bord. En je collega’s van CINQ tref je bij een gezamenlijke data-kantoordag, kennissessie of memorabel uitje. 

Bij ons krijg je direct een vast contract voor 36 of 40 uur per week. Bij deze vacature horen de volgende arbeidsvoorwaarden:

een brutomaandsalaris tussen € 3.000 en € 5.500, afhankelijk van je kennis en ervaring.

8% vakantiegeld en 24 vakantiedagen op basis van een fulltime dienstverband

flexibiliteit om thuis, bij ons op kantoor en bij de klant te werken


De ideale kandidaat bestaat misschien niet. Toch zoeken we iemand die er dichtbij in de buurt komt. Want als data engineer ben je je ervan bewust dat jouw rol altijd in ontwikkeling is. Daarom doe je graag nieuwe kennis op en ben je creatief in het bedenken van oplossingen om klanten te verbluffen. Je bent nieuwsgierig, hebt een sterke klantfocus en kan zelfstandig uit de voeten. Dit breng je mee: 

ervaring met het zelfstandig ontwerpen, bouwen en implementeren van een data-omgeving. Bijvoorbeeld vanuit een eerdere rol als data consultant, data analist, data architect of data scientist. 

ruime ervaring met Splunk, ELK stack of andere vergelijkbare producten.

kennis van Python of een andere scripttaal.

kennis van DevOps, CI/CD-tooling (Docker, Kubernetes, AWS/Azure, Rancher of Terraform) is beslist een meerwaarde.

En, hoe lijkt het? Ben jij de nieuwe data engineer die onze klanten verder helpt? Solliciteer dan meteen via de sollicitatiebutton. Doe het wel voor [sluitingsdatum], want daarna sluiten we de vacature.

Wil je de details van deze vacature tot achter de komma? Neem dan contact op met Marc Jacobs via marc@cinqict.nl of 06-51087437.

Door efficiënt datagebruik help jij onze klanten vooruit. In jouw volgende opdracht krijg je volop de ruimte voor eigen inbreng.

Splunk Engineer

Als Splunk specialist help jij verschillende grote bedrijven om meer waarde uit hun data te halen.

Jij vindt het leuk om aan complexe data-vraagstukken te werken. Je bent de spin in het web als het gaat om data extracten, transformeren en klaarzetten voor verder gebruik binnen organisaties, rekening houdend met de performance van de data-verwerking middels jobs die jij zelf configureert en beheert. Daarnaast zit je boordevol ideeën hoe de omgeving te verbeteren, waarbij je steeds de klant centraal plaatst. Het leren van nieuwe technieken is de reden waarom je dit werk hebt gekozen: nooit saai, en volop mogelijkheden.

CINQ is opgesplitst in vier business units met ieder een eigen expertise. Niet dat we ervan houden om in hokjes te denken, maar dit werkt in de praktijk nu eenmaal het beste. Ook voor onze klanten die een beroep doen op data engineers. Bij een klant meedraaien in een team tot aan het uit de grond stampen van een splinternieuwe dataomgeving: als dataspecialist komt er van alles op je bord. En je collega’s van CINQ tref je bij een gezamenlijke data-kantoordag, kennissessie of memorabel uitje. 

een bruto maandsalaris tussen € 3.000 en € 5.500, afhankelijk van je kennis en ervaring.

eenmalig € 1.000 budget om je thuiswerkplek goed in te richten

Je kunt zelfstandig een data-omgeving ontwerpen, bouwen, en in gebruik nemen in een Cloud-omgeving (Azure, AWS, of GCP);

Je hebt ruime ervaring met de ETL methode en weet nieuwe data op een efficiënte manier te verwerken tot bruikbare datasets;

Certificeringen zijn geen eis, wel een pré;

Python (en data-libraries zoals Pandas, Numpy, PySpark, Matploblib) lezen en schrijven is geen probleem voor je;

Kennis van DevOps, CI/CD tooling, Docker of Kubernetes leveren bonuspunten op.

Vacature: data engineer bij CINQ ICT in Amsterdam. Bij CINQ staat jouw ontwikkeling centraal!

Data engineer

Data Engineer

Draai aansprekende projecten die de grootste organisaties in Nederland steviger op de kaart zetten op het vlak van DevOps. Techniek is continu aan het veranderen en daar weet jij alles over vertellen. 

Iedere organisatie heeft een andere DevOps-cultuur door uiteenlopende behoeftes en wensen. Jij sluit naadloos aan op wat klanten willen en komt met een passend antwoord in de vorm van tooling en technieken. Samen met je collega’s van CINQ loop je voorop met je kennis en vanuit die positie voeg jij de meeste waarde toe voor klanten. En omdat de markt steeds weer verandert, blijf je gefocust op de allerlaatste ontwikkelingen. Projecten waar onze DevOps engineers aan werken zijn onder andere:

bouwen van een Kubernetes cluster op Microsoft Azure.

implementeren van Hashicorp Vault op Azure en AWS.

migreren van applicaties van on-premise naar de cloud.

inrichten en verbeteren van CI/CD pipelines.

Sinds 2013 zetten we onze consultants in op hoogwaardige IT-projecten door heel Nederland. Met de kennis die onze specialisten in huis hebben, adviseren we teams en zetten we koers naar innovatie. Nieuwe tooling helpt ons om klanten keer op keer te verrassen. Tussen alle IT-consultancybureaus vallen we misschien niet direct op in wat we doen. Maar wél in hoe we het doen. Daarmee hebben we naam en faam gemaakt in verschillende sectoren en daar gaan we het liefst nog even mee door. 

CINQ is opgesplitst in vier business units met ieder een eigen expertise. Niet dat we ervan houden om in hokjes te denken, maar dit werkt in de praktijk nu eenmaal het beste. Ook voor onze klanten die een beroep doen op jou als DevOps engineer. Banken, onderwijsinstellingen, overheidsorganisaties: de bedrijven waar wij voor werken zijn groot en divers. Voor jou betekent dat werken aan opdrachten waar je van alles tegenkomt en nieuwe dingen ontdekt. Hoewel je vooral bij klanten werkt, heb je met je CINQ-collega’s een actieve community voor kenniessessies, workshops en game-avonden. Bij CINQ ontwikkel je je in rap tempo en heb je toegang tot alle tooling die je nodig hebt.

een brutomaandsalaris tussen € 3.500 en € 6.000, afhankelijk van je kennis en ervaring.

bezoeken van conferenties, bijvoorbeeld DockerCon of DevOps Days.

flexibiliteit om thuis, bij ons op kantoor en bij de klant te werken.

DevOps zit in je bloed. Of je ademt DevOps, mag ook. In ieder geval voel jij je thuis in een DevOps-omgeving. Je hebt een sterke drive om de laatste technieken te leren kennen en toont inlevingsvermogen. Je begrijpt klanten, onderkent hun problemen en gaat vanuit jouw expertise op zoek naar een passend antwoord. Zowel inhoudelijk als communicatief weet jij iedere klant te overtuigen. Daar breng je het volgende voor mee:

ervaring met DevOps-tooling, cloudoplossingen en CI/CD.

kennis van tools als Docker, Kubernetes, Ansible, Jenkins, Terraform, Rancher, AWS, Azure, Google Cloud en Git.

kennis van de programmeertalen Go, Ruby, Python en Java. Dit heb je bijvoorbeeld opgedaan als developer, ontwikkelaar, programmeur of IT-consultant.

En, hoe lijkt het? Ben jij de nieuwe DevOps engineer die onze klanten verder helpt? Solliciteer dan meteen via de sollicitatiebutton. Doe het wel voor [sluitingsdatum], want daarna sluiten we de vacature.

Draai aansprekende projecten die de grootste organisaties in Nederland steviger op de kaart zetten op het vlak van DevOps.

DevOps Engineer

Als Test Automation Engineer speel je een cruciale rol in het waarborgen van de kwaliteit en betrouwbaarheid van software door het ontwikkelen, onderhouden en uitvoeren van geautomatiseerde tests. Met de technische expertise, aandacht voor detail en toewijding aan voortdurende verbetering draag jij bij aan de succesvolle levering van software van hoge kwaliteit. Dit ga je doen:

Ontwerpen, ontwikkelen, onderhouden en uitvoeren van geautomatiseerde tests

Maximaliseren van testdekking voor meest kritische scenario’s

Integratie automation tests in CI/CD pipelines

Ontwikkelen en onderhouden van automation framework

Opzetten en/of onderhouden Continuous Integration

CINQ is opgesplitst in 4 business units met ieder een eigen expertise. Niet dat we ervan houden om in hokjes te denken, maar dit werkt in de praktijk nu eenmaal het beste. Ook voor onze klanten die een beroep doen op onze Test Automation Engineers. Bij een klant meedraaien in een team tot aan het uit de grond stampen van een splinternieuwe testomgeving: als test specialist komt er van alles op je bord. En je collega’s van CINQ tref je bij een gezamenlijke test-automation kantoordag, kennissessie of memorabel uitje. 

een bruto maandsalaris tussen € 3.000 en € 6.000, afhankelijk van je kennis en ervaring.

De ideale kandidaat bestaat misschien niet. Toch zoeken we iemand die er dichtbij in de buurt komt. Want als Test Automation Engineer ben je je ervan bewust dat jouw rol altijd in ontwikkeling is. Daarom doe je graag nieuwe kennis op en ben je creatief in het bedenken van oplossingen om klanten te verbluffen. Je bent nieuwsgierig, hebt een sterke klantfocus en kan zelfstandig uit de voeten. Dit breng je mee: 

Aantoonbaar tenminste 3 jaar ervaring als test automation engineer

Sterke programmeer skills in talen als Java, Javascript/ Typescript, Python, .NET of C#

Gebruik van automation tools zoals Cypress.io, Playwright, Appium, Tosca, Robot framework of Selenium

Ervaring met CI/CD (bijv Gitlab, Azure DevOps of Jenkins) 

Ervaring met API tools (bijv Postman, SoapUI)

Kennis van performance testen (bijv JMeter, Gatling)

Uitstekende analytische, probleemoplossende en communicatieve vaardigheden

Intrinsiek gemotiveerd om nieuwe dingen te leren

En, hoe lijkt het? Ben jij de nieuwe Test Automation Engineer die onze klanten verder helpt? Solliciteer dan meteen via de sollicitatiebutton. Doe het wel voor [sluitingsdatum], want daarna sluiten we de vacature.

Wil je de details van deze vacature tot achter de komma? Neem dan contact op met Yorick Leeh via yorick.leeh@cinqict.nl of 06-52572941.

Vacature: test automation engineer bij CINQ ICT in Amsterdam. Bij CINQ staat jouw ontwikkeling centraal!

Test Automation Engineer

Als Test Automation Engineer speel je een cruciale rol in het waarborgen van de kwaliteit en betrouwbaarheid van software.

Meetup door Sysdig & CINQ: AI workshops

Meer blogs