Disclaimer: This post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about Writing for Developers by Piotr Sarna and Cynthia Dunlop from Manning.

I started my blog as a hobby seventeen years ago, in April 2008. At the time, I had no clue about technical writing. I'm pretty sure it was not even a thing back then: the only content aimed at developers was technical documentation. Since then, the landscape has changed a lot, to the point that companies hire for technical writer positions.

I was curious to compare what I learned by doing to the structured approach of a book. I ordered the book last year when it was still being written. It was published only early this year, and I was already reading (and reviewing!) DuckDB in action. I put it on the top of my reading pile list; I finally finished it: here's my review.

Facts

• 17 chapters, divided into four parts
• 2 appendices
• 345 pages
• $39.99 (eBook)

Chapters

Part 1 - Fundamentals

1. Why write
2. What to write
3. Captivating readers

Part 2 - Nailing the writing process

4. Creating your working draft
5. Optimizing your draft
6. Getting feedback
7. Ship it

Part 3 - Applying the blog post pattern

8. The "Bug Hunt" pattern
9. The "Rewrote It in X" pattern
10. The "How We Built It" pattern
11. The "Lessons Learned" pattern
12. The "Thoughts on Trends" pattern
13. The "Non-markety Product Perspectives" pattern
14. The "Benchmarks and Test Results" pattern

Part 4 - Promotion, adaptation, and expansion

16. Getting attention
17. From blog post to conference talk
18. So you want to write a book

Pros and cons

• In the first chapter, the authors list the most common reasons developers mention not to write posts. I have heard many of these reasons and can confirm their existence. Then, the authors address each of them and provide multiple counter-arguments.
• Part three is dedicated to blog post patterns; each chapter describes a pattern in detail. Reading this made me realize that most blog posts fall into a specific and easily identifiable category. The authors structured each pattern-chapter into the following sections:
  • Purpose: what's the idea (or ideas) behind the pattern
  • Audience: who does the pattern target
  • Examples: a couple of existing blog posts that embody the pattern
  • Characteristics: common traits found among the posts of this type
  • Dos and don'ts

  I do love typologies, and I found this breakdown very useful.

• I found part four less relevant, especially since cross-posting has been part of my workflow for ages, and I reuse writing content for conference talks. If you never considered these options, you'll benefit from these chapters.
• The only con I found is that the authors remind us that you should ask your company before you reveal trade secrets. I understand that you would like to warn people, but when it's repeated several times throughout the book, I got the feeling they're writing to dummies–not something I'm fond of.

Summary

If you're a technical writer, a Developer Advocate tasked with technical writing, or a regular developer who wants to start a blog or contribute to a company blog, I recommend getting this book.

The exhaustive description of common patterns is a huge asset for beginning writers and can help even seasoned ones.

Originally published at A Java Geek on May 25^th, 2025

The post Book Review: Writing for Developers appeared first on foojay.

An Author Who Understands Both Sides

"Raising Young Coders: A Parent's Guide to Teaching Programming at Home" by Cassandra Chin is an invaluable resource for parents seeking to introduce their children to the world of technology in a fun, accessible way.

As a young computer science student who has been teaching kids' programming workshops since age 14, Chin brings both technical expertise and genuine understanding of children's learning styles to this comprehensive guide.

Inspiration Over Intimidation: A Refreshing Approach

The book stands out for its refreshingly approachable philosophy: inspire children about technology rather than force them to learn programming languages prematurely. Chin wisely advocates for starting with age-appropriate projects that emphasize creativity and hands-on learning.

The projects range from simple squishy circuits for preschoolers to more advanced Python programming on Raspberry Pi for teens, with clear instructions for each age group. This thoughtful progression ensures children can build confidence at their own pace.

Addressing Gender Diversity in Tech

What makes this guide particularly valuable is its emphasis on inclusivity, specifically addressing the need to encourage girls in technology. Chin provides compelling statistics about gender disparities in tech and offers practical strategies to overcome cultural biases that discourage girls from pursuing STEM fields.

The final chapter featuring interviews with five successful women in tech serves as powerful inspiration for young girls considering technology careers. These role models demonstrate that technology is for everyone.

Well-Structured, Progressive Learning

The technical content is exceptionally well-organized, with projects progressing logically from basic circuits with play dough to block coding with Lego robots and finally to Python programming. Each project includes detailed materials lists, step-by-step instructions, and troubleshooting tips.

