Tutorial on Micha Kops' Tech Notes

Orchestrator Agent with Parallel Sub-Agents in Kiro CLI

Thu, 02 Jul 2026 00:00:00 +0200

Figure 1. kiro orchestrator agents

Overview

Kiro CLI allows us to configure an orchestrator agent that executes specialized sub-agents in parallel. Each sub-agent has its own tools, permissions, and MCP servers – the parent’s trust settings are not inherited.

Architecture

Figure 2. Agents flow

Step 1: Define Specialized Agents

We give each sub-agent its own JSON configuration under .kiro/agents/.

.kiro/agents/code-agent.json

{
  "name": "code-agent",
  "description": "Implements features and writes code",
  "prompt": "You are an experienced Kotlin/Java developer. Write clean, tested code.",
  "tools": ["read", "write", "shell", "code", "grep"],
  "allowedTools": ["read", "code", "grep"],
  "toolsSettings": {
    "write": {
      "allowedPaths": ["./src/**", "./tests/**"],
      "deniedPaths": ["./.env", "./secrets/**"]
    },
    "shell": {
      "allowedCommands": ["mvn test", "mvn compile"],
      "autoAllowReadonly": true
    }
  }
}

Messaging with NATS and Java

Tue, 26 Nov 2024 00:00:00 +0100

Figure 1. NATS Architecture Component Diagram

NATS is a high-performance messaging system that offers simplicity, speed, and scalability. It is particularly suited for building distributed systems and microservices.

This article demonstrates how to integrate NATS with Java, showcasing the essential steps to set up, connect, and publish/subscribe to messages.

Prerequisites

Before diving in, we should ensure to have the following installed:

Java Development Kit (JDK) 11 or later.
Maven or Gradle for dependency management.
Docker (optional).

Creating updatable Java Applications using Getdown and the Getdown Maven Plugin

Sun, 27 May 2012 00:00:00 +0200

Many programmers have suffered when trying to setup an environment to handle updates for their application without much effort. Some tried Java Web Start for this purpose and many encountered difficulties with this approach.

Now there is getdown that aims to replace Java Web Start by offering a simple architecture to handle updates that is fast, realiable and the only thing you need is a normal http server. Though getdown lets us handle our updates really easy it is possible to make this process even easier with the getdown maven plugin.

Wiring made easy using OSGi Blueprint and Apache Karaf

Mon, 16 Apr 2012 00:00:00 +0200

The OSGi Blueprint Container specification allows us to use dependency injection in our OSGi environment, declarative import and export of OSGi services, registering lifecycle listeners and wiring dependencies into our services with a few lines of XML code.
In the following tutorial we’re first building an OSGi bundle classical style and afterwards take a trip into the advantages of the Blueprint specification.

Our OSGi container of choice here will be Apache Karaf a lightweight container with a lot of nice features and – of course – blueprint enabled…

Hibernate Search Faceting: Discrete and Range Faceting by Example

Mon, 26 Mar 2012 00:00:00 +0200

In today’s tutorial we’re exploring the world of faceted searches like the one we’re used to see when we’re searching for an item on Amazon.com or other websites. We’re using Hibernate Search here that offers an API to perform discrete as well as range faceted searches on our persisted data.

Maven Dependencies Needed

For simplicity’s sake am I going to use an HSQL database for persistence, in addition the dependencies for hibernate-entitymanager and hibernate-search (of course) should be added to your pom.xml

Snippet: Mixing Scala, Java in a Maven Project

Fri, 23 Mar 2012 00:00:00 +0100

Having just returned from the Atlassian Camp 2012 I just toyed around with Java and Scala and wanted to share the following snippet that demonstrates how to mix code from both languages in a Maven project using the maven-scala-plugin.

Setting up the Maven Project

First create a new Maven project in your IDE or by running mvn archetype:generate.

In the next step, add the dependency for scala-library and the scala maven repositories to your pom.xml and hook the maven-scala-plugin to Maven’s lifecycle. My pom.xml finally looks like this one:

Using the Android Fragment API in a Tablet App

Sun, 18 Mar 2012 00:00:00 +0100

Since I got a new tablet running Android 4.0 aka ice cream sandwich I wanted to play around a bit with the fragments API and creating an application for a tablet.

In the following tutorial, we’re going to build an application that renders several articles from a popular tech blog (just kidding) in a web view.

What to build

We’re going to build an application that is able to display web links in the left section of the screen and when clicked, displaying the corresponding website content in the right section of the application screen.

