Programming Books

I have just finished and released the sequel to the book "Shaders in Godot 4". The new book is titled "More shaders in Godot 4". 😀

The book is a comprehensive guide on creating 33 spectacular shaders in Godot 4, including thorough explanations of their algorithms and parameter settings. Each example comes with complete source code that you can use in your projects without restrictions.

This time, it also includes a b and an elaborate introduction to ray marching.

b

Please visit https://filiprachunek.gumroad.com/l/moreshaders for more information and a free sample (50 pages out of 311).

Thank you for reading this. Good luck with your games. 😎

Learn how to enhance your game’s graphics with impressive visual effects!

This book provides a detailed guide on creating 30 spectacular shaders in Godot 4, including thorough explanations of their algorithms and parameter settings. Each example comes with complete source code that you can use in your projects without restrictions.

So, how can you get it?

Please visit Shaders in Godot 4: Add stunning visual effects to your games for more information and a free sample (50 pages out of 310).

Thank you for reading this. Good luck with your games. 😎

Would you like to explore the world of game development and embark on the journey of crafting your own computer game?

This hands-on guide provides you with the chance to acquire firsthand experience in harnessing the power of Godot 4 and mastering the art of coding with GDScript. Within its pages, you’ll find step-by-step instructions on how to create an entire game independently using the Godot Engine.

What makes an ebook a more fitting choice for a programming guide compared to a traditional printed book?

An ebook is always up-to-date. I already upgraded all the code snippets to be compatible with Godot 4.2, and I want to keep updating it after every significant release of the Godot Engine.

So, how can you get it?

Please visit Godot 4: From Zero To Full Game for more information and a free sample (50 pages out of 301).

Thank you for reading this. Good luck with your games. 😎

I was looking at my books and thought it might be a good idea to hear what programming books you're reading and which ones you would be recommending and hopefully we could build a nice reading list.

I'll start with these two:

• C++ Software Design by Klaus Iglberger: the author is a stellar presenter at conferences like CppCon (you get the contents of his book essentially for free in his talks which are on YouTube, just Google "Breaking dependencies by Klaus Iglberger"). This book is a must-have if your issue is not programming skill itself but more design-related instead and you want to learn how to write high-quality professional software with maintainability in mind. This easily replaces the classic Design Patterns: Elements of Reusable Object-Oriented Software as Klaus' book is more modern and embraces at least C++17 with e.g. variants;
• Game Programming Patterns by Robert Nystrom: this is not about game design! This is about classic C++ patterns (implementable in other languages as well though) that you'll need if you're about to write a game, and I think one can easily see that the patterns and techniques are transposable to other domains like web browser development or even automatic differentiation.

https://d2l.ai/

The book was written originally by a group of Amazon engineers and strives to be a resource on getting started with deep learning.

Even if you have no interest in developing models, you should be aware of how they work under the hood.

For the AI enthusiasts, it makes them more interesting. For the AI doomists, it makes them less scary.

The book being online and an easy to remember URI makes this a great reference book that you can access from any device with an internet connection. You could read the whole thing with cURL if you were feeling wacky. You can also clone the repo and host it locally if you want to "own" a copy.

They are releasing a physical book in English this week, so for you collectors out there can have something for your shelves.

Tap into the wisdom of experts to learn what every programmer should know, no matter what language you use. With the 97 short and extremely useful tips for programmers in this book, you'll expand your skills by adopting new approaches to old problems, learning appropriate best practices, and honing your craft through sound advice.

With contributions from some of the most experienced and respected practitioners in the industry--including Michael Feathers, Pete Goodliffe, Diomidis Spinellis, Cay Horstmann, Verity Stob, and many more--this book contains practical knowledge and principles that you can apply to all kinds of projects.

A few of the 97 things you should know:

• "Code in the Language of the Domain" by Dan North
• "Write Tests for People" by Gerard Meszaros
• "Convenience Is Not an -ility" by Gregor Hohpe
• "Know Your IDE" by Heinz Kabutz
• "A Message to the Future" by Linda Rising
• "The Boy Scout Rule" by Robert C. Martin (Uncle Bob)
• "Beware the Share" by Udi Dahan

Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations

by Nicole Forsgren PhD, Jez Humble, Gene Kim

How can we apply technology to drive business value? For years, we've been told that the performance of software delivery teams doesn't matter―that it can't provide a competitive advantage to our companies. Through four years of groundbreaking research to include data collected from the State of DevOps reports conducted with Puppet, Dr. Nicole Forsgren, Jez Humble, and Gene Kim set out to find a way to measure software delivery performance―and what drives it―using rigorous statistical methods. This book presents both the findings and the science behind that research, making the information accessible for readers to apply in their own organizations.

Messy code is a nuisance. "Tidying" code, to make it more readable, requires breaking it up into manageable sections. In this practical guide, author Kent Beck, creator of Extreme Programming and pioneer of software patterns, suggests when and where you might apply tidyings to improve your code while keeping the overall structure of the system in mind.

Instead of trying to master tidying all at once, this book lets you try out a few examples that make sense for your problem. If you have a big function containing many lines of code, you'll learn how to logically divide it into smaller chunks. Along the way, you'll learn the theory behind software design: coupling, cohesion, discounted cash flows, and optionality.