The book doesn't just teach coding; it teaches problem-solving, creativity, and persistence through engaging projects like building dancing crabs and LED paper fish. These hands-on experiences make abstract concepts tangible and exciting.

Building Family Connections Through Technology

Parents will appreciate Chin's practical advice on integrating technology learning into family life without overwhelming children or competing with other interests. The author's emphasis on spending quality time with children while learning together, rather than pushing for academic achievement, makes this book both a technical guide and a resource for strengthening parent-child relationships.

Whether your child is just beginning to explore technology or ready for more advanced programming, this book provides a solid foundation for fostering lifelong interest in technology.

The post Book Review: Raising Young Coders appeared first on foojay.

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about DuckDB in Action by JoMark Needham, Michael Hunger, and Michael Simons from Manning.

The book was sent to me by Michael Simons. He asked for my feedback: I changed my reading schedule, took a few months, and here it is.

Facts

• 10 chapters
• 288 pages
• $33.59 (eBook)

Note that MotherDuck, the company behind DuckDB, offers a free PDF copy.

Chapters

1. An introduction to DuckDB
2. Getting started with DuckDB
3. Executing SQL queries
4. Advanced aggregation and analysis of data
5. Exploring data without persistence
6. Integrating with the Python ecosystem
7. DuckDB in the cloud with MotherDuck
8. Building data pipelines with DuckDB
9. Building and deploying data apps
10. Performance considerations for large datasets
11. Conclusion

The book takes a step-by-step approach, starting from the basics of DuckDB and SQL.

Pros and cons

After the mandatory section about introducing DuckDB and installing it, the book explains SQL. At first, I admit I thought that the book was for newbies, as it explained things as simple as JOIN. However, the chapter afterwards explained Common Table Expressions and built complex queries upon them.

I like how the authors describe DuckDB in its "natural environment", i.e., how it integrates into different ecosystems, such as Python's Pandas and Apache Spark. In addition, a complete appendix section focuses on DuckDB in Java. Finally, the authors dedicate a section to MotherDuck, a DuckDB cloud provider.

Conclusion

My thoughts on the book are a bit divided. On one side, it tries to explain DuckDB itself and its integration in different environments. On the other hand, it teaches regular and advanced SQL, which users of an SQL database product should know IMHO. The book can't decide between a Learn SQL with DuckDB approach and a DuckDB in Action one. The role of a book editor is to help authors make hard decisions. It feels as if this one didn't want to stop the authors' enthusiasm and couldn't bring themselves to rein them in.

Don't get me wrong: the book is great and can teach you a lot, but it could have been better with more focus.

Originally published on A Java Geek on November 2^nd, 2024

The post Book Review: DuckDB in Action appeared first on foojay.

Let me share a personal story. I started experimenting with Java on a Raspberry Pi about five years ago and blogged a few articles about it. But the more I experimented, the more I wrote down, and eventually, I had written a book… I worked on it for six months in a row, every evening and a lot of weekends. But the moment I received the box with my author copies was an incredible feeling. Holding a paper book with your name is a special moment.

Fast forward to now. The 1000 paper copies are sold out. I have the last 10 copies in case you still want one But as I self-published the ebook, it's still for sale on Leanpub, and I keep updating it. That's one of the first significant differences between publishing a paper book and an ebook…. As an author, I got about 2 euros per paper book from the publisher, and LeanPub pays 80% royalties. Don't forget that I have to pay taxes on what I earn. So, if you do the math, you'll understand that the book didn't make me rich. But yes, it helped me in my career and was one of the reasons I became a Java Champion. So, we can argue about the "becoming famous".

But that's only my story. I invited several guests to share their knowledge about book writing:

• Marián Varga is finishing a book and tells about publishing a book with a publisher.
• Wim Deblauwe wrote a few books and has much experience with self-publishing.
• Len Epp is the co-founder of Leanpub, so he can tell us a lot about ebooks.
• And we start with Trisha Gee, who wrote a lot of books!

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guests

Trisha Gee

• https://www.linkedin.com/in/trishagee/
• https://jvm.social/@trisha_gee
• https://bsky.app/profile/trishagee.bsky.social
• https://x.com/trisha_gee

Len Epp