Android Widget Tutorial: Creating a screen-lock Widget in a few steps

Thu, 06 Oct 2011 00:00:00 +0200

In today’s Android tutorial we’re going to take a look at Android’s Widget API and how to make a widget interact with a service using intents.

Figure 1. hasCode Android Widget Tutorial Logo

We’re going to create a fully functional application that allows us to enable or disable our smartphone’s screen lock settings using a widget that can be placed on our home screen.

Finally, I am going to show how to use a smartphone to test and debug our application and connect it to the IDE.

Screenscraping made easy using jsoup and Maven

Tue, 30 Aug 2011 00:00:00 +0200

Sometimes in a developer’s life there is no clean API available to gather information from a web application .. no SOAP, no XML-RPC and no REST .. just a website hiding the information we’re looking for somewhere in its DOM hierarchy – so the only solution is screenscraping.

Screenscraping always leaves me with a bad feeling – but luckily there is a tool that makes this job at least a bit easier for a developer .. jsoup to the rescue!

Creating Portlets using Java Server Faces 2 and Liferay

Tue, 19 Jul 2011 00:00:00 +0200

Portlets are a common technology to create plug&play components for modern web applications and are specified by the Java Community Process in several specification requests.

In the following tutorial we’re going to learn how to create custom portlets and how to deploy and embed them in Liferay, the popular open-source enterprise portal.

In addition we’re taking a look at inter-portlet-communication and how to create portlets using annotations.

Finally we’re building a portlet-state-aware Java-Server-Faces portlet using the jsf-portlet-bridge mechanism.

Message Driven Beans in Java EE 6

Sun, 05 Jun 2011 00:00:00 +0200

Message Driven Beans are no new concept due to the fact that they exist since EJB 2.0 but in Java EE 6 and the EJB 3.0 specification it is even more fun to use them.

In this tutorial we’re going to take a look at the specification and create an example application that transfers some objects via the Java Message Service to a Message-Driven Bean deployed on a GlassFish application server.

Oh JBehave, Baby! Behaviour Driven Development using JBehave

Tue, 31 May 2011 00:00:00 +0200

Behaviour Driven Development is the keyword when we’re talking about test scenarios written in an ubiquitous language, strong interaction with stakeholders, product owners or testers and well described, common understandable test scenarios.

The popular JBehave framework is our tool of choice here and allows us to decouple our test stories from the test classes, offers an integration for web tests using Selenium and finally there’s a helpful Maven plugin for JBehave, too.

Creating a sample Java EE 6 Blog Application with JPA, EJB, CDI, JSF and Primefaces on GlassFish

Tue, 08 Feb 2011 00:00:00 +0100

Java EE 6 is out and it indeed offers an interesting stack of technologies. So in today’s tutorial we are going to build a small sample web application that builds on this stack using Enterprise JavaBeans, Java Persistence API, Bean Validation, CDI and finally Java Server Faces and PrimeFaces.

The application we’re going to develop is a simple blog app that allows us to create new articles, list them and – finally delete them. We’re also covering some additional topics like JSF navigation, i18n, Ajax-enabled components and the deployment on the GlassFish application server.

Enterprise Java Bean EJB 3.1 Testing using Maven and embedded Glassfish

Sat, 01 Jan 2011 00:00:00 +0100

Are you playing around with the shiny new 3.1 EJB API?

Using Maven for your Java projects?

Need an easy way to write and execute tests for your EJBs that depends on an Java Application Server?

No problem using Maven Archetypes, the Maven EJB Plugin and the GlassFish embedded Application Container..

Prerequisites

For the following tutorial we’re going to need an installation of Maven and of course – the Java Development Kit!

Bean Validation with JSR-303 and Hibernate Validator

Tue, 14 Dec 2010 00:00:00 +0100

You want to add some validation logic to your Java beans? You want to achieve this with some shiny extendable annotations? Then give the Java Bean Validation standard aka JSR-303 a try..

We’re going to use the reference implementation for bean validation, Hibernate Validator in this tutorial but there are also links to other alternatives like Oval or Apache Bean Validation.

So let’s begin and validate some stuff ..

Prerequisites

JDK >=6
Maven >=2
An IDE or text editor of choice

Creating a REST Client Step-by-Step using JAX-RS, JAX-B and Jersey

Thu, 25 Nov 2010 00:00:00 +0100

