JPoint 2017 Java Conference: Moscow, April 7-8 - Presentation Overview

    Five weeks are left until JPoint JPoint Java Conference, 75% of reports have already been approved, the remaining 25% will be selected from existing applications by mid-March. In this post, I will tell you about what we did.



    If the topics of all reports are divided by subject, then the following will turn out:

    • Java performance, both at the JVM level and in working with frameworks;
    • JVM preparation and public demonstration of blood gut;
    • Building distributed systems that work;
    • Concurrency and multithreading issues in large projects;
    • Containerization and orchestration of Java applications and services.

    Plus to the main blocks will be reports on more specific topics: Kotlin, trueOOP in Java from Egor, patterns and, of course, a few puzzlers!

    Under the cut, I will talk about those reports that have already been approved at JPoint 2017. So that all this does not look like a mess, I tried to break up the reports by topic.


    Performance and everything related to it




    Favorite theme of JPoint and Joker members. These reports warm the brain until the state of aggregation changes. This time, as usual, there will be many performance reports.



    Alexey Shipilev - Performance: What's In My Name?

    A revised, augmented and expanded report from Joker 2016 on optimizations in large projects: general principles and relationships; project life cycle and economics of optimizations; benchmark life cycle; typical traps that performance engineers find themselves in.
    More hardcore, more details, more timing, even more crooked curve named "Sh"!



    Sergey Kuksenko - A Tale of how an HTTP / 2 Client engineer overclocked a

    Report on how Oracle uses (or does not use) performance optimization methodologies that have been broadcast for many years from the scene. Using the example of “JEP 110: HTTP / 2 Client” (which will appear in the JDK in the future), Sergey will show how the team started, where it looked and what it twisted in order to make it faster. Note: the report is not about HTTP / 2. Although, of course, some of its details cannot be avoided.



    Nikolai Alimenkov - Let's make Hibernate fast again

    Many Java developers use ORM, but most of them are not aware of the existing options for improving performance. With inherent clarity and practical orientation, Nikolai will give an overview of these options with practical examples. The report is a practice, not a theorist.



    Sasha Goldstein, Fast and Safe Production Monitoring of JVM Applications with BPF Magic

    Sasha Goldstein, a well-known guru of the perfomars in .NET, decided this time to experiment and speak at the Java conference. Over the past years, he has accumulated a lot of experience in optimizing and monitoring applications running on the JVM, which he will share with the participants.




    JVM: Take a look inside




    As always, we have something to listen to about the guts: all about how the JVM works (or will work in the near future) under the hood and what needs to be done so that only what you need happens under the hood.



    Vladimir Ivanov - Techniques for code vectorization in JVM

    In this report, we will talk about how vector processor extensions look like and what tricks the JVM has to go to keep them idle: CPU dispatching, VM intrinsic, and automatic bytecode vectorization in JIT compilers. A specialized vector API (Vector API) will also be mentioned, work on which is actively carried out in Project Panama.



    Alexey Shipilev - Shenandoah: the garbage collector that could

    Shenandoah - the new garbage collector from Red Hat, which is trying to solve the problem of moving objects without stopping the application, thereby reducing pauses even more. This report is about the design and implementation features of Shenandoah, the strengths to be proud of, and the weaknesses to put up with.



    Andrey Pangin, Vadim Tsesko - JVM profiler with a sense of tact.

    The report will discuss various approaches to profiling: JVM TI, AsyncGetCallTrace, perf_events and Flame Graphs. Speakers will analyze the principles of their work, advantages and limitations, as well as find a way to take the best from each of them. In conclusion, we will talk about how Odnoklassniki profile in Production the entire stack from Java code to the Linux kernel.



    Vladimir Dolzhenko - Inside a VM through a hashCode keyhole

    Report on what hashCode () is fraught with. It seems that everyone will learn about him from the first thirty pages of the book by Horstman or Bloch, however, at interviews the problem of misunderstanding the work of hashCode () is constantly revealed. In the report, Vladimir will talk about how the hashCode mechanism is actually built from the inside.



    Nikita Lipsky - Java Bytecode Verification: When, How, and Can Disable?

    A report on the mission of the bytecode verifier in the JVM, when and how it works, whether it can affect the performance of your application and why it is dangerous to disable it.



    Volker Simonis - Analyzing HotSpot Crashes

    In this report, we will look at what you can dig out in the error files that the HotSpot crash handler creates, as well as how these files can help us analyze and reproduce the system crash. In addition, let's look at tools, such as HotSpot Serviceability Agent, which allow you to look into native kernel files and extract the necessary data from them, which would not be easy to get with a standard debugger.



    Charles Nutter - Going Native: Foreign Functions on the JVM

    There are many Java libraries familiar to most developers. Everything will change with the advent of Java Native Runtime and Project Panama. Nevertheless, besides the existing Java libraries, there is a whole world of native libraries: for graphics, cryptography, integration with the OS, and much more. This report will look at interesting native exit scenarios with a comparison of features and an overview of integration tools.




    What else?


    Some participants in our conferences complained that performance reports and JVMs were of little use in real life. Therefore, we will have many reports on applied problems.



    Nikita Koval - Dynamic search for potential deadlocks in multi-threaded Java applications

    Deadlocks are one of the most pressing problems in the development of multi-threaded applications. As part of this report, the Dl-Check tool used to search for potential deadlocks will be considered. During the development of such a tool, one cannot do without bytecode instrumentation, for the implementation of which the ASM framework is the de facto standard. In the first part of the report, the main algorithm of the specified tool will be presented, which allows you to effectively find potential deadlocks during the application. The second part of the report will be devoted to the instrumentation of bytecode, as well as useful techniques and non-trivial problems associated with it.



    Victor Gamov - The Shine and Poverty of Distributed Streams

    Are you one of those who strive for productivity by stuffing Collection.parallelStream () into any cycle? Wondering how to do without global code rework and solve all problems with more servers? How to get distributed processing with a linear increase in productivity? If similar questions sound in your head, then this report is for you.

    In it, Victor will talk about all the details of distributed processing, introduce the audience to his friend, the Oriented Acyclic Graph, and show how information processing is organized on top of the Java 8 Stream API. Distributed! High performance! "In mind"!



    Alexey Zinoviev - Kafka is pouring, and Spark is raking!

    In a typical TK for real-time analytics, there are often points that it is necessary to calculate “on the fly” some aggregated values ​​for a short period of time, filter the flow, reducing the load on the subsequent stages of the calculations. Quite often, we can see projects where teams organize their “data pool” in Amazon, simply dumping all incoming events in Kafka. Will Spark handle streams from Kafka? And if he copes, then at what cost and what will help him in this? Do not wait for the introduction to Spark, RDD, talk about Big Data. One case - one solution - a bit of theory - edit configs - write code.



    Sven Ruppert - Practical Proxy Pattern Deep Dive

    We all read a book about patterns and we know about Proxy. But how to use it effectively? What kind of proxy are there and how to use them to build other patterns? This talk will talk about DynamicProxy, Dynamic / Static-ObjectAdapter, DynamicStaticProxy in runtime and much more.



    Evgeny Borisov, Spring - Deeply and not very
    Working with Spring, you probably come across different problems, nuances and tasks that require non-standard solutions. This talk will talk about spring-core with an overview of the latest changes Spring 4.3 introduced.
    This report will help you better understand how Spring works, how to use it better and more correctly. As usual there will be guts, dismemberment, questions to the audience, prizes and a lot of live coding



    Milen Dyankov - Microservices and Modularity or the difference between treatment and cure!

    The difference between microservices and modularity is almost as blurry as the difference between DI and IoC. In a live-demo talk by Mylene, the Developer Advocate of Liferay, specializing in Java and OSGi, will try to demonstrate this difference and, drawing conclusions, show useful ways to design applications.



    Evgeny Borisov and Kirill Tolkachev - The Curse of the Spring Test

    Each technology contains a specific set of pitfalls. Knowing about them and cleverly avoiding them is the task of a technology-aware developer. Spring is no exception. Let's try to understand various testing approaches using the Spring Boot application as an example, testing it step by step, using new features and collecting new rakes. Let's talk about unit testing, integration tests, the relationship of Spring MVC with Spring Boot, and, of course, about the pains of using Spring 4+.



    Tagir Valeev - Java Inspections at IntelliJ IDEA: What Could Go Wrong?

    IntelliJ IDEA constantly emphasizes your code, offering to replace it with something better. Sometimes the results seem magical. How does an IDE do this? How does he understand your code, how does he generate new code to replace the old one, and what are the pitfalls?

    We'll see what a typical code inspection in IntelliJ IDEA consists of and how much gray hair the IDE developers have in order for you to improve your code with a single click.



    Arun Gupta - Full-stack Reactive Java Application using Docker

    As part of the lecture, Arun, together with students, will create a fully working Java EE / Spring application with RxJava for asynchrony, Docker for containerization and scaling, Couchbase, JavaFX and deployment using Gluon.

    Another Arun talk: Package your Java Application using Docker and Kubernetes . It will tell you how to run and pack Java applications in docker, share them in the Docker Hub, deploy them using Maven and Kubernetes.



    Ivan Ponomarev - The hidden complexity of everyday tasks: Displaying tabular data A tabular

    control (grid) that displays data from a relational database is one of the most common components of the user interface, and everyone has encountered problems with its performance and convenience. The report will show that behind the apparent simplicity of the grid are hiding interesting and unresolved problems that require knowledge in different areas of mathematics. We will try to find a balance between speed and convenience, while learning how to interpolate search, understanding what Collation Rules is and seeing how we can “help” the database quickly retrieve the data we need.




    For dessert - puzzles and holivars!


    In the final part of the post I want to share “dessert” reports: you are unlikely to learn anything new from them about the platform or get any ready-made solutions for implementation in production, but after them you will come out with an excellent mood and cheerful spirit:



    Anton Keks - Kotlin Puzzlers

    Kotlin is a nice alternative language for the JVM, trying to improve the convenience of writing code compared to Java. Although it is no longer new, after the released version 1.0 in 2016, its usability began to grow sharply. Anton will make a quick introduction and immediately move on to the puzzlers - short programs in Kotlin that do not quite what they seem at first glance. Despite the fact that Kotlin was developed for 6 years and even specifically tried to avoid the most famous Java puzzles, he still got his picks and nuances that could not be found in the documentation.



    Tagir Valeev, Baruch Sadogursky - Java Puzzlers NG S02: Everything is

    more wonderful and more wonderful Still, more puzzlers! The more experience industry gains with Java 8, the weirder and weirder it seems to us. It seems that all these streams, lambdas, monads, Optional and Completable Futures were pushed there only to confuse us! And Java 9, barely looming on the horizon, already shines and shimmers with beautiful puzzles and misunderstandings. This season of puzzlers we have, as always, a wonderful set of oddities, funny (at least leading) jokes



    Alexey Savvateev - Collective Responsibility

    Imagine that you are a policeman on duty in a turnstile room. Stowaways
    try to jump through the turnstiles, you catch them. You are one, there are many of them. Is it possible for them to set such “rules of the game” so that they dare not try to jump, even if it is known in advance that you will catch only one of them in any case? It turns out, perhaps.

    Report on mathematics and game-theoretic foundations behind the invention of various ingenious control algorithms. In this report, you will not receive an academic education, you will not learn how to write more efficient algorithms. However, you will get an idea of ​​how rich the mathematical apparatus is.

    If you are interested in the topic of game theory, if you are interested in learning about studies for which the Nobel Committee on Economics has already been awarded several times, then welcome to the report.



    Egor Bugaenko - Annotations in Java is a mistake

    Game lovers are another challenge to the Java community from Egor Bugaenko! As you know, annotations appeared in Java 5 and led to a serious simplification of many libraries, as well as the emergence of new ones. Everyone liked the idea of ​​reducing code size through the use of annotations and the ability to abandon complex XML configuration files in Hibernate and Spring.

    At one time, Egor was also a big fan of annotations. However, everything has changed, and today he is categorically against them and believes that annotations are a big mistake in Java design. Why? This will be the report.



    Baruch Sadogursky - “Computer, how my cluster is doing?” And other magic spells

    As you all know, engineers are lazy. Sometimes we can spend a month of sleepless nights so that later we do not have to press a few buttons. Just for us (actually not) Amazon came up with a great service of voice commands Alexa, with which we can, sitting back in a chair with a glass of cognac / coffee / moonshine (underline as necessary), manage, yes, anything. In this report, I will show you an example of an application that adds a voice interface to completely unexpected things like IntelliJ IDEA and Jenkins, and you can fasten it to whatever you want for less than a month of nights.



    Uff, like I didn’t miss anything from what was announced for today. In general, there will really be a lot of interesting things, and if you write in Java, we will be glad to see you at JPoint.

    It will be useful to recall that in addition to reports at the conference, discussion zones will operate : after each of the reports, the speaker and everyone who wants to ask him questions will be towed to a special zone where participants will have the opportunity to talk with the speaker for another hour and a half - until the end of the next slots with reports.

    In general, we once again did a good job. If you are interested in participating, study the conference website . There is a preliminary schedule, and details of reports and links to materials from past years.

    To all Java, Khabrovites!

    Also popular now: