Cruising Along with Java • Venkat Subramaniam & Alina Yurenko

This interview was recorded for the GOTO Book Club.
http://gotopia.tech/bookclub

Read the full transcription of the interview here

Venkat Subramaniam - Author of "Cruising Along with Java" and Many More Books
Alina Yurenko - Developer Advocate for GraalVM at Oracle Labs

RESOURCES
Venkat
https://twitter.com/venkat_s
https://www.linkedin.com/in/vsubramaniam
https://github.com/venkats
http://www.agiledeveloper.com

Alina
https://twitter.com/alina_yurenko
https://github.com/alina-yur
https://linkedin.com/in/alinayurenko

DESCRIPTION
Java is on a fast-paced development schedule that brings with it improved design capabilities and enhancements for application security. Learn about the changes to Java, from version 9 to 19, and apply new features to build enterprise applications faster and with fewer errors. Get up to speed on how to make your code concise, expressive, and less error prone, and create better OO programs with the newest features. Modularize and create asynchronous applications with ease and proper error handling. This book contains twelve chapters that dive deep into the features, using plenty of examples for you to practice along with.

* Book description: © Pragmatic Programmers

RECOMMENDED BOOKS
Venkat Subramaniam • Cruising Along with Java
Venkat Subramaniam • Programming Kotlin
Venkat Subramaniam • Functional Programming in Java
Venkat Subramaniam • Pragmatic Scala
Venkat Subramaniam • Test-Driving JavaScript Applications
Subramaniam & Hunt • Practices of an Agile Developer

Bluesky
Twitter
Instagram
LinkedIn
Facebook

CHANNEL MEMBERSHIP BONUS
Join this channel to get early access to videos & other perks:
https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/join

Looking for a unique learning experience?
Attend the next GOTO conference near you! Get your ticket: gotopia.tech

SUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

Chapters

• 0:00 Intro
• 1:47 Java's evolution
• 8:43 Fast-paced writing
• 14:57 The power of Java's modern features
• 24:06 Java's potential: Records, optimizations & synergies
• 29:08 Mastering Java's modern landscape: A practical guide for devs
• 37:59 Outro

Transcript

Intro

Alina Yurenko: Hi, everyone, and welcome to this new episode of the GOTO Book Club. My name is Alina Yurenko. And I'm a developer advocate for GraalVM at Oracle. And I'm here with an amazing guest. Hi, Venkat Subramaniam.

Venkat Subramaniam: Hey, Alina. Great talking to you. And hope things are going well today for you.

Alina Yurenko: Yes, a better day. But I hope I will see you tomorrow in person, right, in Bucharest. So, we will have a chance to also speak in person.

Venkat Subramaniam: Yes.

Alina Yurenko: Yes. So I wanted to introduce you. I don't think you need any introductions because I cannot imagine a person that wouldn't know you, but just to do this properly. So, Venkat is an author, speaker, a professor at the University of Houston, and basically a walking legend in the Java community, and beyond. Venkat, would you add anything to that list?

Venkat Subramaniam: No. I think thank you so much for that introduction. I usually say that I'm a programmer, and I get excited about technology and like to talk about it. So that's what I am.

Java's Evolution: Threads, Patterns, and Text Blocks

Alina Yurenko: Very humble. Okay. And for this video, I did a little bit of research. And I looked into what you did over the span of your career. And you started as a system administrator if I'm not wrong, and then you switched to C++. And you've been doing C++ for a while, but even teaching C++, and then you transitioned to Java. So, can you maybe talk a little about what attracted you in Java in the first place? How that switch happened? And how was that experience of starting to work with Java for you?

Venkat Subramaniam: Oh, my gosh. So, yes, I was actually working actively in C++, developing applications for mainly companies that did a lot of chemical engineering. Along the way, I remember seeing this new language called Java being released. There was a lot of excitement about this thing called applets. I remember writing my own applet for the first time, having that deployed on a browser. It's kind of weird to even think about it these days, because, you know, I started working when there was no concept of browsers back then. And we saw browsers come through and then Java eventually come through. It's really funny to watch the evolution, because Java is really known for its capabilities on the server side. But the origins were actually completely elsewhere. That's really a great way to see history, right? You talk about agility, you talk about adaptations, you talk about evolution. All of that stories are stories of Java. So it's pretty exciting to have seen that journey from the beginning.

Alina Yurenko: It sounds like a lot of fun. So how was the experience writing those applets for you? Did you also show them to your friends and colleagues, like, look what I can do?

Venkat Subramaniam: Well, you know, it's funny, because I was teaching a course related to Java last week. And I had to explain certain things about class loaders. And one of the questions...this was in 2024, was, why in the world these things work this way? And the answer is, aha, let's go back and talk about history. And applets really required certain things in a certain way, which may appear strange to some people today, without the context of applets. So it was not only exciting back then, in all honesty, it's exciting even now. Because when people are coming new to the language, from other languages, they are curious to know why things behave a certain way in Java. You know, they come with experience from C#, for example, or they come experienced with C++ or Python. And then they're trying to understand why things are done the Java way. So it's pretty exciting, you know, definitely to explain that, not only back then, but even now, in my opinion.

Alina Yurenko: I like how you called it the Java way. That's a really nice definition. I like it. Since you talked about the evolution of Java and the speed of evolution of Java. So in the preface of the book, you're talking about what were the many exciting features that we've seen since Java 8, when you published your book about doing functional programming in Java. Right? So I wanted to ask you, I know it'll be a very complicated question. But if you could look back maybe since Java 8, what are your maybe top three most favorite features since that and also how they affected your personal approach to programming?

Venkat Subramaniam: You're putting me on the spot with three features, because I would rant away with several of them, but because you said three, I will stick to three.

Alina Yurenko: Okay, maybe five. Maybe five. I believe we can do it. Yes. Let's try.

Venkat Subramaniam: If I look at the significance, right, things that are...it's like, oh my gosh, this is fantastic, kind of an opinion. To me, honestly, that was Java 8. Because with functional programming capabilities, it was mind blowing what you could do in Java. And that same almost aha experience I now have with virtual threads. And so, at the top of the line, I would say my preference would be to virtual threads and structured concurrency. This is a topic we're going to take a little while to get really good in understanding. I can think about these two as two different use cases that kind of come together in terms of how they work together. So I would say those two are really, really exciting features. Besides the concept of virtual threads, and structured concurrency, I would say my really favorite feature is pattern matching. I really like pattern matching.

And one of the reasons I like pattern matching is not only the fluency that pattern matching brings to the table... You know, before the time of pattern matching in Java, I'm a polyglot programmer. I program in Ruby, and Python, and JavaScript, and C#, and so on, and Erlang. And honestly, one of the things I do in almost all these languages is, I would write my code, and then I would spend the next few minutes trying to refactor it, so that it becomes really concise and expressive. Anytime I had multiple FNL statements, I would, you know, look for something similar to pattern matching. In the case of Ruby, for example, I'd use the when, you know, facility, when and case. Similarly, in Kotlin, I'd use features like that as well. So naturally, I'm a big fan of the pattern matching syntax in Java. But again, to mix in these other features that I really like, what I like about pattern matching is, not only is it amazing on its own, but the way it interplays with records, and the way it interplays with sealed classes, is just really, really amazing.

That's one of the reasons why I like pattern matching is, because it's awesome on its own, but it's even more awesome with other features that are in the language. So that's a nice way to really see how it really shines. And then I would say my third feature I would say, is, in all honesty, again, one thing I've used very extensively in other languages is a concept called HereDocs, they have in other languages. Java has it as text blocks. And I really like text blocks as well. Because with text blocks, I'm not writing verbose code, I'm making very expressive. And again, this is one feature, I think, is going to work really well, eventually, with the ability to bring in the string, you know, templates, and I think that's going to shine really well, as well as move forward. So these are, I would say, you know, top three, or top five, is I would say, virtual threads with structured concurrency, text blocks on one end, right in the middle is my favorite, pattern matching, along with the sealed classes and records as well.

Fast-Paced Writing: Crafting Books in Record Time

Alina Yurenko: Let's talk about the book now. First of all, I feel very happy and privileged to have a chance to read it before it even goes live. Right? So you're still writing the book. But you can already give it a try. And I must say I told you, your book and me have a very active social life. So here it is. I read it. We want to see "Dune" together. We went to some meetings together. Great book. I really enjoyed reading it. And I enjoyed how you give a lot of examples. And also it's as educational as it is also fun to read. So you have all those little jokes and very fun examples to follow. So, a great read. And I want to ask as the first thing. So how was it for you to write this book? And can you talk a bit about that process of writing books? How to do it overall, and how it was about this particular one. And also, we all know that you go to a lot of conferences, so I guess it helped that you get questions or maybe some feedback. So can you talk a bit about writing the book?

Venkat Subramaniam: So I've got a very weird way of writing books. And it's probably hard to believe this is actually true. So most of the books I write, I write over a two-week period. I don't write a book for a longer time. And that's just the way I've written most of my books. Because I travel a lot, it's really hard for me to find time when I can focus on, you know, deep work, unless it's client work, then I'm in a client's site usually working for them. So I typically, you know, take two weeks away when I can, usually a week of Thanksgiving, if you will, or a week of Christmas. And I will just plow through and spend 12 hours a day writing books. This one was actually quite unique because I was on a hike on a mountain with my wife. And, you know, away from the computers, you're up at the high elevations, there's no noise, there's no cars, there's no traffic. And we're just hiking, and I'm kind of quietly hiking for a few minutes. And my mind is wandering, what do I want to do next? Where do I want to write?

I suddenly realized, oh, wait, I could actually write about the evolution of Java, all the way from Java 9 to Java 21 at a time, or whatever I want to write about. And as soon as I got that idea, I said to my wife, "I'm thinking of writing this book, what do you think?" And her immediate response was, "Didn't you say there is a Java conference coming up in two months? Well, why can't you get this released for beta in two months?" And I'm like, "Yes, boss. So that's a great idea." So I come home, drop everything else. And I just started writing that, and finished writing it. Approached my very good friends at Pragmatic Programmers and said, "Hey, would you be interested in publishing this book on evolution of Java?" And to my surprise, and I'm very grateful and thankful for them, they reviewed it because I had a first draft already. They took a look at it, came back the next day and said, "Here's the contract approved." And I said, "On one kind request, we need to get this out in beta in two months."

And I've always worked with my good editor, Jackie. She's amazing. And so we called up Jackie and said, "Do you think you can work on this?" And Jackie takes a deep breath and says, "It's going to be hard, but I'll do it for you." And so she works nonstop, and we both work nonstop, going from the first draft into coming up with the first...excuse me, system development edit, and then push it to beta. So that's what we did. So this book actually was created very rapidly compared to even other books that I normally write. So it was an exciting journey to see that take shape. And so I think in a week and a half, I wrote it. And then, you know, we took another month to go through the development edits. And then we got it out in beta in less than about two months.

Alina Yurenko: I must say, this is so impressive. I should not be impressed. Probably nothing new. But still, like, writing a book in under two weeks. Like, some of us, I'm not gonna point fingers, but some of us can take a week to write a blog post, and writing an entire book, I would guess, you wrote it in a year or maybe even two years. So this is really impressive.

Venkat Subramaniam: And, you know, it's a first draft. So it's not an entire book, obviously. And different people have different styles of writing book. And I really respect it. I've got some really good friends, and what they would do is they would take two sentences. And they would work on that sentence, and rewrite it, and rewrite it, and rewrite it. And then when they are done with that sentence, they move on to the next, you know, sentence and next paragraph. And I respect that, right? That's their style of writing. What I do is quite the opposite. I do a core dump. I have a lot of thoughts on my mind. And I would just write everything that comes to my mind. It wouldn't have really good, you know, verbiage. It may have some examples I'm ticking through. But what I've done is I've really created a very, very, very rough draft. But once I've created the rough draft, it's got the shape, but now I'm able to see the arc, and see if I have to move things around.

Then once I have the first draft, I would start working with my development editor. And then we both will start going through one chapter at a time. And that's when, in a way, to say that I rewrite the chapters I've written. So this time, I would go back and reread my paragraphs, rearrange them, reword them. So I kind of take that iterative approach where I create like a beta...maybe not even a beta, right? So it's extremely a rough draft. Nothing that anybody in the world can see other than my wonderful editor who has been extremely patient with looking at my first draft, and then we start really reworking. And in all fairness, even before I give it to her, oftentimes I go through it two or three times, and then she goes through it and then makes a lot of suggestions and improvements. So it goes through several iterations after the first draft. But that's one of the reasons I like to get that first draft very quickly. So typically, in about two weeks or so, is what I aim for.

Unveiling the Power of Java’s Modern Features

Alina Yurenko: Still really impressive, but I guess it should not be a surprise. Okay, let's talk maybe a bit more detail what people can expect from the book. Let's maybe go through the chapters, at least briefly. And I will pull my notes because there is so much I want to ask you. So first, we start with talking about features like type inference, and then we switch to records, and sealed classes, and interfaces. And you mentioned them briefly already. And in the book, you talk about how all these features help us write code that is more readable, more maintainable, more pleasant to work with, more pleasant to write. And what I also like, you give a lot of examples for each feature, or even each aspect of the feature. And then you show how you can gradually improve all of them, step by step, making sure it's something that we can all learn, and understand, and replicate in real life. So I really enjoy reading those chapters. Can you talk maybe about your... from your perspective, about those teachers, and what you want readers to take from them?

Venkat Subramaniam: When I started looking at the features, you know, what are the challenges you often deal with this, you've got all these features, but how do you present them in a proper order where it begins to make sense. So the first challenge for me was to really sift through these features and see what kind of grouping would actually make sense to put them together. And then I realized that there are certain features that are predominantly a compiler related feature. It doesn't even get down to the byte code, for example. And then there are features that are really oriented towards making the code concise. So that was the very first journey, is to really start grouping the features together in ways that it actually makes sense to the readers in terms of how they can really digest these topics.

The second thing that was important to me was not really focusing on, let me tell you what Java has. What I really wanted to focus on, and this is really the pragmatic way in a way to think about writing books, is to focus on how do developers benefit from using these features. So that was the driving factor for examples as well, and also for the narrative story, is to say, you have this particular application, you are struggling with this particular idea. Well, here's how this feature can help you to implement that particular idea that you have. And then here are the ways you're going to benefit from it. But at the same time also to be objective, here are some of the pitfalls you may run into, here are some gotchas you may run into. And that's one of the things that I really enjoyed... As an example, when I was writing about records, that's one of the things I really enjoyed about writing records, is, not only show the amazing power of records, but also the complexities that are involved in the construction of records.

So to step back and say, you're going to trip yourself up when you get to this part, because it's not intuitive, it's not obvious. So let's slow down and understand. And to give a narrative of, what does it really feel like when you use it. It's not really a constructor, it's more like a filter, it's more like a transformation that you go through before the constructor is being used. And I think that really helps to hone in the concept for developers. And that's one of the things I really like doing in books, is, to walk them through in a way there is absorption. So once they have done it, they say, aha, now I see why this is being done this way, and how I can benefit from it. And one of my goals really, genuinely is, I don't want people to walk away saying, this is weird. I want them to walk away saying, oh, I see why this is being done this way. And I can see how I can benefit from it, rather than being tripped by it in accidental usage. So I hope that comes out in the book. And that's kind of what I really tried in terms of not only organizing the structure, but in terms of the depth we go into each of the topics as well.

Alina Yurenko: I really appreciated the level of depth in the book. And since you mentioned records, I wanted to mention that as well. So you go in details about how records are even implemented in Java and things that you need to know before you start working with them. They might seem very simple, and like developer friendly and oriented on the first surface, and they definitely are, but there is so much to know about them. And it's very interesting how they're implemented in Java. And you even talk, like, for this feature but for other features, you also bring up the performance aspect. So give a user a few ways to do things. And then you tell which one will be, you know, a better maintainable, better readable code, but also which one will perform the best. So I really appreciate that in the book as somebody working on a compiler, I care about performance a lot. So that's also a very nice angle and a good level of depth indeed.

Venkat Subramaniam: That's one thing I really like doing as well. I hope they don't overdo it, but in places where it actually makes sense, I like to tear apart and look at the bytecode. And to me, part of the reason I like doing it is, it really provides the developers with fact to remove the concerns of performance, potentially, for example. So when they look at what it looks like in the bytecode, they're like, oh, so that's the way it's implemented. So my, you know, concerns about performance may be are genuine. But they're not realistic, because they're not being done the way I would expect that to be done. Kudos to the team that has implemented this. They have done it in a really good way. And I think that is one of the things I like to do in general. And I do this when I teach classes to clients as well.

When developers ask questions on, "Oh, my gosh, how is it going to work? Oh, let's tear this apart." I was doing this last week, and to bring up Java P and look at the bytecode and show how things are being done. And you can see the developers reaction to it. They're like, "Oh, now I see exactly what's sitting in there. I thought it's the way this works. But this shows it's not the way." And it also gives them a tool to go explore on their own, which is the most important thing, right? Whether a training class or a book, is not going to stay with the developer beyond the time that they're going to explore it. But if we can give them a few tools for them to explore on their own, then... It's like that story of give them a fish versus teach them how to fishing. That's one of the, you know, objective here, is to show a few tools in which they can then use those tools to explore further based on their curiosity. And that's one of the things I like about developers, right? We are, by definition, by nature, very curious people. So we have these concerns, but we want to poke in and see how things actually work. And the fact that we are able to look at these is just absolutely rewarding, in my opinion.

Alina Yurenko: I 100% agree with you. It's also my observation from talking to developers and speaking at conferences, that you can talk to people about how to do things, but also you can show them how they work under the hood. And, you know, you might assume that this is not interesting for people because this is not necessary, things just work, right? But people are so often curious, because indeed, we are curious about those things. So every time I show something under the hood, I can see people's eyes lighting up, they're taking photos, they're taking notes. Because it's very interesting to know and understand why things work a certain way. So 100% agree was that. Okay, let's look at what's next in the book. So we talked about that. And then you're talking about switch expressions and pattern matching. And it looks to me that in the book, the possibilities are endless there. Because especially if you combine those two features together and add even more, then there's so much you can do rather than using one of those features isolated, right? You give some really great examples about how you can use multiple features to write even better code. That's really great.

Venkat Subramaniam: Yep. And the exciting part is where they actually come together. And this is, again, I would give credit to how the evolution of Java is. Java did not evolve as a way that you kind of look at this and say, these are a bunch of sticks sticking out in different corners, right? It really is where you got all these features, but they all come nicely together. That cohesiveness is very important as well. Sometimes you're using a library, or a API, or even a language, and you're like, I'm using this, and I'm using that, I'm using this. There's no connectivity between them. And that's what I really like about this is, it nicely flows through. I learned this, I learned this. Oh, but wait, they actually can come together.

There's also fun because a lot of times, when developers are learning this, they say, "Well, wait a minute, but you said we can do this, and you said we can do that. But can I do them together?" And you're like, "Yeah, Java has been thinking like you're thinking." Right? And that's the really nice feedback to see that the language evolution is in line with how somebody would actually apply these things in production. And that's what I really get excited about is, that all these are coming together to support you, rather than pulling you in different directions.

Alina Yurenko: For sure. And when you come to talks of people who work on Java, the language and the platform, and you listen to how they work and all those things, there are so many things they consider, right? They might not be obvious to you as a user, but when you listen to them working on those things, it's impressive. And, you know, there is so much respect to what those people do, and all the things they need to consider. It's really impressive.

Venkat Subramaniam:That's one of the reasons why it's also exciting to go back and ask the question, why is this implemented this way? And, you know, if we ask that question why, I think we are a lot more receptive to understanding the nuances in the language. Otherwise we get frustrated. We say, "Oh, this is silly, or that's silly." But when we ask the question why, and we then begin to realize they just didn't throw things together, they've gone through a lot more deeper thinking than a normal programmer would do. And you have a better appreciation for those things as well. And the more appreciation you have for the language, the more respect you have for the language that you use as well and the way it serves you. So I think that that's important to focus on, as well as we are learning the language is to develop the, you know, respect and look in the nuances, and ask the right question, I think is important.

Java's Potential: Records, Optimizations and Synergies

Alina Yurenko: For sure. And I'm going through your book next. So the next chapter that you have there is about modularization. And how we can use modules to write applications that are more secure, that manage our dependencies better, have better encapsulation. And what I also like about the chapter is how there you show a very comprehensive picture of why we need to do things a certain way. And you appeal to developers, and architects, and even DevOps teams, and trying to show all the different angles and address all the different concerns that those groups of people can have, and how modules can help us address all those concerns and make a better decision. I really like that comprehensive approach to describing this module.

Venkat Subramaniam: I do have to says a lot of thanks to Alex Buckley. He was extremely helpful in thoroughly reviewing the chapter. So I couldn't have done it without his help. One of the things I really wanted to say in the chapter was, and I sincerely mean this, if you talk to a wide range of Java developers, most of them don't use modules. And a lot of them don't want to use modules. So one of the analogies I make in the book is, the concept of modules is like parenting. You're not going to appreciate parenting when you're a child, maybe decades later, right? You look back and say, "Thanks, mom," or "Thanks, dad. And you say, you know, thanks for taking all that effort that you put in. And that's kind of what I feel about modules. We don't like it today. But I have a feeling that in the long run, we're going to have a renewed respect for modules when we start actually benefiting from it.

And a lot of us have been introduced to modules as this burdensome process. Oh, my gosh, I got to do all of this now to use modules. But if we take the route of asking the question, "Why should I use modules? What are the benefits am I gonna get?" And that's kind of what I hope I've done in the book is, in the beginning of the chapter, is to really ground that, right? Let's not worry about creating modules yet. Let's focus on why you want to create modules. How are you going to benefit as an architect? Or how are you going to benefit as a developer who is answerable code you're writing in a company? How are you going to be responsible as a company to answer to your clients when there is a security issue that arises? How quickly can you give me a listing of modules you're using? How can you... The key word is encapsulation. We talk about encapsulation so much in object-oriented programming. And yet, we don't have good encapsulation at our module levels. And modularization truly brings encapsulation to the table.

So once we start thinking about these things, if I'm a practicing architect, if I realize these are the benefits, I would be viewing about modules very differently for my organization, than if I look at module as a mere implementation detail. So that is the key here, is, don't look at modules as an implementation detail, look at module as an architectural characteristics, then it changes the way you look at it, changes the way you would apply it as well.

Alina Yurenko: Sounds very exciting. And I hope more developers will share your excitement after reading the book. I have no doubt. Thank you.

Mastering Java's Modern Landscape: A Practical Guide for Developers

Alina Yurenko: I also wanted to ask you, so what else do you want to write about in this book? So do you have any new ideas? What else is there to come for this book? Can you tell us, please.

Venkat Subramaniam: So one of the journeys I took on in this book is to really talk about the evolution of Java. And of course, Java has been evolving at a rapid pace. And I'm very thankful and grateful for that. But that also brings up a challenge. And that is, by the time I've been writing these chapters and putting them out into better releases, Java has been moving also. So the challenge for me is to keep the book updated with the evolution of Java as it is evolving. So I'm working on going back to the chapters, and looking at places where there have been changes in Java related to the features I've already written. So that's one thing I'm doing. But the second thing I'm also doing is this new idea that Viktor Klang has been working on, which is the gatherers. And so I'm focusing on, you know, on gatherers as well. And I've got some ideas on how gatherers can actually help us. I've been programming with functional style in Java for a few years now. And there are times when I sit there and say, "I really wish Java would do this."

Well, thanks to his effort, with gatherers, we can actually do that ourselves. And that's what I'm going to show in the book, is how we can use gatherers to really push the boundaries of the functional style and benefit from that. And honestly, that's the kind of stuff I get excited about. And I'm really looking forward to write that in the next couple of days. And that's going to be the next beta that when we release it, is going to have something related to that with other improvements, as well. So it's coming, you know, soon, within the next few weeks, I would say.

Alina Yurenko: Sounds really exciting. And as you brought it up, I also wanted to ask you, I'm not sure it's been possible to answer a question. But if there is, I don't know, one lesson or a few lessons that you want people to get from the book, or how do you want them to use this book ideally in their everyday life. So if you can answer that question at all, what do you want people to learn from it in the end and apply practically?

Venkat Subramaniam: Honestly, the thing I want them to learn from the book is, how amazing it is to actually see the language actually evolve. And so, the focus, I think, honestly, genuinely for me is, is the language and not the book. And my excitement is in the evolution of Java. And that's the excitement I want to share with the readers, is to say, you know, Java is evolving. And honestly, I was that guy on the other side of the picket line, constantly complaining that Java is not moving forward. And now that Java is moving forward, it would be a disservice on my part, and maybe bigotry on my part, to not really praise Java when it deserves the praises, as I was really complaining about it years ago or decades ago. So the point really is, it is evolving. There are some really amazing things in there. And I hope this book gives you a handle into how you can actually make use of those amazing features.

The book is going to be short lived on your hands, but the language is going to be long lived in your application. That's the lesson I want people to take. Use this as a ladder, it's going to take you to the next floor, but there's amazing party in that other floor once you climb up. And I hope this helps you to get there, so you can enjoy and have a good time at the party that you would join in celebrating these features and how to apply them. That's what I want to have as a message.

Alina Yurenko: That is so inspiring. I have read the book already. And I'm still so inspired to read it again, just because of the way you talk about it. It's so great. So, yeah, you're talking about all these more modern features. And it makes me think of the way Josh Long always says, there has never been a better time to be a Java developer, right? There's all these new features come out. And it's indeed so exciting.

Venkat Subramaniam: Totally. Totally. And that's what I love about the language is, they didn't sit there and say, we want to change the language, right? Because if their goal was to change the language, it would have been a disaster. Instead, they've been really working hard, asking the question, what can we do involving the language where it makes the life of the developers better and richer? And that's why this has been a very deliberate, and sensible, and thorough effort in evolving the language. And so, this is definitely not a movement, it is an improvement. And that is why this is genuinely useful, is because the people behind it have spent a very decent amount of effort. And if I can use the word with all sincerity, I would say, they have evolved Java responsibly. That's what I like about the evolution.

You know, things change. But a lot of times, people can change things irresponsibly. They could be disruptive. They could break things. And they could do things for the sake of changing it and showing that we can change. But the developers behind the language have been evolving it responsibly. And it's great for us to be able to use that and enjoy that for applications. So that's where my respect and genuine excitement comes, because it is something that deserves to be brought to light. And I hope I played a very small part in bringing that to the limelight for others to really see it, if they couldn't see it in other places already.

Alina Yurenko: No, for sure. Thank you for this amazing contribution to the Java community. We all appreciate it a lot. So let's talk about where we are now. And I want to ask you one last thing. So if you could imagine, you know, in five years, maybe from now, what will be our life as Java developers. So what kind of applications we will be writing, which features maybe we will use the most, will we still use AI or not? So can you maybe fantasize just briefly about what do you think the future is like for us?

Venkat Subramaniam: The honest answer is, I have no clue. And five years is a short time and a long time, at the same time in our field. Because some things change rapidly, some things take time to change. And I think, genuinely I say this, I'm one of those people who is upbeat and very positive about AI, but not for the reasons a lot of people are today. I'm not positive about AI for what it is doing today. But I'm really positive about AI for what it would eventually do for us. And I truly believe that AI can be a really, really good vehicle that gets us safely and fast to where we want to go. So I look at this as a phenomenal augmentation tool more than anything else. So I think it's going to definitely influence us, but not in the way that we are seeing right now. It's going to be different. The Java language itself is changing. And we're going to see that really continue to evolve and continue to prosper. But honestly, we have been in somewhat of a stagnation in terms of the architectural capabilities, if you will. We had desktop applications. We had console application. I started programming on VT100 terminals back in time. And we then of course, had, you know, a graphical user interfaces, Windows, and I remember Windows 3.1, for example, right?

And then we saw, you know, desktop applications, then we saw mobile applications. The question really is, what's next in terms of the architectural capabilities in terms of how humans would interact with these machines? We're talking about, you know, devices that are AR devices, and how we can communicate and work with them. Speech recognition. So there's so much happening besides just AI alone. And how are we going to start programming for the next generation of these applications? I have more questions to your question than answers, because I think that's the excitement of the future. I think it would be naive for me to pretend that I know the answer. So the honest answer is, I don't know the answer, but I can bet you, I have a lot more questions, and I'm as excited about them as anybody can be. So I'm looking forward. And maybe you and I can talk in five years. And we can talk about, you know, how things have evolved, and how we have been adapting. But time will tell.

Outro

Alina Yurenko: Sounds amazing. And yes, it could be very exciting to, you know, be surprised and find out what happens next. So, okay, to wrap this up, is there any place where people can, you know, check the book, or follow the updates, or, like, what people need to do if they want to read your book as well.

Venkat Subramaniam: I would say there are two places to go get the book. And thank you for that. One is the Pragmatic Programmers website, pragprog.com. And they can get the book right there as a beta right now. So they don't have to wait for the book to be released. They can start reading it today. And every update, they will continue to receive it. But if they really would like a paper copy and wait for it, that's perfectly fine as well. They can get that from pragprog.com also. Or eventually, they can get it from Amazon or any other booksellers that they have access to. So those are the two places that I would go to.

Alina Yurenko: Sounds amazing. Cannot wait to get a paper copy, and I'm sure it will be a huge success. Thank you so much for this conversation.

Venkat Subramaniam: Thank you so much, again, to you, for, you know, hosting this, and being such a wonderful person to talk to. I really appreciate it. And also to my friends at GOTO. They've been amazing. Of course, I would say for those listening, please go check out GOTO and all the amazing conferences they are running as well. And thanks to GOTO Book Club for organizing this as well. I'm very thankful, very grateful for this opportunity to talk as well. Thank you so much.

Alina Yurenko: Thank you.