Test code quality is not just nice-to-have

CRIU and Java opportunities and challenges

Restoring lost expertise of service

Dismantling technical debt and hubris

The DGS framework by Netflix GraphQL for Spring Boot made easy

Adding generational support to Shenandoah GC

Reading from Cassandra — internals and performance

About Scala 3

Reactive Spring

Getting the most from modern Java

Performance: Nuances vs obviousness

Multi-step refactorings in IntelliJ IDEA

Why user-mode threads are (often) the right answer

Babashka: A native Clojure interpreter for scripting

Spring Cloud in Kubernetes era

Enum in API — The deceit of illusory simplicity

Inner loop development with Spring Boot on Kubernetes

GC optimizations you never knew existed

How we built a high-performance Akka system from scratch: Gentleman's set and pitfalls

Workshop: Pair programming

Type inference: Friend or foe?

Jakarta EE 9 and beyond

You can go your way: Kafka without Zookeeper

Workshop: Pair programming (part 2)

IntelliJ productivity tips — The secrets of the fastest developers on Earth

Real World JFR: Experiences building and deploying a continuous profiler at scale

What languages are IDE-friendly?

Workshop: Build Bomberman with RSocket

What is a Working Product and how to make it

Why you should upgrade your Java for containers

Java Records for the intrigued

Workshop: Build Bomberman with RSocket (part 2)

Spring Data Postroitel' (Spark it!)

Spring Data Postroitel' (Spark it!) (part 2)

Interview and Q&A with James Gosling

Cryptography for a Java programmer

Micronaut deep dive

Safepoint — let the whole world wait

ML и AI: Как сейчас выглядит разработка решений в крупных компаниях

Как не испортить своего джуна

Финансовое low latency-приложение на Java и Akka

Внедрение open source-решений на примере Альфа-Банка

Interview and Q&A with Joel Spolsky

Path from functional programming to object oriented programming

Precomputed data access with Micronaut Data

How we write Space on Kotlin

Interview and Q&A with Ted Neward

From cozy Java to brutal Native code or There and Back Again

A Java developer's quest for productivity

When it all went to Kafka 2: Disperse producers

Рассчитать платежную комиссию? Что может быть проще!

Ни дня без спорта или немного про SMLab

Интервью: Технологии и работа в ТехЦентре Дойче Банка

Разработка электронных кошельков

Интервью: Наши практики и подходы

How to develop a successful Kubernetes native application using Quarkus

Ignoring fashion trends with Jakarta EE and MicroProfile

Polyglot done right with GraalVM

Increasing file I/O performance for JVM on Linux

Elasticsearch internals

Microservices made easy with MicroProfile OpenJ9 Open Liberty and OpenShift

Ah, these strings

Contract testing: Should or shouldn't?

Game of Streams: How to tame & get the most from your messaging platforms

Внедрение open source-решений на примере М.Видео

Инженерные практики в банковской сфере

Bootiful Kotlin

Fear and loathing in Scala and Kotlin interop

Writes in Cassandra — internals and performance

The art of code

A few more small optimizations

assert! thou comprehensive word…​

Writing a Java library with better experience

Feature evolution in Java 13 and beyond

Прыжок в online: Как выдержать высокую нагрузку и скорость изменений

Использование GraphQL при построении банковских API

How to develop a successful Kubernetes Native application using Quarkus

Interview and Q&A with Aleksey Shipilev

Dynamic Constants — oxymoron or promising JVM feature?

Life beyond Java 8

Intel Optane DC and Java: Lessons learned in practice

Grow your employer in a coronavirus, or how to make sure that you're not fired in crisis

Building microservices with Helidon

What the hell is service mesh anyway!?

Зачем дата сайентисту знать Scala, а Java-программисту ML

Внедрение open source-решений на примере Одноклассников

Valhalla is coming

RSocket to bring the next generation of Service Mesh

The world needs full-stack craftsmen

Software testing pitfalls

JDK 12: Pitfalls for the unwary

Create your own interpreter with a JIT in 1 hour

RSocket — future reactive application protocol

Reactive programming: lessons learned

Pushing a big project forward: the Jenkins story

The Proxy fairy and the magic of Spring

Don't put all your eggs in one container

Bulletproof Java Enterprise applications for the hard production life

A tale of how we did channel algorithm in Kotlin Coroutines

Maximizing performance with GraalVM (talk + workshop)

Performance aspects of Axon-based CQRS/ES systems

Spring comes ahead of time, or Unbearable lightness of AOT compilation of the Spring Boot applications

Lost in transaction? Strategies to manage consistency in distributed systems

Don't be Homer Simpson to your Reactor!

Anatomy and physiology of Vaadin Flow

Reactive, or not reactive: that is the question

Improve Java build performance with Gradle 5

Java microservices: from Netflix OSS to Kubernetes

Java 11 reactive HTTP Client

Playing God: Has science crossed a line?

JVM TI: how to create a "plugin" for a virtual machine