• https://www.linkedin.com/in/lenepp/
• https://bsky.app/profile/lenepp.bsky.social
• https://x.com/lenepp

Wim Deblauwe

• https://www.linkedin.com/in/wimdeblauwe/
• https://bsky.app/profile/wimdeblauwe.com
• https://www.youtube.com/@WimDeblauwe
• https://www.wimdeblauwe.com/
• https://www.widit.be/

Marián Varga

• https://www.dastalvi.com/book/
• https://www.linkedin.com/in/mari%C3%A1n-varga-4869a042/
• https://mastodon.social/@mrvarga

Links

Book by Frank

• https://webtechie.be/books/
• https://leanpub.com/gettingstartedwithjavaontheraspberrypi/

Books and links by Trisha Gee

• https://trishagee.com/books/
• https://trishagee.com/2022/12/12/tools-and-processes-for-collaborating-on-a-book-remotely/
• https://trishagee.com/2022/12/01/writing-a-book-is-hard/
• https://medium.com/97-things
• https://youtu.be/RzaNJzz5jW8
• https://learning.oreilly.com/search/?q=trisha%20gee&rows=100&language=en&language=es

Books by Wim Deblauwe

• https://www.infoq.com/minibooks/spring-boot-api-backend-version2/
• https://www.wimdeblauwe.com/books/modern-frontends-with-htmx/
• https://www.wimdeblauwe.com/books/taming-thymeleaf/

Book by Marián Varga

• https://www.dastalvi.com/book/
• https://bsky.app/profile/love2integrate.com

Leanpub

• https://www.youtube.com/leanpub
• https://twitter.com/leanpub
• https://mastodon.social/@leanpub
• https://www.instagram.com/leanpub
• https://bsky.app/profile/leanpub.bsky.social

Lulu

• https://www.lulu.com/

Content

00:00 Introduction of the topic and guests

01:53 Books by Trisha Gee
02:24 Trisha's motivation for writing books
04:13 Difference between publisher and self-publishing
09:53 Publishers are looking for authors and course creators
12:55 How long do you work on a book?
17:35 Can we expect a new book by Trisha?
21:00 Automating the writing process

24:50 Len Epp about Leanpub and how it started
27:18 On Leanpub, you can publish a book-in-progress
27:51 Different publishing processes with Leanpub
30:20 You can use LeanPub to generate your book, but you don't need to sell it on Leanpub
32:57 80% of the selling price goes to the author
40:09 How to market your book
45:35 Let an expert handle the payments...

50:55 Books by Wim Deblauwe
51:45 Wim's motivation for writing books
53:15 Earning back the time spent on the writing
54:37 How to sell paper books on Lulu
57:19 Tools used to write a book
58:34 Wim's author-plans for the future
59:42 How the books influenced Wim's career

01:00:02 Marián Varga about the topic of his book
01:03:07 Current status of the book
01:04:03 The book is a teamwork with a publisher
01:07:06 Organizing the work between multiple authors
01:09:17 Time worked on the book
01:10:40 Feedback from the community for the content
01:12:13 What Marián wants to achieve with the book

01:14:38 Conclusion

The post Foojay Podcast #67: Writing a book. Does it make you rich and famous? appeared first on foojay.

Otávio Santana's "Mastering the Java Virtual Machine" takes readers on an insightful journey through the inner workings of the JVM. As I read this book, I found myself reconnecting with the fundamentals of Java programming while also discovering new depths of understanding.

The book strikes a perfect balance between nostalgia and innovation. It reminded me of my early programming days, while also introducing cutting-edge concepts that are crucial for modern Java development. Santana uses clever technical metaphors to make complex JVM internals more accessible, bridging the gap between theory and practical application.

For both new and experienced developers, this book offers valuable insights:

• This book provides a comprehensive look at JVM architecture and performance optimization.
• This book allows seasoned developers to revisit core concepts with a fresh perspective.
• This book introduces newcomers to the intricacies of the Java platform in an approachable way.

As we explore the details of "Mastering the Java Virtual Machine" in this review, prepare to enhance your understanding of Java, challenge your existing knowledge, and gain practical skills for optimizing JVM performance.

Title: Mastering the Java Virtual Machine
Author: Otávio Santana
Genre: Technical Fiction

Mastering the Java Virtual Machine