Often in a developer’s life there is a REST service to deal with and nowadays one wants a fast and clean solution to create a client for such a service.

The following tutorial shows a quick approach using JAX-RS with its reference implementation, Jersey in combination with JAX-B for annotation driven marshalling between XML or JSON structures and our Java-Beans.

Prerequisites

The following stuff is needed to run the following examples and code samples

Using PrimeFaces to pimp up existing Java Server Faces / JSF 2 Applications

Sun, 14 Nov 2010 00:00:00 +0100

In this tutorial we’re going to modify an existing Java Server Faces / JSF 2 web application by adding rich UI components to the existing layout.

Our tool of choice here is the PrimeFaces framework. It offers a wide range of interesting, customizable and (several) Ajax-enabled components that blend very well with JSF1+2 and also a solid documentation that allows a quick integration into existing projects.

Project setup

For this tutorial we’re going to reuse the web application from my JSF2 Tutorial “Java Server Faces/JSF 2 Tutorial – Step 1: Project setup, Maven and the first Facelet” – the source code is available at GitHub.org.

How to create a Confluence SOAP Component in 5 Minutes

Sun, 24 Oct 2010 00:00:00 +0200

You’re using the popular Confluence wiki? You’re using its RPC/SOAP API and missing a function you really need? Just extend the capabilities of the Confluence RPC API by programming a custom web service component – it is really easy and also well documented.

In this tutorial we’re going to take a look on how to quickly implement a SOAP service, securing it and putting its methods in a transactional context.

Prerequisites

Maven >=2
JDK >= 5
Confluence Wiki >= 3.0 (for a quick installation guide take a look at this article)
SoapUI for Testing

Object-relational Mapping using Java Persistence API JPA 2

Mon, 11 Oct 2010 00:00:00 +0200

Today we’re going to take a look at the world of object-relational Mapping and how it is done using the Java Persistence API by creating some basic examples, mapping some relations and querying objects using JPQL or the Criteria API..

Prerequisites

Java 6 JDK
Maven >= 2
If you’d like to take a look behind the scenes e.g. how entities are mapped in your database you could install a RDBMS of your choice .. or just use Derby/JavaDB that is bundled with the JDK 6

Playing around with the Android Animation Framework

Mon, 27 Sep 2010 00:00:00 +0200

Animations add some spice to our Android applications and the offered animation framework makes it easy to create custom animations and tweens.

So lets dance around and create some animations ;) ..

About

There are two ways to create animations – via XML declaration or in a Java class. We’re going to focus on XML declaration – if you’re interested in java based declaration – take a look at the Android JavaDocs and the subclasses of android.view.animation.Animation.

Creating a SOAP Service using JAX-WS Annotations

Thu, 23 Sep 2010 00:00:00 +0200

It is possible to create SOAP webservices with only a few lines of code using the JAX-WS annotations. In a productivity environment you might prefer using contract-first instead of code-first to create your webservice but for now we’re going to use the fast method and that means code-first and annotations olé!

Creating the SOAP Service

Create a class SampleService with two public methods
Annotate this class with @WebService (javax.jws.WebService) – now all public methods of this class are exported for our SOAP service
To change the name of an exported method, annotate the method with @WebMethod(operationName = “theDesiredName”) (javax.jws.WebMethod)

Finally the service class could look like this

package com.hascode.tutorial.soap;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService public class SampleService {
 @WebMethod(operationName = "getInfo") public String getInformation() {
 return "hasCode.com";
 }

 public String doubleString(String inString) {
 return inString + inString;
 }
}

How to create an Android App using Google’s App Inventor

Wed, 04 Aug 2010 00:00:00 +0200

Today we’re going to take a look at Google’s App Inventor feature that offers programming-novices a nice possibility to enter the fabulous world of Android App programming without deeper knowledge of the API or complex SDK installations.

So lets build some stuff ..

Prerequisites

Java 6 JDK
App Inventors Extras Software
A Google App Inventor Beta Account – request one here

What we are going to build

We are building a simple GUI with a Textbox and a button
A click on the button starts an event that queries the acceleration sensor for coordinates
If the sensor is active and enabled then the coordinates are displayed in the text box

How to create a simple OSGi Web Application using Maven

Sun, 25 Jul 2010 00:00:00 +0200

In this tutorial we will take a look at the development of a simple OSGi Web Application and what tools can save us some time.