Local variable type inference: Friend or foe?

Cloud native, service-meshed Java Enterprise with Istio

Kotlin: how do usual constructions work

Metacompilation, partial evaluation, the Futamura projections, and how GraalVM will save the world

Decomposing Java applications

Kotlin/Native: why make a native language in 2019? What is beyond JVM?

Kafka Streams API: Moving beyond Hello World

Atomic refactoring in IntelliJ IDEA: Bending IDE to our will

When it all went to Kafka

Fast & functional

Let's make some 0xCAFEBABE — test-driven bytecode engineering

Moving Spring Boot microservices from Java 8 to Java 11: what can possibly go wrong?

Do it yourself: Collections

Java is slow: CodeCache edition

The definite guide to Java agents

How to unravel the tangle: Analyzing and debugging apps in IntelliJ IDEA

Efficient file-based IO for Java developers

Seamless web services development with Mu

What do I do with 1000s cores. Lessons learnt building an agent-based modelling system

Making sense out of serverless computing

Spring Framework 5.0 on JDK 8 & 9

Kafka Streams and Firehose API helping to fight "Russian Hackers"™

Ruining enterprise app performance with ineffective code

The Eclipse OpenJ9 JVM: a deep dive!

Idiomatic Kotlin: from formatting till DSL

Hardware transactional memory in Java

How to implement an internal JVM profiler that works well with AOT-compiled code?

Camel microservices with Spring Boot and Kubernetes

Nuances of machine learning with Spark ML

Program analysis: are you a good developer?

Building scalable, back pressured services with Akka

Diving into Internet of Things with Java 9

Refactoring your code to Java 9 modules

Wishing for something strange — Java web UI for desktop applications

ReadyNow — an "AOT" with profiling for Java

Kotlin DSL: theory and practice

Big data in modern biology

Boot yourself, Spring is coming (Part 1)

A "smart" release of a multimodule project with a single click

Deep dive into the Eclipse OpenJ9 GC technologies

Apache Kafka's "exactly once" semantics analysis

Boot yourself, Spring is coming (Part 2)

From monolith to microservices

Extreme scaling with Alibaba JDK

Kotlin coroutines

Designing for modularity with Java modules

Reactive programming with Vert.x

Profiling to within microseconds and processor instructions

On the shoulders of giants: languages Kotlin learned from

Spring Boot and Xtend: black magic session with exposure

A​ ​craftsman’s​ ​guide​ ​to​ ​designing​ ​a​ ​clean architecture

Graal, Value Types, Loom and other perks: what it is and why you need it

Linux container performance tools for JVM applications

Java EE 8 finally final! And now Jakarta EE?

Spring Framework 5: feature highlights and hidden gems

VMStructs: how an application may benefit from knowing JVM internals

Typical problems in software development at a large scale

The adventures of Senior Holmes and Junior Watson in a software development world

Performance: What's In It For You?

Java Puzzlers NG S02: Down the Rabbit Hole

More Than You Want to Know about Java's String

Architectural crossroads

Where is my service, dude?

Divide, Distribute and Conquer: Stream v. Batch

How to find deadlock, not hitting it

Devops: now Java is not slow

Fast and Safe Production Monitoring of JVM Applications with BPF Magic

The art of JVM profiling

“Computer, how my cluster is doing?” and other magic spells

Scalability in distributed in-memory systems

Brainstorming a Clean, Pragmatic Architecture

Spring — Deep and not-so-deep dive

Microservices and Modularity or the difference between treatment and cure!

Programming language implementation for a tariff system

Application Performance Monitoring: comparison, issues and solutions

The collective responsibility problem

The Curse of Spring Test

Package your Java Application using Docker and Kubernetes

Java byte-code verification: when, how, or maybe to turn it off?

Future of Kotlin: Strategy and tactics

Shenandoah: The Garbage Collector That Could

Hidden complexity of a routine task: presenting table data in user interface

Development of modern distributed systems: problems and solutions

Struggle for performance in Intellij IDEA

Hibernate performance tuning

CRDT. Resolve conflicts better than Cassandra

Through the keyhole of hashCode into VM

Full-Text Search Explained

Deploy your microservice using Amazon Web Services S3, API Gateway, Lambda and Couchbase

Java Annotations Are a Big Mistake

Handling with Spark what Kafka is streaming

Code vectorization in JVM

Performance engineering story: How Oracle optimized HTTP/2 client

Java inspections in IntelliJ IDEA: What can go wrong?

DataWars. The Bloody Enterprise strikes back

Analyzing HotSpot Crashes

Going Native: Foreign Functions on the JVM

Kotlin Puzzlers

The missing link in programmer training

Multithreaded programming - theory and practice

Object Oriented Lies

Distribute and conquer: an introduction to distributed systems

JVM: a short course in general anatomy

Java Security. From A to Z

Refactoring your legacy code for better maintainability

Tool build battle - Maven vs Gradle

Bytecode for the curious