Summary of Each Section

Part 1: Understanding the JVM

In Chapter 1, he primarily discussed the evolution of Java, introduced the JVM, and explained how the JVM works internally.

In Chapter 2, he explained how to decode class files, understand class file headers, fields and data repositories, and use Java class file methods.

• In the Java Virtual Machine (JVM), developers consider class file structure critical, which leads to byte code dancing, constant pools, and class loading.
• While decoding class files, he explains the conversion of Java Source -> Java Compiler -> Class file, where the Class File structure contains important details magic, Minor Version, Major Version, Constant Pool Count, Access Flags, Interfaces, Fields, Methods, and Attributes.
• He also explains how the class file structure encapsulates vital information about the return types, access modifiers, and parameters, which guides the JVM to execute code dynamically and efficiently.

In Chapter 3, he explores Bytecode, Arithmetic Operations (Addition, Subtraction, Multiplication, and Division), Value Conversions, Object Manipulation, and Conditional Instructions in depth.

• ByteCode Instructions demonstrate how arithmetic and comparison operations function properly, how various method calls perform datatype conversions, and how the JVM coerces objects for Set and Get fields. The JVM primarily operates within two fundamental categories: 1. Primitives; 2. Reference Values.

Part 2: Memory Management and Execution

One of the most important aspects for developers and architects is optimizing the application's memory management.

In Chapter 4, he explains the foundations of executions, discusses various system operations layers involved (Like Applications, System Operations, Instruction Set Architecture, and Hardware), decodes JVM execution which he discussed about steps involved for execution, covers Just-In-Time (JIT) compilations, and unravels Class Loading concept.

In Chapter 5, he enthralled readers with very important topics such as how memory management in the JVM affects the entire lifecycle of the Java Application, including memory components like the Method Area, Heap, Java Stacks, PC Registers, and native method stacks.

In Chapter 6, he provided readers with an overview of garbage collections and algorithms, explaining how they work, the differences between algorithms, how we can configure GC for our applications, and recommending correct algorithms and configurations. And also discusses JVM tuning and ergonomics for achieving optimal performance.

Part 3: Alternative JVMs

In Chapter 7, he explains how achieving performance and efficiency through Oracle Labs' new architecture, GraalVM, is important. He highlights its features and clarifies the role of JVM internals.

• When developers create cloud-native applications, they must optimize applications for efficient memory and resource utilization, especially during compilation.
• By leveraging GraalVM's transformative capabilities, you can learn to create Native Images with a high-performance compiler and understand the relevance of the AOT compiler.

In Chapter 8, he explores the gallery of the great JVM ecosystem and alternative JVM implementations, highlighting their significance in various use cases such as Eclipse J9, Amazon Corretto, Azul Zulu and Zing, IBM Semeru, and Eclipse Temurin, before he moves on to JVM vendors and SDKMan.

Part 4: Advanced Java Topics

In Chapter 9, he explains the importance of Java Framework Principles and how they contribute to API Design, the preference for convention over configuration, and the importance of documentation and testing. Furthermore, he discusses how these principles help developers create robust, tailor-made frameworks that embrace Java Standards and Best Practices.

In Chapter 10, he discusses the importance of the Reflection API tool, which enables developers to access the inner workings of Java programs. He also explains the role of reflections in Dependency Injection (DI) Containers, Object Relational Mapping (ORM), testing frameworks, serialization and deserialization libraries, and Dynamic Proxies tools. These tools allow developers to create objects at runtime, implement one or more interfaces, and interpret method invocations.

In Chapter 11, he captivated readers by showcasing the art of code generation, from annotated classes to dynamic metadata, using the Java Annotation Processor to demonstrate the transformative power of automation.

In the final chapter, Chapter 12, the author focuses on topics such as the JVM landscape, how to navigate the system operation architecture, and how to become a master of garbage collection. Finally, he explains the importance of the Virtual Threads feature introduced in JDK 21, as well as the distinction between platform threads and virtual threads.

Conclusion

"Master the Java Virtual Machine" offers an unparalleled deep dive into the JVM's inner workings. Its comprehensive coverage of both foundational concepts and cutting-edge features makes it an invaluable resource for Java developers looking to elevate their understanding and skills.

The book excels in:

• Providing a clear progression from basic to advanced topics
• Offering practical insights that directly apply to real-world Java development
• Covering emerging technologies and trends in the Java ecosystem