The Maven Bundle Plugin makes our life much easier here as does the OSGi Bundle Repository that offers some nice bundles – in our case the servlet API and an embedded Jetty web server.

So lets develop some bundles ..

Prerequisites

You are going to need a JDK (>=5), Maven2, the Apache Felix OSGi implementation and and text editor/http://eclipse.org/[IDE] of your choice.

How to create a Template Bundle Plugin in Confluence

Mon, 12 Jul 2010 00:00:00 +0200

Since Confluence 3.2. there is a new plugin module type that allows you to deploy templates in a bundle via the plugin API.

In addition it is possible to assign these templates to specific spaces and preview available templates in the Confluence administration area.

So let’s build some sample templates..

Creating a Template Bundle Plugin

Creating a template bundle is easy – just create a class implementing TemplatePackage – there are two methods: one returns a list of bundled PageTemplate Objects the other the name for the template bundle.

A look at Google’s Protocol Buffers

Tue, 06 Jul 2010 00:00:00 +0200

Protocol Buffers are a serialization format developed by Google- you might ask if another IDL is really needed here – is Google barking at the wrong tree?

But protocol buffers offer some advantages over data serialization via XML or JSON – Google says they (compared to XML)..

are 3 to 10 times smaller
are 20 to 100 times faster
provide generated data access classes for programmatic use
provide backward compatibility

Java Server Faces/JSF 2 Tutorial – Step 1: Project setup, Maven and the first Facelet

Sat, 05 Jun 2010 00:00:00 +0200

In this short tutorial we are going to build a Java Server Faces Web-Application using JSF2.0, Facelets, Maven and Hibernate as ORM Mapper.

The goals for this first step are: Setting up the project structure using Maven, defining a frame template/decorator and a registration facelet, creating a managed bean and mapping it’s values to the facelet, adding some basic validation, displaying validation errors and finally adding a navigation structure.

In step2 of this tutorial we are going to add persistence using Hibernate, add some security, create a custom UI component and add some AJAX.

Sensor Fun: Location Based Services and GPS for Android

Sun, 30 May 2010 00:00:00 +0200

The Android SDK offers a nice API to receive information about available providers for location based services and get the current location and coordinates.

In this short tutorial we’re going to build a small activity that displays a list of available location providers and shows the current position using GPS services.

Example Application

Create a new Android Project using ADT and your IDE with a package named com.hascode.android.location_app

Add the permissions needed to the AndroidManifest.xml – it should look like this

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.hascode.android.location_app" android:versionCode="1"
	android:versionName="1.0">
	<application android:icon="@drawable/icon" android:label="@string/app_name">
		<activity android:name=".LocationActivity" android:label="@string/app_name">
			<intent-filter>
				<action android:name="android.intent.action.MAIN" />
				<category android:name="android.intent.category.LAUNCHER" />
			</intent-filter>
		</activity>

	</application>
	<uses-sdk android:minSdkVersion="7" />

	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION"></uses-permission>
</manifest>

Extending the Confluence Search Index

Sun, 23 May 2010 00:00:00 +0200

Developing plugins for the Confluence Wiki a developer sometimes needs to save additional metadata to a page object using Bandana or the ContentPropertyManager. Wouldn’t it be nice if this metadata was available in the built-in Lucene index?

That is were the Confluence Extractor Module comes into play..

Overview

An extractor allows the developer to add new fields to the lucene search index. Creating a new extractor is quite simple – just implement the interface com.atlassian.bonnie.search.Extractor or bucket.search.lucene.extractor.BaseAttachmentContentExtractor if you want to build a new file extractor.

Creating a simple Gesture App with Android

Fri, 14 May 2010 00:00:00 +0200

The integration of gestures into your android app adds some nice functionality and is made very easy using Google’s GestureBuilder application and the integrated GestureLibrary and Gesture Overlay API – so let’s build a sample app.

If you need some basic information regarding gestures on android first – take a look at this article.

Creating a gesture library

First you need to define the gestures that should be captured in the application later. For this reason there’s the GestureBuilder delivered with the Android SDK. You can find the app in the samples directory of your android sdk – e.g. <installation-directory>/android-sdk-linux_86/platforms/android-2.1/samples/GestureBuilder.

Playing around with QR Codes

Tue, 11 May 2010 00:00:00 +0200

Sometimes QR codes are a nice way to distribute information like calendar events, contact information, e-mail, geo-locations or internet addresses.

In the following article we’re going to encode information to QR code images using the ZXing library and afterwards decode information from a given QR code.