Java on Elbrus

Inadequate Java interview

Functional Reactive Programming in Java/JS

What can an Open Source student give. Squeezing maximum pleasure and benefits

The web application I dreamed about

Kotlin for JVM: simple, clear, safe

How can a budding Java developer make friends with his database?

Black mark, StampedLock and his friends. How not to violate the pirate code

High fashion news, or Looking for the silver bullet

What you need to know about logging to a pragmatic Java programmer

(Almost) non-blocking synchronization

Monads - an abstraction or a crutch?

Hotspot and AOT: It's time to compile

Unobvious Generics

How to Apply Big Data Analytics and Machine Learning to Real Time Processing

HotSpot Intrinsics

Oh, the cat ran: Compilation and performance of the code on Kotlin

Distributed systems in Odnoklassniki

A saga about how Java developers should test their applications

Hadoop Jungle: a world of wild algorithms and poisonous JVMs

Escape analysis and scalarization

Build tool battle - Maven vs Gradle vs SBT

Native code, off-heap data and Java

Well, the performance of your opensource!

If not Unsafe, then who: the rise of VarHandles

Microservices and Containers in the Middleware World

Myths about Spark or whether a regular Java developer can use Spark

Your personal Spring Boot Starter

Bring up your monkey

«Razbor Polotov» Live!

Man and instincts: how programmed are we?

It works - do not touch! Or why did we redo the whole architecture again

JCache and Distributed Caches: Mayhem!

Quantum Performance Effects II: Beyond the Core

Analytics with Spark and Cassandra

New Sberbank Platform: from idea to replication. Inside look

Stream API oddities

Fear and loathing in distributed systems

How to make a profiler from sticks …​ and other improvised tools

Java 8 support in Excelsior JET

Anatomy of a distributed Data Grid with Apache Ignite

Java 8 Puzzlers

Deeper than stack traces, wider than hip dumps

Types: war of strict with soft …​ and why?

Expand your boundaries with Gradle

IMDG as the main repository - remember everything!

Wait for your happiness without blocking!

Solving the full stack problem, live!

ORM is a shame

11 Friends of the Internet of Things

Development of a client module for the largest back-office system on the grid

The Lord of the Strings: Two Scours

High performance and fault tolerant architecture

Clean up after yourself!

1,2, 314, 271.. SecureRandom in JVM. Hitchhiker's Guide

…​

Seven lessons developers can learn from film

Techno-bio-creatures: the code of artificial life

Dude, where's my memory?!

Internet banking architecture without Enterprise

Javassist at the service of a Java developer

Migrating from PL/SQL to Java

Catechism java.lang.String

Spring Puzzlers - The Beginning

Packed Objects, Object Layout & Value Types — a Survey

Rise of the machines: in an enterprise with 256K RAM

Not everything, but a lot about what you wanted to know about how to write asynchronous multi-threaded HTTP applications, but were afraid to ask Shipilev

Continuous profiling of Java applications during operation

Mom, I really want Hibernate for NoSQL, or whatever you have in mind…​

Team development tools

Best DIY debugger

Scala development productivity

Epic Groovy Puzzlers - Revenge Of The Brackets

Round table. Refactoring and technical debt

CompletableFuture is already here

RESTful services and OAuth protocol in IoT

Iron meters to guard performance

Round table. Java developer tools

Squeeze me completely

Aspect-oriented solution to classic problems

We express ourselves regularly

Round table. The future of the Java platform

Do we need JMS in the world of modern Java technologies?

Secrets are in our heads, not in the JVM

Scala under the hood

Round table. Highload

Theoretical minimum for understanding Java Memory Model

Crash dump - «black box» of the fallen JVM

Advanced Deployment

Java multithreading under the hood

Heap, off you go

Choosing technologies for an enterprise application

Java 8: Advanced Stream Techniques

Akka framework and its use in Yandex

Sandbox escape. Java zero day vulnerabilities

Java 8 and JVM: what's new in HotSpot?

Trade-offs, or How programming languages are designed

Compiler-level meta programming in Groovy

Java Benchmarking: how to write two timestamps!

Spring the Ripper

Java Embedded at your home

Garbage collection, battle of algorithms

Barefoot Hibernate rake

Java compiler and IDE: mutually beneficial collaboration

Java Life Story

What's New in Java 8

(The Art of) (Java) Performance Benchmarking II

IntelliJ IDEA from the inside: architecture, performance, development process

GC: friend or foe?

JVM bytecode converter for Phantom virtual machine

Eclipse vs Intellij IDEA

Type-safe Web with Kotlin

Quantum Performance Effects

Closures and Collections — the World After Eight

Cool!est Cassandra

Java Memory Model: close encounters of the third kind

Bulletproof Java Concurrency

Dynamic race detection in multi-threaded Java programs

Java Runtime: daily duties of the Java Virtual Machine

Exploring JVM Memory optimization capabilities and limitations: one project history

Type annotations in Java 8. And why it's good