• jNation Live Stream

    Needs a location

    For the 2nd year in a row the Virtual JUG is excited to bring you a live stream of the full day of the JNation conference in Portugal! NOTE: This event takes place in UTC time zone. Click here to see in your time zone: https://www.timeanddate.com/worldclock/fixedtime.html?msg=JNation+All+Day+Live+Stream&iso=20190604T09&p1=%3A You can watch online at: http://virtualjug.com/#live Full schedule of sessions: The schedule is available here: https://jnation.pt/schedule/ JNation is an inclusive developer conference currently embracing Java and JavaScript at its core, the two most popular programming languages in the world. Java established itself as one of the largest software ecosystem in the World, with more than 3 billion devices running Java and over 10 million Java developers. JavaScript is one of the pillars of the web and its community is growing at a rate unprecedented in the history of programming languages with over 13 million JavaScript developers worldwide. The schedule is available here: https://jnation.pt/schedule/

  • jPrime Conference Live Stream Day 2

    Sofia

    NOTE: This event takes place in Eastern European Summer Time (GMT+3) Click here to see in your time zone: https://www.timeanddate.com/worldclock/fixedtime.html?msg=jPrime+Live+Stream+Day+1&iso=20190529T10&p1=238 For the 2nd year in a row the Virtual JUG is excited to bring you a live stream of the entire jPrime conference! You can watch online at http://virtualjug.com/#live jPrime is a two-day conference with talks on Java, various languages on the JVM, mobile, web and best practices. It is held on 28th and 29th May 2019 in Sofia Tech Park. It's run by the Bulgarian Java User Group and backed by the biggest companies in the city. jPrime features a combination of great international speakers along with the best presenters from Bulgaria and the Balkans. It is divided in two tracks and provides great opportunities for learning, hacking, networking and fun. The agenda is available here: https://jprime.io/agenda

  • jPrime Conference Live Stream Day 1

    Sofia

    NOTE: This event takes place in Eastern European Summer Time (GMT+3) Click here to see in your time zone: https://www.timeanddate.com/worldclock/fixedtime.html?msg=jPrime+Live+Stream+Day+1&iso=20190528T0930&p1=238 For the 2nd year in a row the Virtual JUG is excited to bring you a live stream of the entire jPrime conference! You can watch online at http://virtualjug.com/#live jPrime is a two-day conference with talks on Java, various languages on the JVM, mobile, web and best practices. It is held on 28th and 29th May 2019 in Sofia Tech Park. It's run by the Bulgarian Java User Group and backed by the biggest companies in the city. jPrime features a combination of great international speakers along with the best presenters from Bulgaria and the Balkans. It is divided in two tracks and provides great opportunities for learning, hacking, networking and fun. The agenda is available here: https://jprime.io/agenda

  • Java, Turbocharged

    LONDON, london

    Watch the session on https://www.virtualjug.com This is a virtual Meetup occurring at 5PM UK time (GMT). The live session will be broadcast on https://www.virtualjug.com. Just click to join when the time comes! The recording will be available immediately afterward. Here's a timezone calculator: https://www.timeanddate.com/worldclock/fixedtime.html?msg=Java+Turbocharged&iso=20190502T17&p1=136&ah=1 Take part in the live session discussion on our slack channel: https://bit.ly/2ramaDW Abstract: Over the last twenty years, there has been a paradigm shift in software development: from meticulously planned release cycles to an experimental way of working in which lead times are becoming shorter and shorter. How can Java ever keep up with this trend when we have Docker containers that are several hundred megabytes in size, with warm-up times of ten minutes or longer? In a live coding demo I will demonstrate how we can use Quarkus so that we can create super small, super fast Java containers! This will give us better possibilities for scaling up and down - which can be a game-changer, especially in a serverless environment. It will also provide the shortest possible lead times, as well as a much better use of cloud performance with the added bonus of lower costs. Speaker: Marcus Biel (@MarcusBiel) Marcus works as Director of Developer Experience for Red Hat. He is a well-known software craftsman, Java influencer and Clean Code Evangelist. He is also a regular speaker at Java conferences all over the world, such as JBCN Conf Barcelona, JPoint Moscow and JAX London. Besides this, he works as a technical reviewer for renowned Java books such as Effective Java, Core Java SE 9 for the Impatient or Java by Comparison. In 2015, Marcus started a Java blog and YouTube channel that makes Java accessible to passionate developers. There are many advanced tutorials that you can find online, but tutorials with a solid background like this one are rare. Marcus has become well-known in the Java community, with a total of[masked] followers across various social media platforms. In 2017, the editorial team at http://jaxenter.com rated him #13 in their list of the world’s top Java influencers.

  • Reactive Performance

    LONDON, london

    Watch the session on https://www.virtualjug.com This is a virtual Meetup occurring at 5PM UK time (GMT). The live session will be broadcast on https://www.virtualjug.com. Just click to join when the time comes! The recording will be available immediately afterward. Here's a timezone calculator: https://www.timeanddate.com/worldclock/fixedtime.html?msg=Reactive+Performance&iso=20190417T17&p1=136&ah=1 Take part in the live session discussion on our slack channel: https://bit.ly/2ramaDW Abstract: Reactive libraries such as RxJava 2 and Project Reactor 3 are great tools that allow writing async, functional and declarative code which looks clean and works like a charm. Even though Reactive Libraries works fast, performance is usually not the best characteristic here. Nevertheless, can we make reactive code perform better? In this session, we are going to look at the performance tuning that we can do to a reactive application without changing any code. We'll look at the hidden properties inside the Reactor 3/RxJava libraries; GC that can fit streaming use cases better; whether to choose Graal as the JIT compiler; all those questions will be discussed and answered during the presentation. Speaker: Oleh Dokuka Oleh is mainly a Java Software Engineer / Consultant focused on distributed systems development adopting ReactiveManifesto and ReactiveProgramming techniques. Along with that, Oleh is the author of the book “Reactive Programming is Spring 5.0”: https://www.packtpub.com/application-development/reactive-programming-spring-50. He is also, an active contributor to the community’s development as co-organizer of Rockstar Night meetups, and as a part of the program committee of conferences such as Devoxx Ukraine, JEEConf, Kotlin Night.

  • Evolving a Pragmatic, Clean Architecture  - A Craftsman's Guide

    Watch the session on youtube: http://youtu.be/qM4RlRf9gLY This is a virtual Meetup occuring at 5PM UK time (GMT). The live session will be broadcast on https://www.virtualjug.com. Just click to join when the time comes! The recording will be available immediately afterward. Here's a timezone calculator: https://www.timeanddate.com/worldclock/fixedtime.html?msg=Evolving+a+Pragmatic%2C+Clean+Architecture+%C2%A0-+A+Craftsman%27s+Guide&iso=20190328T17&p1=136&ah=1 Take part in the live session discussion on our slack channel: https://bit.ly/2ramaDW Abstract: Are you in a mood for a brainstorm? Join this critical review of the major decisions taken in a typical enterprise application architecture and learn to balance pragmatism with your design goals. Find out how to do just-in-time design to keep as much use-cases as simple as possible. The core purpose of this presentation is to learn to strike a balance between pragmatism and maintainability in your design. Without continuous refactoring, a simple design will inevitably degenerate into a Big Ball of Mud, under the assault of the new features and bugfixes. On the other hand, very highly-factored code can burden the take-off of the development and end up freezing the mindset in some rigid 'a-priori' design. The end goal of this talk is to challenge you to rethink critically the architecture of your own systems, and seek ways to simplify it to match your actual needs, with a pragmatic mindset. "Architecture is the art of postponing decisions", said Uncle Bob. This talk takes this idea further and explains an optimal mindset about designing enterprise applications: Evolving (Continuously Refactoring) a Pragmatic (Simple), Clean (aka Onion) Architecture, aiming to provide Developer Safety™️ and Comfort™️. It’s the philosophy that Victor distilled over the past 5 years, designing and implementing 9 applications as IBM Lead Architect, and delivering trainings and advising many other companies. You’ll learn how to break data into pieces (Fit Entities, Value Objects, Data Transfer Objects), how to keep the logic simple (Facades, Domain Services, logic extraction patterns, Mappers, AOP), layering to enforce boundaries (keeping DTOs out of your logic, Dependency Inversion Principle), and many more, all in a dynamic, interactive and extremely entertaining session. Speaker: Victor Rentea Victor is one of the top Technical Trainers in Romania. He trained and coached more than 1000 developers of 30+ companies over the 6 years of his training activity. At IBM, even though they call him a Lead Architect, he writes code each day: he’s maniac about Clean Code, so expect seeing some hard-core refactoring. Victor is a key community member: organized the largest 3 Bucharest Java User Group meetups in history. In 2018 he founded the Bucharest Software Craftsmanship Community in which he runs open sessions about clean code, refactoring, pair programming and TDD. He posts daily on LinkedIn and Twitter (@VictorRentea) thoughts about culture, technical excellence and Software Craftsmanship.

    4
  • Performance After Eight

    LONDON, london

    This is a virtual Meetup occuring at 5PM UK time (GMT). The live session will be broadcast on https://www.virtualjug.com. Just click to join when the time comes! The recording will be available immediately afterward. Here's a timezone calculator: https://bit.ly/2V5EHy3 Take part in the live session discussion on our slack channel: https://bit.ly/2ramaDW Abstract: Every major JDK release brings new and (mostly) exciting features with a ton of performance improvements. For example, JDK 9 consists of an impressive number of JEPs—91—of which at least a quarter are performance-related. This session takes a look at Java 9, 10 and 11 performance improvements implemented in the language, core libraries, and the JVM itself. It also discusses potential performance regressions and pitfalls to look out for. Whether the pain of upgrading to Java 11 is worth the effort, you will decide for yourself. But this session’s speaker hopes to give you enough incentives to entertain such an idea. Speaker: Dmitry Vyazelenko Dmitry is a software developer, conference speaker and a disorganizer of JCrete (http://www.jcrete.org/) and JAlba (http://jalba.scot/) unconferences, who is passionate about concurrency and performance. Follow Dmitry on twitter @DVyazelenko.

  • Monitor Your Java Apps with the Elastic Stack: Logs, Metrics, Pings, and Traces

    This is a virtual Meetup occuring at 5PM UK time (GMT). The live session will be broadcast on https://www.virtualjug.com. Just click to join when the time comes! The recording will be available immediately afterward. Here's a timezone calculator: https://bit.ly/2S40jgr Take part in the live session discussion on our slack channel: https://bit.ly/2ramaDW Abstract: "With microservices every outage is like a murder mystery" is a common complaint. But it doesn't have to be! This talk gives an overview on how to monitor distributed applications. We dive into: - System metrics: Keep track of network traffic and system load. - Application logs: Collect structured logs in a central location. - Uptime monitoring: Ping services and actively monitor their availability and response time. - Application metrics: Get the information from the application's metrics and health endpoints via REST or JMX. - Request tracing: Trace requests through a distributed system and show how long each call takes and where errors are happening. And we will do all of that live, since it is so easy and much more interactive that way using Elasticsearch Service on Elastic Cloud. Speaker: Philipp Krenn Philipp lives to demo interesting technology. Having worked as a web, infrastructure, and database engineer for more than ten years, Philipp is now working as a developer advocate at Elastic — the company behind the open source Elastic Stack consisting of Elasticsearch, Kibana, Beats, and Logstash. Based in Vienna, Austria, he is constantly traveling Europe and beyond to speak and discuss about open source software, search, databases, infrastructure, and security.

    1
  • Continuous Profiling in Production: What, Why and How

    Needs a location

    This is a virtual Meetup occurring at 5PM UK time (BST), here's a timezone calculator (https://www.timeanddate.com/worldclock/fixedtime.html?msg=Continuous+Profiling+in+Production%3A+What%2C+Why+and+How&iso=20190122T17&p1=1440&ah=1). You can tune in to the live session at virtualJUG.com (http://virtualJUG.com/) Join us for live, in-session discussion on our slack space: https://goo.gl/ELDDcp Abstract: Everyone wants to understand what their application is really doing in production, but this information is normally invisible to developers. Profilers tell you what code your application is running but few developers profile and mostly on their development environments. Thankfully production profiling is now a practical reality that can help you solve and avoid performance problems. Profiling in development can be problematic because it’s rare that you have a realistic workload or performance test for your system. Even if you’ve got accurate perf tests maintaining these and validating that they represent production systems is hugely time consuming and hard. Not only that but often the hardware and operating system that you run in production are different from your development environment. This pragmatic talk will help you understand the ins and outs of profiling in a production system. You’ll learn about different techniques and approaches that help you understand what’s really happening with your system. This helps you to solve new performance problems, regressions and undertake capacity planning exercises. Speakers: Richard Warburton & Sadiq Jaffer Richard is a Software Engineer, Teacher and Java Champion. He is the cofounder of Opsian.com and has a long-standing passion for improving Java performance. He’s worked as a developer in different areas including Developer Tools, HFT and Network Protocols. He has written the book “Java 8 Lambdas” for O’Reilly and helps developers learn via http://iteratrlearning.com and http://www.pluralsight.com/author/richard-warburton. Richard is an experienced conference speaker having spoken at dozens of events and sat on conference committees for some of the biggest conferences in Europe and the USA. He holds a PhD in Computer Science from The University of Warwick. Sadiq holds a PhD in Autonomous Robotics and has for years consulted for multi-national companies designing and implementing highly scalable intelligent platforms. His experience has included deep learning systems, embedded platforms, desktop and mobile games development. He's a regular speaker at software conferences including Devoxx Be and UK, Javazone and JAX London.

  • Securing the JVM - Neither for fun nor for profit, but do you have a choice?

    This is a virtual Meetup occuring at 5PM UK time (BST), here's a timezone calculator (https://www.timeanddate.com/worldclock/fixedtime.html?msg=Securing+the+JVM+-+Neither+for+fun+nor+for+profit%2C+but+do+you+have+a+choice%3F&iso=20190109T17&p1=%3A&ah=1). You can tune in to the live session at virtualJUG.com (http://virtualJUG.com/) Join us for live, in-session discussion on our slack space: https://goo.gl/ELDDcp Abstract: Consider a Java application in a private banking system. A new network administrator is hired, and while going around, he notices that the app is making network calls to an unknown external endpoint. After some investigation, it’s found that this app has been sending for years confidential data to a competitor (or a state, or hackers, whatever). This is awkward. Especially since it could have been avoided. Code reviews are good to improve the hardening of an application, but what if the malicious code was planted purposely? Some code buried in a commit could extract code from binary content, compile it on the fly, and then execute the code in the same JVM run… By default, the JVM is not secured! Securing the JVM for a non-trivial application is complex and time-consuming but the risks of not securing it could be disastrous. In this talk, I’ll show some of the things you could do in an unsecured JVM. I’ll also explain the basics of securing it, and finally demo a working process on how to do it. Speaker: Nicolas Frankel Developer Advocate with 15+ years experience consulting for many different customers, in a wide range of contexts (such as telecoms, banking, insurances, large retail and public sector). Usually working on Java/Java EE and Spring technologies, but with narrower interests like Software Quality, Build Processes and Rich Internet Applications. Currently working for Exoscale. Also double as a teacher in universities and higher education schools, a trainer and triples as a book author.