By mastering the concepts presented in this book, developers will be better equipped to:

• Write more efficient and performant Java code
• Debug complex issues at the JVM level
• Make informed decisions about JVM configuration and alternative implementations
• Leverage advanced features like reflection and code generation using Java Annotation Processor effectively

Recommendation

I strongly recommend that whether you're a novice, experienced, or seasoned Java developer, you read the book "Master the Java Virtual Machine." It will certainly help you enhance your knowledge of JVM internals, and after reading this book, you'll definitely notice a significant difference in your understanding of the JVM.

The post Book Review: Mastering the Java Virtual Machine appeared first on foojay.

That is why in this post, I am going to ask for your help!

We have created a survey that aims to provide insight in how organizations, IT departments and teams are dealing with topics around green computing and sustainable software development.

Now we just need a lot of people filling out the survey and providing us with that data. E

ven you or your organization does not do anything, we still want to ask you to fill in the survey, because that is also a valid outcome.

The survey is anonymous and it is in no way passing any judgment to anyone. You would be of immense help if you fill out the survey and share it with as many people as you can.

You can find the survey here.

The post Sustainable Software Engineering: Input Requested! appeared first on foojay.

For a personal pet project, I started experimenting with JavaFX and Kotlin to create a user interface with a lot of Java / Kotlin background processing. As I knew there is a book available on this specific topic, Apress was so kind to send me a review copy of Frontend Development with JavaFX and Kotlin: Build State-of-the-Art Kotlin GUI Applications by Peter Späth (152 pages, 48€ on paper, 35.5€ for ebook on Amazon.nl).

Content

I received both a PDF and paper version of the book. The biggest difference is full color (PDF) versus black-white, which is unfortunate for a book about user interfaces with IDE and other screenshots.

Chapter 1 - Getting Started

The book starts with an introduction to JavaFX and how it can be combined with Kotlin. A "Hello World" application is created with Gradle, Eclipse, IntelliJ IDEA, and Visual Studio Code. The author explains how to install Oracle's distribution of OpenJDK, but if you know me, you'll understand I would recommend other distributions...

Immediately, a nice example is given of the reduced amount of code that can be achieved with Kotlin, with a minimal example of a button with a click handler. This is the typical Java code:

Button btn = new Button();
btn.setText("Say 'Hello World'");
btn.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("Hello World!");
    }
});

In Kotlin, the same can be achieved with:

val btn = Button().apply {
    text = "Say 'Hello World'"
    setOnAction { _ ->
        println("Hello World!")
    }
}

That's a reduction from 222 to 120 characters!

Other topics handled in this chapter are Kotlin utilities for JavaFX and direct downloads of JavaFX releases from openjfx.io. The author also explains why FXML is not used in the book. I agree with his view that the XML files are not as dynamic as code and bring a mix of technologies into your project.

Chapter 2 - Properties

This chapter explains Properties, Bindings, and Observable Collections (with FXCollections). You can use these to connect data and values (model) to JavaFX components (view).

Chapter 3 - Stages and Scenes

Explanations of how you can read which physical screens are connected, what the difference is between Stage and Scene, and how you can create an application with multiple windows. Adding keyboard shortcuts, changing which node has the focus, node lookup, creating snapshots (screenshots), handle key presses and mouse events,... are all described in this chapter. Additionally, the Camera and 2D/3D are mentioned without more info, so the writer assumes you already have knowledge about this.

Chapter 4 - Containers

In Chapter 4, you'll learn how to use different panes (or containers), such as StackPane, VBox, HBox, GridPane, BorderPane, etc., to add components to your application and how to style these panes.

Chapter 5 - Visual Nodes

While the previous chapter dealt with the nodes that are used to group and lay out other nodes, this chapter deals with the visible nodes that eventually can also handle user interaction. It starts by describing the different ways of using a node's bounds to prevent them from overlapping.

Different types of visual nodes are described separately:

• Shapes: to show something but can't handle user input. For example: Text, Rectangle, Circle,...
• Canvas: to access the graphics system (without containers).
• Image: to place an image using the ImageView.
• Controls: nodes that accept user input. For example: TextField, TextArea, Button, Menu,...
• Control panes: panes (or containers) with some kind of user interoperability. For example: Accordion, ScrollPane, TabPane,...

