The best time to talk with speakers and attendees
The best time to talk with speakers and attendees
Cod filet in lemon sauce + potatoes + salad
Chicken strogonoff + rice + salad (gluten free)
Dumplings: Spinach&feta + Ukrainian with salad
The best time to talk with speakers and attendees
The best time to talk with speakers and attendees
The Java platform experiences an outburst of cool new features – new features added to the Java language include multi-line string literals, simple data carriers and pattern matching. Many library and Java Virtual Machine features were added as well, and many more features are in the pipeline and are actively worked on. This includes value classes for the Java virtual machine, and ability to interconnect Java and native code. These features are delivered quickly, thanks to the recently adopted, predictable, six-months schedule of major Java SE releases. This new release cadence means new Java platform features are delivered twice every year! In this talk, we will show a live demo of many of the recently added and newly developed features and improvements for the Java platform.
Jan Lahoda ,
A software developer with a passion for Java
Spring 2021 - long awaited - Spock 2.0 has been finally released. Heavily rewritten to leverage JUnit Platform (a crucial part of JUnit 5) is ready for even better testing in your projects.
However, what about the support for Groovy 3 and Java 14+? Is Spock compatible with a brand new Groovy 4 and Java 17+? Could the parametrized tests be even better? How problematic will it be to migrate existing tests from Spock 1.3 (especially those using JUnit 4's rules)? What other new features and breaking changes are expected in 2.x?
During this talk, I will summarize over 2 years of development, explaining if/how it impacts the status quo (Spock 2 vs JUnit Jupiter 5) presented by me three years ago.
Marcin Zajączkowski ,
Software Craftsman & Solution Architect @Bottega
When you publish your first HTTP API, you’re more focused on short-term issues than planning for the future. However, chances are you’ll be successful, and you’ll “hit the wall”. How do you evolve your API without breaking the contract with your existing users? In this talk, I’ll first show you some tips and tricks to achieve that: moving your endpoints, deprecating them, monitoring who’s using them, and letting users know about the new endpoints. The talk is demo-based, and I’ll use the Apache APISIX project for it.
Nicolas Fränkel ,
A Java Geek
Let us jump on that Kubernetes train. It is just another tool for running my apps. Right? ... Wrong!!! As Kubernetes becomes mainstream established companies want to benefit from the advantages Kubernetes brings in, too. However, a lot of them underestimate the technical and organizational implications they will face. What happens if you do not care about Resource Requests and Limits? Why do you lose data because of the Shell Form in your Dockerfiles? Why do you have to reconsider how to scale your apps? Why will Kubernetes change your organizational architecture? Why do lots of projects start with one cluster and end up with lots of them? This talk will help you understand the pitfalls of not caring about best practices in Kubernetes. You will hear war stories about failed migration projects and learn how to be successful with yours.
Hubert Ströbitzer ,
JVM Developer doing Kubernetes stuff
Working in a fast-growing company that doubles in size every year, maintaining the quality of products and engineers is a very challenging task. In this talk I will describe how Wix org structure evolved from functional teams to gangs, cross-functional teams responsible for end-to-end delivery; guilds, professional groups responsible for methodology, best practices, and training; and mini-companies that serve as internal startups to support rapid growth while maintaining velocity. Unlike many implementations of the Guild structure, at Wix the guilds are operational guilds that are involved in the day to day life of a developers throughout their journey at the company. I will also discuss how we poured our culture into a game-like “guild day”, that helps us maintain alignment, keep the high quality of our work and people, share knowledge, recruit and preserve the best developers, and support a quality-based culture of innovation.
Aviran Mordo ,
VP Engineering, Wix.com
When writing new Java (web) applications, teams often have some nagging scaling doubts:
* How many users can my application simultaneously handle?
* How fast will my Java app dash out those JSON responses?
* How much memory does my application need? Do I need to worry about garbage collection?
* How much money do I need to spend on hosting? How do I even know how powerful my AWS, VPS or bare-metal machine is?
* Couldn't I just run my whole app on my https://www.raspberrypi.org/[Raspberry Pi]?
Surprisingly, there's very little advice out there on how to sensibly approach these questions in a practical way- apart from that deceiving gut-feeling which tells you that everything will be fine, by simply auto-scaling your Kubernetes pods into oblivion. In this #almostnoslides session we're going to use a terminal, an IDE and a couple of other tools to get a deep, practical understanding of the following scaling topics:
* Latency: How your Java webapp would compare to a Counterstrike game server and what to expect
* Memory: How little memory your application actually needs
* Throughput: How to find out to how many users your application will scale to
* External Systems & Garbage Collection: What to do about the supposed performance killers
* Servers: What the cheapest Hetzner server can do for you By the end of this talk, you'll have learned all the needed tools & processes that make you never worry about scale again.
Marco Behler ,
Developer Advocate @ JetBrains
Are you bored of hearing about Spotify’s Model, Basecamp’s Shape Up, or Netflix’s “No Rules Rules”? All of them do have something in common. They tailored something unique to match both their ambition and their strengths, while honestly acknowledging their weaknesses. Well, so did we. Our VP Of Engineering joined a 100+ engineering team and embarked on a mission to make it scalable. Listen to Ataccama's story and find something to inspire you…because only dead fish go with the flow. SpaceUP - Our Journey to Create a Unique and Scalable Product Organization. More @ https://medium.com/ataccama-spaceup target group: Product & Engineering leaders, Directors, C-Levels - takeaways - how to build a scalable product & engineering organization, the journey of a company growing from 100 to almost 300 people in engineering the goal of the talk: Don't follow the crowd, do your thing - as we did.
Roman Pichlik ,
Software developer, kitesurfer, ironman, coffee & books lover, blogger, podcaster, speaker.
The recipe for a basic web application is simple: front end, back end and the datastore. Nobody ever gets fired for implementing microservices, but it can be a lot of hassle to set them up and keep them running. Wouldn’t it be simpler to let your code live with your data in the blockchain? During this talk we will use Smart Contracts to build a simple resource tracking system and deploy it to the testnets of popular blockchains - Ethereum and Flow. We will compare it to building a Spring based application hosted in AWS to figure out which one is faster to build, easier to manage and cheaper to run. Code snippets will be presented in Solidity and Cadence in a format that doesn’t assume any prior knowledge of these languages. Repositories: [the first](https://github.com/mrydzy/bbi-eth) and [the second one](https://github.com/mrydzy/bbi-cadence).
Maja Rydzy ,
A pragmatic software engineer at work, hype driven developer after hours
I really enjoy giving live coding talks. They let me demonstrate concrete usages of a tool or library that work, rather than 'almost work, but...'. Although the opinions vary, I'd argue that it's possible to deliver an awesome live coding talk - provided that you come well prepared. Having already given a couple of live coding sessions, I'd like to share the lessons I've learned. If you're planning to prepare you own live coding session, the tips&tricks presented here will help you feel more comfortable and prepared for (almost) everything. Real-life horror stories included!
Jacek Kunicki ,
Passionate Software Engineer
Modern-day distributed systems are anything but simple. Schedulers, sidecars, dynamic routing, server-side discovery, proxied connections - all these (useful) concepts increase the operational complexity for such activities as: identifying where an issue propagates from, tracing request's processing graph, nailing down the root cause of the problem. Not even mentioning the proactive early warning - detecting an inevitable issue before it escalates. This session will be dedicated to modern telemetry and how it can be implemented in the cloud (on AWS). We'll traverse all the pillars of observability (centralized logs, metrics, SIEM, distributed tracing) and how they are supported with managed, ready-to-use services (CloudWatch, X-Ray, CodeGuru). We'll take a look at the integration with popular OSS products (Grafana, Prometheus, OpenTelemetry) and we'll draft some reference telemetry architectures for distributed applications in the cloud.
Sebastian Gębski ,
Geek, engineer, blogger, codefella, serial reader. In the daylight: Principal SA for AWS. ex-CTO
Why in the third decade of the 21st century, after 80 years of writing software, data continues to live in two states, hot data in the compute space and cold data in the persistence state? Of course, data is created and manipulated while in a hot state. Ideally, all data would exist entirely in a hot state when you think about it. However, the reality is that due to the way most computers work, it is necessary to keep only the data that is actively in use in a hot state and push all inactive data out to a cold state persistence layer. This hot and cold data perspective raises the question of why is it that at the software level, we still have to focus so much attention and effort on dealing with the movement of data between these two states. In this talk, we will examine what has led us to this point, why we seem to be stuck here and look at some possibilities for moving forward. You also see a real example of a live hot state software approach that inspired this rant and line of thought about seeing data in a hot and cold state way and the profound impact on how we develop software.
Hugh McKee ,
Developer Advocate at Lightbend
CompletableFuture revolutionised asynchronous processing in Java. Unfortunately, it’s full of quirks, traps, and surprises… during this live coding session, we’ll have a look at things like: thread pools backing task execution, exception propagation, cancellations, and unintuitive methods from the public API.
Grzegorz Piwowarek ,
Your friendly neighbourhood architect
DDD and Clean Architecture are nothing new. There are plenty of learning materials in the topic. Books, online courses, conference talks to name a few… However, sometimes I had problems understanding the example domain, presented in the material. That's why I decided to go with my own example with a well-known domain. Domain I'm able to explain to my little son. Let's check 'The Three Little Pigs' fairy tale built with DDD and Clean Architecture. This presentation is for people knowing at least a bit about DDD and Clean Architecture and wanting to see the example implementation. The code is in Java.
Mateusz Chrzonstowski ,
Experienced Full Stack coder; fan of AI, technology, Dragon Ball, and the strategies of the big companies
According to World Health Organization every 2nd person will experience burnout at least once in a lifetime. And since preventing it is much less costly than curing, it is worthwhile to check-up on yourself by answering following questions:
Aleksandra Błaszczyk ,
Crisis coach, soft skills trainer, HR & management consultant
To define where you want to go, first, you need to see where you are. The next step would be to define a plan. Let's discuss a strategy that supports corporations in the adoption of cloud technologies. With several options of cloud services and the different architectures such as multi-cloud and hybrid-cloud, how can Java applications be modernized or developed as a cloud-native solution? Within the Flightplan, we'll discuss the different levels of maturity in cloud adoption and share a guide that will help you avoid targeting too ambitious goals or too conservative and less effective actions. We'll also fly through the application lifecycle management with discussions about lifecycle automation - fast delivery is not a sign that your app lifecycle is on a good path! By the end of this talk, you'll have extra knowledge about technologies, practices, and concepts that you can adopt to support your cloud adoption journey with Java applications!
Otavio Santana ,
Empowering developers worldwide to deliver better software in the Cloud
What will the future of the Cloud and Edge look like for us as developers? We have great infrastructure nowadays, but that only solves half of the problem. The Serverless developer experience shows the way, but it’s clear that FaaS is not the final answer. What we need is a programming model and developer UX that takes full advantage of new Cloud and Edge infrastructure, allowing us to build general-purpose applications, without needless complexity. What if you only had to think about your business logic, public API, and how your domain data is structured, not worry about how to store and manage it? What if you could not only be serverless but become “databaseless” and forget about databases, storage APIs, and message brokers? Instead, what if your data just existed wherever it needed to be, co-located with the service and its user, at the edge, in the cloud, or in your own private network—always there and available, always correct and consistent? Where the data is injected into your services on an as-needed basis, automatically, timely, efficiently, and intelligently. Services, powered with this “data plane” of application state—attached to and available throughout the network—can run anywhere in the world: from the public Cloud to 10,000s of PoPs out at the Edge of the network, in close physical approximation to its users, where the co-location of state, processing, and end-user, ensures ultra-low latency and high throughput. Sounds exciting? Let me show you how we are making this vision a reality building a distributed real-time Data Plane PaaS using technologies like Akka, Kubernetes, gRPC, Linkerd, and more.
Jonas Bonér ,
Founder/CEO of Lightbend; Creator of Akka and the Reactive Manifesto; Java Champion
In a world where microservices are more and more a standard architecture for Java based applications running in the cloud, the JVM warmup time can become a limitation. Especially when you look at spinning up new instances of an app as response to changes in load, the warmup time can be a problem. Native images are one solution to solve these problems because their statically ahead of time compiled code simply doesn’t have to warmup and so has short startup time. But even with the shorter startup time and smaller footprint it doesn’t come without a drawback. The overall performance might be slower because of the missing JIT optimizations at runtime. There is a new OpenJDK project called CRaC (Coordinated Restore at Checkpoint) which goal it is to address the JVM warmup problem with a different approach. The idea is to take a snapshot of the running JVM, store it in files and restore the JVM at a later point in time (or even on another machine). This session will give you a short overview of the CRaC project and shows some results from a proof of concept implementation.
Gerrit Grunwald ,
Loves coding in general, esp. in Java
Jakarta EE 9 lowered the barriers of entry and established a foundation for future innovation paving the way for Jakarta EE 10. With Jakarta EE 10, we introduced Jakarta EE Core Profile which targets smaller runtimes suitable for microservices. The Jakarta EE Core Profile also aims to be an even better fit for compiling to native images. But it does not stop there. Both Jakarta EE Web Profile and Jakarta EE Platform is moving forward as well with updates to almost all the individual specifications. Join this session for the latest updates on the progress with Jakarta EE 10. I will go through what Jakarta EE 10 brings to the table, and what to expect when the specifications are moving forward. The session will also give you a clear understanding of how to migrate from previous versions of Jakarta EE and Java EE as well as show how to leverage Java SE 17 and newer features with Jakarta EE.
Ivar Grimstad ,
Java Champion | Jakarta EE Developer Advocate | The guy with the Duke tattoo
As an SRE, If I have to pick one monitoring for a IT system, it will be the canary monitoring. Why? Let me explain this to you in the 'from zero to hero talk'. We will cover all the necessary details including practical examples and experience from running it in the production. You should get back from the session:
* What is canary monitoring?
* How to build it?
* Deep dive into the benefits
* Considerations and what you need to watch out for
* How to use the same tools beyond monitoring.
Marek Śmigielski ,
SRE Evangelist / System Architect
AWS Lambda is a serverless, event-driven compute service that lets you run code for virtually any type of application or backend service without provisioning or managing servers. AWS Lambda is chosen for its flexibility, the ease of integration with other AWS Services, and reducing the amount of infrastructure you and your team own. But over time, when the number of clients and requests start to increase, and you start caring about latency, you may discover that there is no free lunch. Clients complain about latency, things you've taken for granted when running your software on EC2 or Fargate no longer apply, and costs start to ramp up. In this talk, I'm going to describe some of the lessons learned from working on multiple services backed by AWS Lambda: what are and how to reduce the cold starts, how the JVM makes them even more problematic, when AWS Lambda is more expensive than the less abstract platform, how to use provisioned concurrency and why one of the biggest problems in Computer Science (caching) is even bigger on Lambdas.
Andrzej Dębski ,
Software development engineer at Amazon Alexa
Have you ever dreamed about having an autonomous, self-healing cloud system? One, that would automatically react on unexpected situations, making you sleep well at night? If so, chaos engineering could be for you. This approach is used with good result by biggest players on the market, like Netflix, Linkedin, Google or Facebook, where resiliency is the key to keep your business successful. In this session, you are going to hear a bit about history of chaos engineering. Then, we will be discussing about typical process of stressing an application, which is following chaos engineering principles. Finally, we are going to take a look at AWS Fault Injection Simulator, fully managed service for running fault injection experiments on AWS, in action.
Bartłomiej Pisulak ,
Senior Manager of Cloud Engineering @ Pegasystems | Seasoned IT Trainer | Executive MBA
The idea for the talk came when I had finished bedtime reading “The Lord of the Rings” trilogy to my two daughters. It took us more than a year to go through the journey of the fellowship together, with plenty of questions and digressions, some harder to even wonder about, sometimes existential. That’s why this talk will be different than others, there’ll be no programming languages but rather human language (and a small dose of elvish). Today let’s go together on an adventure and find out what does it mean to be a leader! In Middle-earth we’ll explore why it’s important to answer “why?”, what’s the difference between a good and bad leader, featuring Gandalf and Saruman (also what kind of games they were playing), what’s a diverse team, and why interns are like hobbits. There’ll also be a touch of psychology, sociology, and capitalism, plus our “industry buzzwords” like agile, senior leadership, scrum team, open-source contributions. We’ll find out where to find these in Tolkien’s fantasy world where there are no computers (unless you count palantíri as handheld peer-to-peer devices) but there’s a lot to learn from and benefit — as a leader, contributor and human being. If you are one of those, you’re welcome here (hobbits, dwarves, elves and others are welcome as well!).
Grzegorz Rożniecki ,
Curious constant learner with the mission to empower and inspire others to do fantastic things
Have you ever been confused by implicits in Scala? I most certainly have. I struggled to understand them at the beginning of my Scala journey, and to this day I trip over them regularly. It doesn't help that one keyword can be used for many different things - defining Implicit parameters, implicit conversions, or type class instances. And sometimes it's so frustrating when your code doesn't compile because you can't remember the magical implicit import incantation that is needed (the problem also known as 'why does it work fine in that other file, but not here?!'). Scala 3 addresses a lot of the tricky bits in the language to make it clearer and easier to use, and luckily, implicits have also undergone a redesign. Well, to be precise... they're gone. But in their place, we're getting language constructs that do one thing and do it well. Please join me in welcoming the new keywords: 'given' and 'using', as well as context functions and extension methods. They're the new kids on the block to define our contextual abstractions, and they're here to make our code more expressive and easier to understand. Let's see them in action.
Magda Stożek ,
Software developer at SoftwareMill
When it comes to distributed, event-driven messaging systems, we usually see them supporting either one of two types of semantics: streaming, or queueing, and rarely do we find a platform that supports both. In this presentation, we’ll first get an introduction and some clarifications of event-driven versus message-driven systems, event streams, and stream processing. We’ll then take a look at Apache Pulsar which offers a very unique capability in modern, cloud-native applications and architecture, in which its platform supports both Publish-Subscribe and Message Queues, and extends into streams processing as well as performs message mediation & transformation. We will see how it works closely with and relies on Apache Bookkeeper for its durable, scalable, and performant storage of log streams, and leverages on Apache Zookeeper to manage the otherwise very complex ecosystem. We will then compare Apache Pulsar with the popular Apache Kafka platform to understand some of their key differences as to how Pulsar can overcome some of Kafka's limitations. With Pulsar's flexible architecture and cloud-native readiness, we will take a look to see how it can be integrated and work collaboratively with the popular Spring framework.
Mary Gryglewski ,
Passionate Developer Advocate at DataStax, Java Champion and Chicago JUG President
In our profession, we tend to reinvent the wheel. We introduce new silver bullets that promise to solve our products’ problems: aligning strategy, teams, architectural, and data processing decisions. We’ve all been there: from hundreds of microservices, introducing AI anywhere possible to vast Data Lakes swallowing all of our events. But we end up very often in silos, focusing too much on fine details without looking into a broader picture. That results in underperforming - working in silos, creating over-engineered solutions, or not delivering our business goals. However, several well-proven and well-explored engineering methodologies and tools can help us maximize our efforts - the autonomy of teams, architectures, and data processing they build, which boosts their productivity and quality of delivery. We’ll start with how to identify the proper business boundaries and align our teams together with them. We’ll see which ready-to-use tools we can utilize and how these affect and improve product engineering, data processing, and analytics teams - and, in the end - our overall productivity.
Wojtek Ptak ,
Learner, teams & products builder, leader, achiever, contributor, and freeride biker :)
In this session, Sergio del Amo introduces the Micronaut® framework and demonstrates how the Framework's unique compile-time approach enables the development of ultra-lightweight Java applications. Compelling aspects of the Micronaut framework include: Develop applications with Java, Kotlin, or Apache Groovy Sub-second startup time Small processes that can run in as little as 10 MB of JVM heap No runtime reflection Dependency injection and AOP Reflection-free serialization A database access toolkit that uses ahead-of-time (AoT) compilation to pre-compute queries for repository interfaces. Cloud-native features Sergio also demonstrates how you can generate GraalVM native images of your Micronaut applications to achieve instant startup and ultra-low memory footprint. Sergio del Amo is a Micronaut core committer, Developer Advocate for the Micronaut Foundation, and host of the Micronaut podcast.
Sergio del Amo Caballero ,
Core developer of the Micronaut Framework
We are living in an age of distributed systems. And one of the most challenging problems is the consensus problem. Raft is a consensus protocol that is used in many systems like etcd and Kubernetes, Consul, Kafka, Hazelcast etc. This protocol is based on asynchronous communication between nodes in a cluster (with leader election, log replication, tolerate node failures, timeouts etc.), so we need some useful mechanisms and language features to effectively implement protocol behaviour. During the talk, we will briefly discuss the basics of Raft, and then in code, we will see how parts of the protocol can be implemented using the promising Loom project.
Andrii Rodionov ,
JUG UA leader and Devoxx Ukraine program committee member
Over the past year, Service Mesh has emerged as a critical component of the cloud native stack. It makes communication between service instances flexible, reliable, and fast, so developers can focus on adding business value and letting the mesh does all the complex non-functional work like service discovery, load balancing, encryption, authentication, authorization, support for the circuit breaker pattern, and other capabilities. In this session we’ll provide an introduction to service mesh, starting with somehow the philosophical questions: do we really need a service mesh? what it can do and why people are interested in it ? Going it really to make all our problems disappear? We’ll also explore how it simplifies application design and also where it adds complexity. All with some demos that highlight how the new microservices architectures, as well as legacy monolith applications, could benefit from service mech!
Mohammed Aboullaite ,
Backend engineer at Spotify
Most of you probably heard about distributed caching being the most common application of Hazelcast – but I bet not many of you heard about CRDTs, HyperLogLog, CP Subsystem, or real-time stream processing. During this talk, we’ll go for a quick journey around Hazelcast’s ecosystem, revisit basic functionality, and have a look at some of its hidden flavours. Even if that’s way too much for your use case, there’s still a lot for an engineer to learn from studying these concepts.
Grzegorz Piwowarek ,
Your friendly neighbourhood architect
During this session, I will discuss a few techniques about how to improve the JVM start-up time for any application running on the JVM, independent of the programming language. These techniques could be applied in any project, in general without code changes. You can use the same techniques to speed up the JVM start-up time for your applications (both in development and production environments). Main topics:
- when the JVM start-up matters (i.e. for what types of applications)
- Application/Dynamic class-data sharing in HotSpot JVM
- shared class cache in Eclipse OpenJ9
- few handy JVM flags
- hands-on demonstration (including benchmarks results)
- (optional) Ahead-of-time (AOT) compilation The JVMs included in this talk are OpenJDK HotSpot, Eclipse OpenJ9 and Graal VM
Ionut Balosin ,
Software Architect @ Raiffeisen Bank International
In recent years, one of the biggest trends in applications development has been the rise of Machine Learning solutions, tools, and managed platforms. Vertex AI is a managed unified ML platform for all your AI workloads. On the MLOps side, Vertex AI Pipelines solutions let you adopt experiment pipelining beyond the classic build, train, eval, and deploy a model. It is engineered for data scientists and data engineers, and it’s a tremendous help for those teams who don’t have DevOps or sysadmin engineers, as infrastructure management overhead has been almost completely eliminated. Based on practical examples we will demonstrate how Vertex AI Pipelines scores high in terms of developer experience, how fits custom ML needs, and analyze results. It’s a toolset for a fully-fledged machine learning workflow, a sequence of steps in the model development, a deployment cycle, such as data preparation/validation, model training, hyperparameter tuning, model validation, and model deployment. Vertex AI comes with all standard resources plus an ML metadata store, a fully managed feature store, and a fully managed pipelines runner. Vertex AI Pipelines is a managed serverless toolkit, which means you don't have to fiddle with infrastructure or back-end resources to run workflows.
Marton Kodok ,
A Google Developer Expert, champion of the Cloud Innovators program, top user on Stackoverflow
Costs are the major concern of the 'Day-2' operation in the cloud. On Google Cloud, there is several ways to optimize, reduce the costs. And also to limit the expenses and the mistakes that can involve huge billing This session presents many tips and tricks to reduce the costs: free tiers, recommender, quotas, limits, auto-shutdown,...
Guillaume Blaquiere ,
Google Developer Expert on Google Cloud and fan of serverless services
Quarkus makes it possible to write Java web applications ready to serve requests less than 20 milliseconds after start and occupying less than 20 MB of memory. At the same time, its programming model feels much like the one of a traditional application server: There is persistence with JPA, JAX-RS for REST, CDI, transactions, all MicroProfile specifications and even a compatibility layer for some Spring APIs. Come and see how Quarkus makes all the above possible on top of GraalVM using a new technique called Compile Time Boot. Learn how exactly Quarkus eliminates runtime costs and how it circumvents the limitations of GraalVM. An 8 ms demo will be included.
Michał Szynkiewicz ,
Member of the Quarkus team at Red Hat. Leading gRPC and REST Client Reactive Quarkus extensions
Java has been around for over 25 years. Some say that it’s a little fusty. Meanwhile, it evolved significantly, and much more is coming in the near future! During the presentation we will dig into one of the biggest changes, that is coming with one of the future releases. One of the biggest Java criticisms is its memory management. There are light primitives and heavy objects. As a developer, you can use primitives, but you can’t create your own. There are generic types for objects, but not for primitives. Project Valhalla is trying to address that problem. In what way? What does it mean for developers? What does it mean for frameworks like Spring, JUnit, and many others? What is changing under the hood? During the presentation, we'll explore all these areas!
Arkadiusz Sokołowski ,
Team Manager - Advertising Tech w Allegro
There are many programming paradigms. One of them is the object oriented programming. But... Do you really take advantage of it? Are you brave enough to say that you have real 'objects' in your project? Having classes and creating something from them is not enough... Have you heard about SOLID or GRASP principles? Let's investigate those and some other rules to make your code really object oriented.
Dominik Przybysz ,
Software Developer @ TouK
Your current project is old, tech leader even older, and design was lost? Don't wait for another greenfield project. Code cleaner, and in a more objective way right here, right now. I will demonstrate a few ready to use techniques/recipes/patterns that will make your code better, more readable, and, most importantly, more satisfying. Demonstrated techniques will be objective design oriented and fit in almost every codebase no matter how old, neglected, complex, and tangled.
Marcin Haręza ,
Team Leader at Big Picture
Finance, insurance, telecommunications, e-commerce, gamedev - all is just development, right? During this presentation, I’ll show you what surprised me after transitioning to a full-time gameplay programmer from a backend Scala engineer. Surprisingly, it’s a whole new world with unique structures, tools, and quirks. We’ll touch upon things like: game engines as frameworks - what’s it like to write code in Unreal Engine, how their C++ code is actually not that big of a deal to write what to use for version control if git is not good enough how Steam is used in internal development and why you can see Cyberpunk uploads while there are no patches released yet how gameplay mechanics are tested typical team structures … and many more If you ever wonder about any of that, this presentation will be of interest to you.
Robert Piwowarek ,
Backend engineer turned Gameplay programmer
Technology leaders often strive to build creative teams. However, nowadays it may be a challenging task to achieve, especially in a distributed workplace and a hybrid operational mode. Can Agile be the answer to this difficulty? Does the Agile boost creativity? Will creative mindset help in the Agile transformations? In this short talk I will shed the light on challenges that I faced when building Agile teams and solutions I found to increase team’s creativity and productivity.
Tomasz Manugiewicz ,
Tomek is General Manager, Agile enthusiast and Coach, engineer at heart, lecturer at AGH
An application can only be tested successfully using test automation and executable specifications if the architecture is testable.
The tests must be fast, reliable, and offer good diagnosis precision. They must also be easy to write, maintain, and execute.
Tests without these properties will be abandoned and the effort creating them will be lost.
In this session you will see one battle proven example where I have used executable examples and ended up with a testable architecture as well as living documentation. Takeaways
* With the proper approach, ending up with a testable architecture is doable and fun
* Outside-in development supports test automation
* Re-using executable examples is not too hard when it is implemented properly.
Thomas Sundberg ,
Independent consultant based in Stockholm, Sweden
It's 2022, long gone are the days of ceremony and Java development should be productivity, simplicity. Let's look at how we make it happen, in context of startup going FAST. I will describe the architectural approach we use stack we use, and what, sometimes unorthodox, technology and design choices we have made, and their consequences. Expect: code samples, why does our stack look the way it looks AND… what have we learnt in the process. It's all going to be Revolut-based!
Andrzej Grzesik ,
making things @Revolut, Java Champion
Code efficiency today is often treated indulgently. To a certain degree, it is reasonable. Memory is cheap and developers are expensive. Though at some point maybe your application runs on millions of devices and some battery use optimization might save enough energy to power a small city. Or maybe your company already pays lots of money for servers and their maintenance, and some optimization might make it significantly cheaper. Or even your application works well for a small number of requests but does not scale well and on the day of the trial it shuts down. In this session, I'll show you how to make an efficient Kotlin code cheaply, and how to optimize performance-critical parts of your code.
Marcin Moskała ,
Android developer and Kotlin trainer certified by JetBrains; Author of the books
Just a concurrent programming or a job interview topic in the past, day to day class design practice now. For many teams “immutable first” becomes the norm not only for Value Objects or functional paradigm. It’s a natural consequence of constructors’ existence. Software is more and more complex, there is no place for additional effort just for objects’ state tracking. Despite everything, you can hear objections or whispers of temptation: “It can’t be immutable because of the framework”, “Don’t do it here, it is just an entity/service/DTO”, “We don't need another annotation, 5 on each field is enough”. I'll dispel these myths and show how to make popular Java libraries great tools again (persistence, serialization, mocks and other). They won’t tell you more how to code. Instead of writing God Classes, be a god of your code and write immutable classes whenever you want.
Tomasz Skowroński ,
Software engineer at PANSA. Member of Resilience4J core team
Unit / Integration / GUI - an obvious association when anybody mentions a test triangle. Every ISTQB student can drill down these elements when woken up in the middle of the night. The thing is: is this decomposition still relevant? Does it even work when you run a highly distributed, microservice environment? Does this make any sense in a microservices world?.
During this session we will walk through different test goals, a different hypothesis we want to assert during testing, evaluate tools that can support us and see these tools in action: on a 'real' java based microservices. So expect some critical thinking and a walk-through a set of tools and methods on how to use unit and integration tests effectively. But first and foremost, we will look beyond that and look when to initialise application container, how to approach validation of the service's contracts and finally is it worth to mimic a part of production environment with test containers.
Jakub Marchwicki ,
Software craftsperson, Hazelcast
Mongo - stepping around the pitfalls, avoiding marketing honeytraps (why Mongo marketing goes so far and where to find effective counters: Jepsen and Nemil Dalal; the (in)famous loosing data while reading problem or why clustering is hard and what you can do about it, recently unveiled transactions and their issues and settings and general clustering, sharding, indexing, RAM usage and hints.)
Tomasz Borek ,
Coder from Poland. Hoping to learn something new every day
Delivering APIs to classic server infrastructure takes a lot of time. You need to create servers, application, spend a lot of effort on networking aspects. Cloud opens exciting opportunities to achieve the same in almost no time. Further more, you can go global really easily. I would like to focus on 3 most popular cloud technology providers: AWS, Azure, GCP. If You are a beginner or a daily user fascinated by cloud, feel invited to join me. Let's get together and see how we can create APIs using API Gateway technologies and Serverless functions - in few easy steps . I am also going to touch on some important topics like security and limitations of that solution. I will be happy to see You and have a great fun comparing inside-outs of solutions built by 3 of the biggest Cloud providers.
Tomasz Lis ,
Senior Software Consultant at Capgemini
Jaroslav Tulach ,
NetBeans Platform Architect. Working on GraalVM at OracleLabs
Culture this, culture that; much has been said about organizational culture, its effects on people and productivity, and very little on how to deliberately and concsiously craft your own. While I don't pretend to have the answers, I have found tremendous value in asking and iterating on the questions themselves. In this talk we will - instead of hashing out corporate values and mission statements - figure out how to ask (and evaluate) hard questions. By doing that we arrive at something far more fundamental and powerful: an ethos.
Tomer Gabel ,
Programmer, consultant, conference organizer, and co-founder of Israeli meetups Java.IL and Underscore
Once upon a time in a land far away... Just kidding, it's not that type of a tale I'm about to tell you. I do, however, want you to think: when was the last time you did some theoretical math?
Despite being a part of a software engineer's everyday work, math is too often forgotten and in most cases, we do not think that it can actually impact our job. In this talk, I'm having a closer look at the math hidden behind our software. Can we in fact predict the scalability of our systems by using mathematical laws? Let's dive into some theory and find out.
Bartłomiej Żyliński ,
Software Engineer who likes coding in Scala and blogging
Let's see how we can make the worst possible decisions during a project, and not get fired. We'll talk about not so obvious or counter-intuitive problems and how to deal with them, so that it won't be so easy to blame us later on. The list includes: debugging algorithms, logging, burn-out, neuroscience, depression, buying 3rd party software, handling toxic people, diagrams, burning russian coal (on CPU cycles), religious definitions of architecture and making your dev-life a nightmare. There'll be some solutions as well. The author might talk about his own experience. Or not. SLAs et al. NSFW
Jakub Nabrdalik ,
Solution architect and mentor at Bottega IT Minds, specializing in DDD, TDD, BDD and Spring
The best time to take coffee or juice
The best time to talk with speakers and attendees
To Be Announced
Lighting talk - To Be Announced
Join other attendees and share ideas, talk about the recent challenges, or find solution for a problem. During this session you can connect with other like-minded people in a space designated for certain languages, technologies, and interests.
1. Suggest a topic
Look for large white sheets of paper, and tell everyone what is on your mind! You can also tweet using #topicforgeecon hashtag. Vote for topics (mark it with line/x/heart) and like tweets to show others you’re interested.
2. Choose a room and have fun
We will group similar topics and assign a room. Topics will be pinned before room entrance (list of topics and rooms will be also posted using attendees slack channel - slack.geecon.cz), so you will be able to join others also interested in eg. Kotlin, JVM tuning, Machine learning or testability.
HEVRE (level 0 + 1), Meiselsa 18 Street
Roasted pork in mushroom sauce + pęczotto (pearl barley) + salad (gluten free)
Grilled chicken filet in red pesto + rosemary potatoes + salad
Vegie cutlets with tzatziki sauce + rosemary potatoes + salad
Turkey in thyme&cream sauce + rice + salad (gluten free)
Pork steak in green pepper sauce + potatoes + salad
Penne Vegetariana (pasta) (gluten free)
Cod filet in lemon sauce + potatoes + salad
Chicken strogonoff + rice + salad (gluten free)
Dumplings: Spinach&feta + Ukrainian with salad