jvm
Showing 12 out of 12 results
Should Kotlin Be Your Go-To Language?
In the ever-changing landscape of programming, Eammon Boyle and Garth Gilmour have chosen Kotlin as their default language. Preben Thorø explores the reasons behind that choice and how this language could make your life easier.
Expert Talk: Managing Complexity in Software
Complexity of software systems sometimes grows beyond control. Left unchecked, it can leave behind bloated applications. Kevlin Henney talks to Hadi Hariri, developer advocate at JetBrains, about how some of the key traits of developers like creativity and problem solving make them prone to innovate more but also over-engineer their code and not choose solutions based on context.
Programming with Kotlin: Why, How and Kotlin’s Place in the Future
“Developers don’t just like Kotlin, they LOVE it.” Understand why in this discussion with Venkat Subramaniam, author of “Programming Kotlin: Create Elegant, Expressive, and Performant JVM and Android Applications 1st Edition” and Hadi Hariri, VP of developer advocacy at JetBrains. They give you reasons to learn more about Kotlin, whether you like dynamic or functional languages, and why you should always be learning something new.
Spring Boot: Up and Running
Spring Boot is a versatile and supportive environment for developers. Mark Heckler, the author of Spring Boot: Up and Running and Thomas Vitale, software architect at Systematic, explore many of its capabilities while discussing Mark’s book. They cover hot topics such as data integrations, deploying in production, security and reactive vs imperative programming. They both share their views and transforming experiences of joining the Spring Boot community.
15 Years of Spring: Evolving a Java Application Framework
The Spring Framework originated from a book in 2002, becoming the most widely used application framework in the entire Java ecosystem within a few years... and holding that position to this day. This talk illustrates Spring's evolution over 15 years, adapting not only to five new JDK generations but also to ever-changing requirements in modern enterprise architectures. **Prerequisite attendee experience level:** advanced
Keeping Up with Java
It seems like keeping up to date with Java nowadays is an enormous task. Gone is the era of big, delayed Java releases that span years. We're now getting a new major release every 6 months. What's up with that? You're probably still developing on Java 8, even though Java 11 is already available. Join this session to get an overview of what's new in Java since Java 8. We'll give an overview of the module system (Java 9), the local-variable type inference feature (Java 10) and the new HttpClient API (Java 11). Expect lots of advice on how to get from Java 8 to Java 11. It's time to embrace the newfound agility of the Java platform!
Turning the JVM into a Polyglot VM with Graal
The GraalVM is a polyglot platform that runs multiple languages with the same high performance you expect from Java. We’ll show you what you can do with GraalVM, including running Java faster, running JavaScript, Ruby, R, Python and sharing libraries between these languages, running Java programs without the JVM, and running native code on the JVM. Then we’ll show you a little about GraalVM does all of this, and we won’t have to leave our Java IDE to do that because GraalVM is written in Java.
Functional Programming in 40 Minutes
Functional programming has finally escaped from academia. These days developers are building real systems in functional programming languages like Clojure, Scala, Elixir and F#. Functional techniques are also seeping into more traditional languages like Java and Ruby. Unfortunately somewhere along the way functional programming has also developed a reputation for being deep and mysterious: Good programs achieve the Zen-like state of being functional which somehow involves immutability, higher order functions and being referentially transparent. In this talk Russ Olsen will strip away the cloud of mystery to uncover the simple — and wonderful — truth about functional programming: It can make your programming life easier by letting you do simple things simply while also providing you with the sharp tools you need to tackle more complex problems.
Enough java.lang.String to Hang Ourselves
Is it better to write "" + 42 or Integer.toString(42)? How much memory can you save if you intern() all of your strings? How can String Deduplication reduce your memory footprint and what does it cost? And how much memory will Java 9 Strings save in Bulgaria? What is the maximum length of a constant String? And a dynamic String? How much faster is new StringBuilder().append("Hello ").append(name).toString() than "Hello " + name? What are intrinsics and how do they relate to Strings? Are Strings really immutable? How can you efficiently create substrings? These and many more questions we will answer during this talk.
Securing the JVM
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.
Keeping Up with Java [VIRTUAL]
*This will be presented by video* It seems like keeping up to date with Java nowadays is an enormous task. Gone is the era of big, delayed Java releases that span years. We're now getting a new major release every 6 months. What's up with that? You're probably still developing on Java 8, even though Java 11 is already available. Join this session to get an overview of what's new in Java since Java 8. We'll give an overview of the module system (Java 9), the local-variable type inference feature (Java 10) and the new HttpClient API (Java 11). Expect lots of advice on how to get from Java 8 to Java 11. It's time to embrace the newfound agility of the Java platform!
