Review of the most interesting reports Joker 2018: version of EastBanc Technologies
Hi, habrovchane! In this post, we want to share our impressions of the conference for Java-developers Joker 2018 , which we heard most of all we heard.
We hope this will help you navigate the conference videos when they appear in the public domain. In the meantime, we added links to presentations wherever possible.
')
Agile is the ability to adapt to changes. Efficient use of Agile prevents us from creating the complexity of the systems with our own hands.
The Venkata report contains a list of issues that complicate the system and the general advice of the speaker on software development. It is unlikely that this report will become a revelation, but even obvious things need to be known, it is useful sometimes to refresh them in memory and use them.
As we ourselves make the system complex:
Harald explained how the project solved the problem of organizing distributed transactions by removing transactions and replacing them with the State Machine. To maintain consistency between microservices, they must implement support states, including the disabled, and respond to their change. For communication between services in the project is used Kafka.
In fact, the report has one idea - to abandon transactions when switching to a distributed system.
How does the former transaction work:
Andrey's report can be used as a reference and how-to debugging problems with native memory leakage using the example of non-heap memory.
The report is useful for understanding who and what eats up memory. Andrew shows tools for analyzing memory, including the AsyncProfiler, which is built into the Idea: "The upcoming IntelliJ IDEA 2018.3 integrates a low overhead sampling profile and canvassing profile".
We recommend everyone to look at it and drive their modules and microservices along the same steps.
Tagir talks about the possibilities of programming languages: what, how, when and with what crutches can appear in Java, what problems this has to be solved by the developers and the language community. Explicit practical applicability is small, but may be useful in the long term.
Abstract report has already intrigued. Holmes and Watson promised to uncover several puzzles from the daily development: tools, libraries and frameworks that perplex ordinary developers in their daily routine.
We noted the most useful moments in the story:
It can be said that this is an introduction to reactive programming: the report describes basic concepts and abstractions. Oleg shows the entire evolution of our reasoning, which leads us to the implementation of Publisher from the standard library Reactive Streams. We advise you to look in order to understand where your legs grow from.
You can listen if you’re doing machine learning. Although it is not very clear for whom the report was intended. If people understand, then for them it is no longer interesting. If they do not understand, they will not understand the report, too little information is needed for understanding.
The main message is this: you can use google TensorFlow to train models from Java, but support for learning is limited. But you can use trained models. For example, load a trained model into TensorFlow-microservice and send it requests from Java or another microservice to get a response. For example, recognize the picture, tell by the symptoms, what kind of disease ...
And the TensorFlow team has Docker Image with TensorFlow, which can be used to load models there and send requests for applications of these models. Sweet!
Cyril and Maxim compared modern frameworks in terms of launch speed, in terms of the amount of memory needed to launch and in terms of coding complexity.
One fact caught our attention: Micronaut implements DI at compile time, and Spring implements at startup / work. This allows Micronaut to run faster. But until the release version of Micronaut came out, you have to take a word for it.
Vadim Tsesko talks about the architecture of the music distributor in Odnoklassniki. The report has a description of servers and their roles, a description of balancing and how Fault Tolerance and High Availability are ensured. Separately - about the reactive approach on a real case without any special technical details. OK showed a working example of using a reactive approach.
Various concepts, best practices and architecture for obtaining a fault-tolerant service due to balancing and replication and other data caching tricks for fast data delivery to the user are presented. As always, in the presentation, OK has a bunch of links for more in-depth study of the topic from the slide.
The report we were traveling for :) Actually, no, but Josh Long is one of two big conference stars. His report is cool, combines both humor and technology.
What we call the report in practice was this live coding session on creating reactive microservices using Spring WebFlux. It gives a general understanding of what the Reactive API is, offers an example of use in Spring 5, and the bonus is a cheerful presentation of material. There was also an example with Reactive Proxy as an alternative to Zuul. We advise everyone to look.
There were many reports about this and even more it was discussed in the discussion areas. In fact, the big question is whether the world has become reactive or has it been like this for a long time, but now they have come up with a new name for the old patterns and poured new blood into them.
Among the reports on reactivity were for every taste: and purely technical, for example, Josh Long, who told how to do reactivity in the spring. And real cases of reactivity - for example, Vadim Tsesko from Schoolmates.
Our main technology is Spring, so the Josh Long report is a must-see. ( Link to the repository from the report ). There is an example of a reactive service that works with Mongo reactively and a reactive service that reactively proxies another reactive service. It was quite helpful for us to find out.
We hope this will help you navigate the conference videos when they appear in the public domain. In the meantime, we added links to presentations wherever possible.
')
Day 1
Don't walk away from complexity, run - Venkat Subramaniam
Agile is the ability to adapt to changes. Efficient use of Agile prevents us from creating the complexity of the systems with our own hands.
The Venkata report contains a list of issues that complicate the system and the general advice of the speaker on software development. It is unlikely that this report will become a revelation, but even obvious things need to be known, it is useful sometimes to refresh them in memory and use them.
As we ourselves make the system complex:
- Moving parts
Make unnecessary configuration, create unused components, create too many layers, etc. - Unreadable code
"This code works, but it looks like it should not." Complicated code leads to invisibility of changes. Opaque changes create bugs and interfere with understanding what is happening with the object. - Too many dependencies
Dependencies quickly become incompatible; the more, the harder it is to manage. - Reckless passion to introduce new technologies
Try to answer your questions:
- What is the price of introducing a new technology?
- How easy will it be to abandon the selected technology?
- Library or framework? You use the library, and the framework "surrounds" you. It is much easier to abandon the library than the framework. Therefore, the decision to use the framework should be made more balanced. If it is easy to return to the old approach and if we can prove it, then we need to take it. Do not download what you really do not need.
- Resume Driven Development. - Random difficulty
For example, low-level multithreading. If you have solved the problem using the thread pool, you now have a problem pool.
Transaction cascades or Harald Wendel ( presentation )
Harald explained how the project solved the problem of organizing distributed transactions by removing transactions and replacing them with the State Machine. To maintain consistency between microservices, they must implement support states, including the disabled, and respond to their change. For communication between services in the project is used Kafka.
In fact, the report has one idea - to abandon transactions when switching to a distributed system.
How does the former transaction work:
- It is still transactional, but only one business transaction (conditionally one) is committed to the database. Others as part of the transaction, save to the database for Kafka.
- Also as part of the transaction, we get a new State business transaction. This is a fully valid, self-contained State.
- A special handler reads the base: either polling or commit hooks on the entity, if the handler is in the same place as the entity. Then sends a message to Kafka.
- Kafka subscribers are processing messages. Here we can use the standard delivery guarantee mechanism. Messages are in Kafka right time and someday processed by the service.
- When processing, subscribers can commit to their database and change their State. In doing so, the services exchange the State.
- Rollback business transaction no. And there are three options for handling problems:
- Wait for the victory to correctly process the message from Kafka.
- On error (and the required number of repetitions), it translates to start the corresponding “erroneous” State.
- Send a message to Kafka so that the initiator of the business transaction (and other participants) will process it, to take measures to roll back their local transactions.
Memory Java-process on the shelves - Andrey Pangin
Andrey's report can be used as a reference and how-to debugging problems with native memory leakage using the example of non-heap memory.
The report is useful for understanding who and what eats up memory. Andrew shows tools for analyzing memory, including the AsyncProfiler, which is built into the Idea: "The upcoming IntelliJ IDEA 2018.3 integrates a low overhead sampling profile and canvassing profile".
We recommend everyone to look at it and drive their modules and microservices along the same steps.
Pattern matching and his imaginary friends - Tagir Valeev
Tagir talks about the possibilities of programming languages: what, how, when and with what crutches can appear in Java, what problems this has to be solved by the developers and the language community. Explicit practical applicability is small, but may be useful in the long term.
The Adventures of Senor Holmes and Junior Watson in the world of software development [Joker Edition] - Evgeny Borisov and Baruch Sadogursky ( presentation )
Abstract report has already intrigued. Holmes and Watson promised to uncover several puzzles from the daily development: tools, libraries and frameworks that perplex ordinary developers in their daily routine.
We noted the most useful moments in the story:
- In Spring 5, you can add bins and other things in the external groovy file. Those. no need to rebuild, just restart, for example, to add a BeanPostProcessor.
- It is necessary to remember the name of the bins. For example, you cannot create a bin ConversionService, because This is already in the intestines of the spring.
- Need to remember about the standards. For example, multipart is allowed only for post, and Spring is behind it.
- Need to read the documentation. We will explain on the example of the cuts. AllArgsConstructor adds the java.beans.ConstructorProperties annotation for the constructor. Moreover, if there is no annotation, Jacson uses the default constructor and getters, since constructor parameter names are not saved after compilation. If the annotation is present, it contains the parameter names (in accordance with the java beans convention), and Jacson uses the constructor. Lombok annotation SneakyThrows changes the Checked exceptions to Unchecked exceptions.
- The report also voiced an interesting question: “Do we really need Checked exceptions in principle?” We are thinking.
Day 2
Reactive hardcore: how to build your Publisher <?> - Oleg Dokuka
It can be said that this is an introduction to reactive programming: the report describes basic concepts and abstractions. Oleg shows the entire evolution of our reasoning, which leads us to the implementation of Publisher from the standard library Reactive Streams. We advise you to look in order to understand where your legs grow from.
Derek Ferguson ( presentation )
You can listen if you’re doing machine learning. Although it is not very clear for whom the report was intended. If people understand, then for them it is no longer interesting. If they do not understand, they will not understand the report, too little information is needed for understanding.
The main message is this: you can use google TensorFlow to train models from Java, but support for learning is limited. But you can use trained models. For example, load a trained model into TensorFlow-microservice and send it requests from Java or another microservice to get a response. For example, recognize the picture, tell by the symptoms, what kind of disease ...
And the TensorFlow team has Docker Image with TensorFlow, which can be used to load models there and send requests for applications of these models. Sweet!
Micronaut vs Spring Boot, or Who is the smallest? - Kirill Tolkachev and Maxim Gorelikov
Cyril and Maxim compared modern frameworks in terms of launch speed, in terms of the amount of memory needed to launch and in terms of coding complexity.
One fact caught our attention: Micronaut implements DI at compile time, and Spring implements at startup / work. This allows Micronaut to run faster. But until the release version of Micronaut came out, you have to take a word for it.
Ok.ru/music jet distributor - Vadim Tsesko ( presentation )
Vadim Tsesko talks about the architecture of the music distributor in Odnoklassniki. The report has a description of servers and their roles, a description of balancing and how Fault Tolerance and High Availability are ensured. Separately - about the reactive approach on a real case without any special technical details. OK showed a working example of using a reactive approach.
Various concepts, best practices and architecture for obtaining a fault-tolerant service due to balancing and replication and other data caching tricks for fast data delivery to the user are presented. As always, in the presentation, OK has a bunch of links for more in-depth study of the topic from the slide.
Reactive Spring - Josh Long
The report we were traveling for :) Actually, no, but Josh Long is one of two big conference stars. His report is cool, combines both humor and technology.
What we call the report in practice was this live coding session on creating reactive microservices using Spring WebFlux. It gives a general understanding of what the Reactive API is, offers an example of use in Spring 5, and the bonus is a cheerful presentation of material. There was also an example with Reactive Proxy as an alternative to Zuul. We advise everyone to look.
The world has finally become reactive. Or the overall impression of the Joker reports
There were many reports about this and even more it was discussed in the discussion areas. In fact, the big question is whether the world has become reactive or has it been like this for a long time, but now they have come up with a new name for the old patterns and poured new blood into them.
Among the reports on reactivity were for every taste: and purely technical, for example, Josh Long, who told how to do reactivity in the spring. And real cases of reactivity - for example, Vadim Tsesko from Schoolmates.
Our main technology is Spring, so the Josh Long report is a must-see. ( Link to the repository from the report ). There is an example of a reactive service that works with Mongo reactively and a reactive service that reactively proxies another reactive service. It was quite helpful for us to find out.
Source: https://habr.com/ru/post/427517/
All Articles