This book helps you:

• Understand the basic theory of how software design works and the forces that act on it
• Explore the difference between changes to a system's behavior and changes to its structure
• Improve your programming experience by sometimes tidying first and sometimes tidying after
• Learn how to make large changes in small, safe steps
• Approach software design as an exercise in human relationships

Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.

Noted software expert Robert C. Martin, presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin, who has helped bring agile principles from a practitioner’s point of view to tens of thousands of programmers, has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of software craftsman, and make you a better programmer―but only if you work at it.

What kind of work will you be doing? You’ll be reading code―lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly you will be challenged to reassess your professional values and your commitment to your craft.

Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code―of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.

Readers will come away from this book understanding

• How to tell the difference between good and bad code
• How to write good code and how to transform bad code into good code
• How to create good names, good functions, good objects, and good classes
• How to format code for maximum readability
• How to implement complete error handling without obscuring code logic
• How to unit test and practice test-driven development
• What “smells” and heuristics can help you identify bad code

This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.

Book Description

Software failure in high-profile areas, such as aerospace, defence and medicine frequently makes the headlines because of the potentially disastrous consequences. The huge and recent growth in the use of software development has particularly serious implications for such safety-critical and high-integrity systems.

Despite its popularity and the excellent tool support available, C is only suitable for use in these areas within firm constraints and guidelines. Safer C: Developing Software for High-integrity and Safety-critical Systems highlights the 'holes' in C, but also demonstrates clearly that, employed correctly, C can be used to write software of as high intrinsic quality as other languages.

Beginning with a broad overview of safety in software, the book provides a critique of C as a safety-critical language, based on the author's extensive measurements of commercial C quality. Complexity, safer subsets, standards and tools are all examined. Essential rules of good working practice and guidelines for immediate implementation are presented and a direct comparison is made of specific safety-related features in C and other commonly-used languages. This important and timely book contains vital information for all developers working with C, whether in high-integrity areas or not, who need to produce reliable and effective software.

Special features include: much needed guidance for all software developers using C, not just those working on high-integrity and safety-critical systems; practical points for immediate implementation based on the use of safer subsets; and an examination of poorly understood legal implications of software safety and references to standards throughout.

Back Cover Text

The software development community widely acknowledges that domain modeling is central to software design. Through domain models, software developers are able to express rich functionality and translate it into a software implementation that truly serves the needs of its users. But despite its obvious importance, there are few practical resources that explain how to incorporate effective domain modeling into the software development process.

Domain-Driven Design fills that need. This is not a book about specific technologies. It offers readers a systematic approach to domain-driven design, presenting an extensive set of design best practices, experience-based techniques, and fundamental principles that facilitate the development of software projects facing complex domains. Intertwining design and development practice, this book incorporates numerous examples based on actual projects to illustrate the application of domain-driven design to real-world software development.

Readers learn how to use a domain model to make a complex development effort more focused and dynamic. A core of best practices and standard patterns provides a common language for the development team. A shift in emphasis—refactoring not just the code but the model underlying the code—in combination with the frequent iterations of Agile development leads to deeper insight into domains and enhanced communication between domain expert and programmer. Domain-Driven Design then builds on this foundation, and addresses modeling and design for complex systems and larger organizations.

Specific topics covered include:

• Getting all team members to speak the same language
• Connecting model and implementation more deeply
• Sharpening key distinctions in a model
• Managing the lifecycle of a domain object
• Writing domain code that is safe to combine in elaborate ways
• Making complex code obvious and predictable
• Formulating a domain vision statement
• Distilling the core of a complex domain
• Digging out implicit concepts needed in the model
• Applying analysis patterns
• Relating design patterns to the model
• Maintaining model integrity in a large system
• Dealing with coexisting models on the same project
• Organizing systems with large-scale structures
• Recognizing and responding to modeling breakthroughs

With this book in hand, object-oriented developers, system analysts, and designers will have the guidance they need to organize and focus their work, create rich and useful domain models, and leverage those models into quality, long-lasting software implementations.

Back Cover Text

For more than twenty years, experienced programmers worldwide have relied on Martin Fowler’s Refactoring to improve the design of existing code and to enhance software maintainability, as well as to make existing code easier to understand.

This eagerly awaited new edition has been fully updated to reflect crucial changes in the programming landscape. Refactoring, Second Edition, features an updated catalog of refactoring's and includes JavaScript code examples, as well as new functional examples that demonstrate refactoring without classes.

Like the original, this edition explains what refactoring is; why you should refactor; how to recognize code that needs refactoring; and how to actually do it successfully, no matter what language you use.

• Understand the process and general principles of refactoring
• Quickly apply useful refactorings to make a program easier to comprehend and change
• Recognize “bad smells” in code that signal opportunities to refactor
• Explore the refactorings, each with explanations, motivation, mechanics, and simple examples
• Build solid tests for your refactorings
• Recognize tradeoffs and obstacles to refactoring

This is a place where you can share and discuss books relating to the instance

Links are currently disabled in the community. If you have a domain that you feel should be whitelisted feel free to let me know and ill add it. (This rule is just in place to prevent pirating books)

And if you want to be a mod for the community let me know