Chapter 6 - List and Tables

Lists, tables, and trees are a bit more complex and handled in a separate chapter. I always struggle to remember how you can create a custom view for an object in, for instance, a table, and this chapter gives a clear example of how to visualize a Person object's first and last name into a single ListView item. A perfect reminder of how to convert any object to a list node. By further extending that Person object with properties, an example is also given of a table with editable values, also with an example of a DatePicker cell.

Chapter 7 - Events

Events are used in JavaFX to inform occurrences of interest to all parts of the application. This happens in two different directions, something I wasn't aware of. Event Filters must be used if your code must be invoked in the capturing phase (from the highest level to the component with the event). Event handlers must be used in the bubbling phase (from the component with the event to the highest level). This chapter gives a full overview of all the available types of events.

Drag and Drop Procedures are also described here as they rely on event handling.

Chapter 8 - Effects and Animations

Although less used in business user interfaces, effects and animations are also part of JavaFX's core functionalities. Effects can be used on, for instance, images and text to change colors, or add blur, shadows, lighting, etc. With animations you can change the effects, position, and size of a node over time, using different types of transitions and keyframes.

Chapter 9 - Concurrency

A user interface always needs to be "snappy" and react immediately to any user input. That's why business logic (happening in Java) and user interaction (with JavaFX) must happen in separate threads. In Chapter 9, the JavaFX Concurrency Framework is explained. With Service and Task, you can achieve such separation between long-running tasks and not blocking the user interface. This is demonstrated with an application with a Slider which progress is changed from a Task with Thread.sleep.

A short starting point is given about Kotlin Coroutines, which provide a new concurrent programming approach. This is explained with a quick example in which intermediate results of an ever-running PI calculator are displayed.

Sources of the Examples

In a few places, a link to the sources of the code examples in the book is given, but these seem to be wrong (there is even a remaining "TODO" about this on page 18). The book's sources can be found here: github.com/Apress/Frontend-Development-with-JavaFX-and-Kotlin.

Conclusion

I'm probably a bit old-fashioned, but I still prefer paper books. I'm always disappointed that publishers still print this kind of book in black and white. Screenshots and effect examples are so much clearer when you check the ebook version, which has these images in full color. As there are only a few of these images in this book, I can't understand why they were not printed in color.

This book provides a lot of information on a limited number of pages, so there are many references to websites where you can find more information. It would have been nice if a few of those had been handled more in detail, especially the Kotlin-specific parts, such as the Kotlin Coroutines.

If you are new to JavaFX+Kotlin, this book is a good starting point and gives enough examples to help you understand how to create an application and benefit from Kotlin's features. If you are new to JavaFX, I would advise you to combine it with the "JavaFX Bible" written by Stephen Chin, Johan Vos, James Weaver, and many others: The Definitive Guide to Modern Java Clients with JavaFX 17: Cross-Platform Mobile and Cloud Development (635 pages, 63€ on paper, 44.3€ for ebook on Amazon.nl). BTW this book is printed in full color!

The post Book review: Frontend Development with JavaFX and Kotlin appeared first on foojay.

This is part 3 of the JCON interviews.

Frank meets Otavio Santana, who recently wrote the book "Mastering the Java Virtual Machine." At JCON, he talked about the persistence layer and how you can evolve your career.

You'll also learn more about Jakarta EE, GlassFish, and a PET project with messaging via Telegram.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

00:42 Otavio Santana: Book Author, Talks about the persistence layer and evolving your career thanks to open-source.
https://www.linkedin.com/in/otaviojava
08:44 Arjan Tijms: Jakarta EE, Eclipse Foundation, Which version of Java to use 
https://www.linkedin.com/in/arjan-tijms-1214aa1b1
17:08 Ondro Mihalyi – Jakarta EE, Eclipse GlassFish, Creating small Java applications, Edge devices 
https://www.linkedin.com/in/mihalyiondrej
24:09 Buhake Sindi – Talks about Jakarta EE in the cloud, Comparing Jakarta EE to other frameworks, Java community in South Africa 
https://www.linkedin.com/in/buhake-sindi
31:50 Patrick Baumgartner – Swiss community, Talks about a PET project with messaging via Telegram 
https://www.linkedin.com/in/patbaumgartner

