TOP programming books for beginners

“Passion for technology, ability to choose the best solution to a problem, general IT erudition, understanding of what awaits him at work” – that was his answer.

I once described in an article about programming books for beginners that helped me learn Java. In this article, I will focus on publications that will help a novice programmer gain that very IT erudition, an understanding of future work, and also simplify the task of choosing the best solution. That is, to get a job and show yourself as good as possible in it from the very beginning.

 

BOOK FOR BEGINNERS

I made this list according to my own preferences, so it can be somewhat subjective. There are classic programming textbooks for students, and handbooks for programmers of all generations.
Improving code and productivity
Just writing code isn’t enough. It is important to write it well, be able to improve it, and also understand how it is developed in general. The following books for novice programmers and not only have helped more than one generation of specialists to cope with the difficult technological process of software development.

Pragmatic programmer. The Path from Apprentice to Master (Andrew Hunt, David Thomas)

Original title: The Programmatic Programmer from From Journeyman to Master by Andrew Hunt and David Thomas
If you have not read this book, most likely you have repeatedly come across quotes from it on forums and specialized resources. The image of a pragmatist programmer in this book is so clear and idealized that … he can be called a romantic, however paradoxical it may sound. Nevertheless, the advice from the book is sensible and relevant, despite her considerable age.

I don’t know what to compare “The Pragmatic Programmer” with in the world of a programming book. The closest counterparts outside of this world are The Old Testament or some super-cool cookbook. In “Pragmatics” everything is very specific and is maximally applicable in practice. Sometimes it comes to platitudes (for example, the section on effective communication contains elementary rules of business etiquette), but sometimes the advice from the book is irreplaceable, especially if a novice developer does not have a patient and attentive mentor. These are the clues about code repeatability, prototyping, evaluations. Or a reminder of the impossibility of creating a perfect program. There are also useful technical points related to, for example, debugging code, unit testing or the speed of algorithms … in short, what you need to prepare for a career as a programmer.

Refactoring Improving existing code (Martin Fowler)

Original title Refactoring: Improving the Design of Existing Code by Martin Fowler, with Kent Beck
If you ask someone to list the best coding books of all time that have helped build a career, someone will definitely mention Refactoring. Someone may say that this book is out of date, and in some ways will be right. It was written at a time when refactoring was not yet a ubiquitous rule, and some truths about it are obvious to aspiring programmers today. Nevertheless, the refactoring techniques are described in it so well and in detail (in places, I would even say, verbose) that every beginner will find something useful in it. An updated edition of the book came out a few years ago, and new techniques were added, which is just great. In addition, the examples in this book are written in Java. Of the shortcomings, I will only note the verbosity. However, I recommend the book.

Clean Code (Robert Martin)

Original title Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin
This book, although newer than the previous one, has also become a classic in programming books. “Uncle Bob”, as Robert Martin is sometimes called in the global programming community, is one of the authors of the Agile manifesto, as well as some of the principles of modern “pure” programming, for example, SOLID. One of the main leitmotifs of the book can be considered … empathy or just a good attitude towards everyone who will have to work with your code (including yourself in the future). Most of the Clean Code rules are based on this simple principle and common sense. Most of the rules and tips seem to be very correct, the kind that intuitively revolve in the head, but it is not easy to articulate them clearly. However, one can argue with some of the author’s thoughts: he is sometimes extremely categorical. For example, he writes that good code doesn’t need to be commented.

Introduction to Computer Science (Glenn Brookshire, Dennis Brilov)

Original title Computer Science: An Overview by Glen Brookshear and Dennis Brylow
This book came to me when I was still at university, when I was studying the basics of computer science. Only I got the translation of the sixth edition, and currently the 13th edition is relevant. The book is a basic course in computer science, which has been taught at universities in the United States and other countries for many years. The scope of the material in it is very wide: machine architecture, number systems, data processing, operating systems, principles of building databases, data structures, file structures, and so on. Not all sections of the book are written equally well. For example, once I was very confused by the sections about design methods and databases, but the sections about number systems, bitwise computing, PC architecture and data structures really interested me. The coolest thing about the book is the sheer amount of key exercises. Such a book, in addition to students, is perhaps needed primarily by self-taught people without technical education in order to fill in the gaps and get an idea of ​​computer science in general.
Algorithms and data structures. That still attack!
Given how high-level modern programming has become, knowledge of algorithms has lost its paramount importance. Now it is enough to use the required library and not rack your brains over how best to sort the array. However, you still have to puzzle in your work, and more than once. Remember the “ability to choose the best possible solution” from the requirements for a novice programmer? So, no matter what anyone says, I consider good algorithmic training to be an excellent pumping for finding optimal solutions. Therefore, the next two books are about them. About algorithms.

Grock algorithms. An illustrated guide for programmers and the curious Aditya Bhargava

Original title: Grokking Algorithms: An illustrated guide for programmers and other curious people by Aditya Y. Bhargava
The author himself at the beginning of the book writes that the algorithms were not given to him right away, and he tried to write “Grock Algorithms” so that it was easy to read. It is designed for novice programmers, that is, those who can write “hello, world” and know what int, string, loop, branch and array are. Well, it can display an array on the screen. The required knowledge of mathematics is approximately at the level of 6-7 grades of high school without frills. And this is the first serious plus of the book. She does not try to present the reader as a student of mathematics, like many publications on the topic. That is, if you are afraid of mathematics, algorithms, have already tried to learn the latter and have not understood anything, this book is perfect for your rehabilitation in your own eyes. The second positive point is that the book discusses what may well be useful in practice (understanding this, for sure).

It starts with explaining the essence of binary search and efficiency – literally on the fingers and with a lot of pictures. Third – there are many questions and exercises in the book (code examples are in Python, but this is not so important). A moment that may be positive for someone, but negative for someone: the book does not constitute an all-encompassing reference book. For example, of the algorithms generally accepted for studying, there are only two – an inefficient insertion algorithm and an efficient quick sort algorithm. Why should the author not consider other algorithms, say, bubble or merge – I don’t know. In fact, the book mentions the merge algorithm, but briefly, indiscriminately and only in comparison with quicksort. With the rest of the topics, everything is exactly the same. There are basics that are very well disassembled, but sometimes you really want a more in-depth continuation, but it simply does not exist. In a word, we have before us a very basic book, after which, most likely, you will want to find a book in which everything is more serious. For example, the following.