Eduards Sizovs sizovs

// package.json
{
  "name": "stress-sqlite",
  "scripts": {
    "start": "node test.js"
  },
  "dependencies": {
    "better-sqlite3": "^9.2.2",
    "tmp": "^0.2.1"

1. Microservices, Modular Monoliths, and Event-Driven Systems

In this masterclass, I’ll take you through three different styles of enterprise service architecture: modular monoliths, distributed synchronous systems, and event-driven systems.

Together, we will design a non-trivial backend system and find out the strengths and weaknesses of each architectural approach. We will discuss the typical mistakes and problems developers face during service architecture design and how to solve them. You will learn how to choose the best architecture style for your project, and how to design hybrid solutions, leveraging the best parts of each architecture style.

Topics include:

Understanding the main styles of service and backend architecture
Microservies or monoliths? Is there a middle ground?

Programming in Kotlin: The Essential Parts

In this masterclass you'll learn the essential parts of Kotlin: an elegant, powerful, and a pleasant language to work with. We'll focus on fundamental parts of Kotlin, it's imperative and functional programming capabilities, how Kotlin provides elegance without compromising performance by tactfully channeling the JDK. We will also dive into how to interact between Kotlin and Java code. You'll learn:

How to work with ease to exploit the power of Kotlin
How to write code in idiomatic Kotlin
How to use powerful features of Kotlin, including extension functions and nullable types
How to write type-safe, maintainable code
How to leverage both imperative and functional style as appropriate
How to use Kotlin's performance related features
Intermix Kotlin with Java code

Hi Venkat

To create the best possible course offering, I'll need some input from you:

1. Date

Please let me know a date in November or December when you're available in the EU/Berlin timezone to run the course from 9:00 to 17:00. Say, 23-24 November.

2. A brief description of the course

Please share a brief description of the course: for whom is this course, what people will learn, and how the learning process will be organized. 5-10 sentences should be enough.

	import com.google.common.reflect.TypeToken;

	import java.util.Collection;
	import java.util.concurrent.CopyOnWriteArrayList;
	import java.util.concurrent.Executor;

	import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
	import static java.lang.Thread.currentThread;
	import static java.util.concurrent.Executors.newWorkStealingPool;

	import com.google.common.collect.ForwardingList;
	import org.springframework.beans.factory.ObjectProvider;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.context.annotation.Scope;
	import org.springframework.stereotype.Component;

	import java.util.List;

	import static org.springframework.beans.factory.config.BeanDefinition.SCOPE_PROTOTYPE;


	<!DOCTYPE HTML>

	<html lang="en">
	<head>

	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
	<meta charset="UTF-8"/>
	<title> Gartner Conferences \| Best Tech, IT and Business Conferences for Executives</title>
	<meta name="keywords" content="Conference"/>

	require 'droplet_kit'

	DO_API_TOKEN = 'YOUR_DO_API_TOKEN_HERE'

	client = DropletKit::Client.new(access_token: DO_API_TOKEN)

	# Auto scaling configuration
	auto_scaling_config = {
	droplet_size: 's-1vcpu-1gb',
	max_instances: 5,

	Every complex software product has a variety of architectural concepts that directly affect the code base. Which types of components do we have, how do we identify these components, how do we structure them and how are they allowed to depend on each other and through which interfaces. However, in an agile environment with many developers and distributed roles, it becomes harder and harder to keep a common understanding and a consistent code structure.

	If the architecture deteriorates, costs for development will rise. Also fixing the code structures will become more and more expensive, the longer it takes to find and fix architecture violations. Thus every project should establish an automated test process to continuously check for violations and allow developers to fix them, while the costs are still low.

	This session will show through lots of live coding, how the open source library ArchUnit can help to maintain these structures.