Eduard Sizov sizovs

1. Forwarding collections

You can turn any object into a Collection by extending ForwardingCollection (available in Guava). This makes your object iterable as a normal collection. For example:

@Component
public class ImportantNotifications extends ForwardingCollection<Notification> {

  private final Collection<Notification> notifications;

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

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.

	package cleanbank.commands;

	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 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.