The post Foojay Podcast #51: JCON Report, Part 3 – Persistence, Evolving your Career, Jakarta EE, GlassFish, Messaging via Telegram appeared first on foojay.

That’s the question Steve Poole and Olimpiu Pop embarked on to respond. And, what better way to achieve it than to tap into the best resource Java has: its community!

We(all of us) will write a book in an era when you ask and the AI assistant answers. A community crowd-sourced book to show you the track on how to become the expert you always wanted to be.

The book will be a series of practical advice - real recipes on mastering a trade of the development flow. We will look at architecture, algorithms, tooling, cloud, platforms, collaborations and more.

And because we are developers, we will do it using development practices: submit an issue and we will look to find who’s the best person to respond. Do you have somebody in mind, great! Propose her/ him too. Do you want to submit some thoughts: do a PR and we will make sure it is reviewed and then it becomes part of the knowledge base.

I know what you think: this is a never-ending story. Agree! That’s why we will have releases once a year we will have a GA version that contains the stable part of it.

And because we like to give, any money that might be generated will be donated to Foojay.

What can you do? Keep an eye out and better yet keep both of them on the site. Share this article with your network, join the conversation on the foojay slack, star and follow the GitHub repo.

The post Crowd-Publishing the 10x Java Dev Book appeared first on foojay.

price: €39.99 for the eBook
publication date: October 2023
publisher: O'Reilly Media, Inc.
pages: 99
ISBN: 9781098151249

Kent Beck, who certainly is not an unknown name in the software development world, recently published this book, which is based upon his newsletter with the same name.

In this book, which is the start of a new series, we dive into the world of tidyings which are small changes that do not alter the behaviour of our applications.

These are similar to refactorings, but smaller in scope and impact, or as described in the book "cute, fuzzy little refactorings that nobody could possibly hate on".

The "?" in the title is certainly not an error, it's not a how-to book but it offers us premises to makes us think and his insights are shared to help us define a framework.

About the book

This book is the start of a new series, and we start with tidying which he calls "the Pringles of software design" to facilitate future (behavioural) changes.

It is split into 3 sections:

• Tidyings what are they?
• Managing if & when do them?
• Theory: why should we do it?

Tidyings

Here Beck starts us of with some sample tidyings that make behavioural changes (features) in the future easier.

These small, easily reversible changes that do not need to be preemptively approved, and increase our enjoyment and productivity while coding.

We're walked through 15 examples, some of which may seem quite obvious but it never hurts to think about them, and what they actually mean.

Some examples:

• reading order
• extract helpers
• new interface, old implementation
• ...

Managing

Here we dive into the more ephemeral question of: should we tidy up, and if so: when?

Like everyone else (hopefully), I like seeing clean code. But as the saying goes "beauty is in the eye of the beholder". There is only so much time we can spend on tidying, since after all we also need to focus on the added value.

Ken Beck is not dogmatic in his opinion, and approaches these questions from a trade-off point of view and gives us possible approaches.

He provides us with insights to help us think about:

• when to tidy: before behavior changes, after behavioral changes, later, or never
• when to stop tidying
• whether or not to combine structural changes and behavioral changes
• when and how to batch

And as always align with your team.

Theory

This was my favourite section. We've diven into the what & when, but what's the why? Which is certainly a question one can expect when tidying.

Often there can be certain challenges if one cannot properly convey the reasoning for this activity, after all why are you doing this? What's the value for the product owner?

And here's where we dive into metaphors from the financial market & option trading to help explain the different offered forms of value:

• optionality
• time/value of money
• coupling & cohesion
• capability of dealing with uncertainty and change
• reversible changes
• ...

He does a magnificent job of clearly conveying these concepts, which helps us bridge certain gaps.

My thoughts

The book contains some very useful insights, and the small bite-sized sections made it an enjoyable, educative read whilst sipping some tea.

While the "what" section might contain a lot of "obvious" things, a refresher never hurts and they are always approached from multiple angles.

This also makes it an easier recommendation, compared to certain more opiniated books.

The "when" & "why" section are where the real meat was for me.

In the finalle, Ken put a lot of effort into the value (or lack thereof) of doing these changes and gives insights into bridging certain gaps/phrasing towards business-owners to discuss the buy-in.

The post Book review: “Tidy first?” appeared first on foojay.