Finally we’re taking a look on online QR code generators and how to integrate the ZXing library in a Maven project.

The ZXing Library

Download the ZXing Libraries from http://code.google.com/p/zxing/downloads/list – the file name is ZXing-<version>.zip
Unpack the downloaded archive somewhere
Change to the extracted directory and run ant. If you don’t have JavaME installed – and you don’t have to for the samples below – run ant buildwithoutj2me – that will do the job
Having compiled the libraries you’re now free to include the core.jar from zxing-<version>/core/ and the javase.jar from zxing-<version>/javase as dependency in your project

First steps on Android: Creating a simple Todo App

Mon, 26 Apr 2010 00:00:00 +0200

In this tutorial we are going to build a simple todo app that is able to store simple todos in a database. The user is able to add new todos or delete old ones by clicking on a todo. For this tutorial we won’t use maven to keep it simple – if maven integration is desired – take a look at this tutorial.

Steps

Create a new android project using the Android SDK and your IDE
Create some packages com.hascode.android.activity and com.hascode.android.persistence

Create the layout in res/layout/main.xml – the main elements: a listview for the todos-list, a textbox and a button to enter new data.

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        android:id="@+id/widget31"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        xmlns:android="http://schemas.android.com/apk/res/android"
    >
        <TableRow
            android:id="@+id/row"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal"
            android:layout_below="@+id/tasklist"
            android:layout_alignParentLeft="true"
        >
            <EditText
                android:id="@+id/etNewTask"
                android:layout_width="200px"
                android:layout_height="wrap_content"
                android:text=""
                android:textSize="18sp"
            >
            </EditText>
            <Button
                android:id="@+id/btNewTask"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@+string/add_button_name"
            >
            </Button>
        </TableRow>
        <ListView
            android:id="@+id/tasklist"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_alignParentTop="true"
            android:layout_alignParentLeft="true"
        >
        </ListView>
</RelativeLayout>

Create a SOAP client using the JAX-WS Maven Plugin

Thu, 08 Apr 2010 00:00:00 +0200

Having written the article “How to build a Confluence SOAP client in 5 minutes” some readers asked me for some more information and help using the JAX-WS plugin that I mentioned in the article instead of the Axis plugin – so here we go ;)

Steps

Create a simple maven project first using archetype:create or archetype:generate
```
mvn archetype:create -DgroupId=com.hascode.jaxws -DartifactId=soap-tutorial
```

We get a pom.xml like this:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.hascode.jaxws</groupId>
     <artifactId>soap-tutorial</artifactId>
     <version>0.1</version>
</project>

Confluence Developer Instance Quick Setup

Fri, 26 Mar 2010 00:00:00 +0100

This short tutorial shows how to set-up a developer instance of the popular Confluence Wiki from Atlassian in a few minutes.

It’s a prerequisite for a few following tutorials regarding the Confluence API and plug-in development for this system.

We want a quick install so we are going to run Confluence with the embedded servlet container and HSQL database.

update Meanwhile it is way much easier to use Atlassian’s Plugin SDK using atlas-mvn run or atlas-mvn-run-standalone –product confluence –version x.x.x but if you need to setup an independant instance, this article still might be useful.

How to build a quick Lucene Search

Thu, 25 Mar 2010 00:00:00 +0100

Helo – today I wanted to post a small tutorial for a small index and search operation using the Lucene indexer and Maven for the project setup.

Setup

Create an empty Maven sample project using the Eclipse Maven Plugin or use the following console command:
```
mvn archetype:create -DgroupId=com.hascode.demo.search -DartifactId=lucene-sample
```

Here is my pom.xml there are some dependencies for Lucene defined:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hascode.demo.search</groupId>
  <artifactId>lucene-sample</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>My Lucene Search Sample</name>
  <description>Lucene Search Sample</description>
  <dependencies>
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-core</artifactId>
      <version>2.4.1</version>
    </dependency>
    <dependency>
      <groupId>lucene</groupId>
      <artifactId>lucene</artifactId>
      <version>1.4.3</version>
    </dependency>
  </dependencies>
</project>

Rust Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Installation

Installing rustup first…

install rustup via shell script

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

install rustup via brew

brew install rustup-init (1)
rustup-init (2)

Welcome to Rust!

[...]

Current installation options:


   default host triple: aarch64-apple-darwin
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation

1	install `rustup`
2	install rust binaries and add them to paths etc…