A manual for the care and growth of your programming career
920612
This is a great compliment to The Pragmatic Programmer.  That book presents short, sweet descriptions of successful habits for a programmer to follow while practicing their craft.  My Job Went To India arms a programmer with habits and practices that will help enhance their career.

I love books with short chapters, and this one has fifty-two of them.  They read quickly and many end with exercises to apply the practice or skill recently discovered.

Much of what a programmer must do to advance his craft these days is more closely related to business than software.  Many programmers, myself included, are somewhat intimidated by the need to learn these skills.  Fowler breaks it down and make this subject matter far easier to approach.

The essence of this book is tons and tons of experience distilled into words.  Sure, you could learn all of this stuff over a decade in the industry, but you might have some frightening, tight times in between.  I feel like My Job Went To India has given me a leg up by focusing the topic of managing a programmer's career into fun-to-read, easily digestible chunks that are all highly actionable.
964201
In my years of doing programming on different platforms and Operating System this book by far has been the most useful. The sheer detail in examples and the well thought-out instructions lend this book to be a great resource to the novice and the pro. A must read and great investment.

James E. Rudolph
3054083
Every time I open this book I get stunned, he keeps talking about questions I ask myself daily while programming, daily! and he answers them in a very nice clear simple way, the way will guide you definitely into having cleaner code, and cleaner code will make you a happier person (at least me).

Imagine you collect all your clean code thoughts, blogs you read, everything into a single general purpose book - you have imagined Clean Code.

The best thing about this book is that it's really down to earth.  Nothing is simple about programming, naming a variable? pay it attention the book will approach and take you step by step and talk about all the naming questions you might ask, until you get to understand what is a good variable name, what is not.  The book looks at code from many directions with many down to earth examples.  It talks both about lower level issues such as exceptions, length of methods / classes and then goes beyond into system design and general principles for organizing your project.

You can definitely treat this book as a summary, he took all the notes from all major programming voices in our world and gathered them with his own views into a book.  The book is written very clearly.

CHAPTER 11: SYSTEMS - Cities are complex right? and yet they get to manage quite well right? the write then says, if cities are very complex and are well behaved why shouldn't your complex software as well... He then compares how city is managed to your software, its very insightful and helps you build better systems.
CHAPTER 13: CONCURRENCY - it talks both about high level aspects as well as (surprisingly) lower level, it beautifully merges the two.  The main concept from which the chapter emerges is that concurrency is the decoupling process of the `what` of the application from the `when` meaning what your application does from when it does it, it put it so simply  beautifully and shows how much it becomes difficult to keep the SRP principle in these situations.
3462579
This book describes, in a simple series of steps, how to construct a production-quality runtime system. This includes powerful features like TCP/IP networking, interfacing to native code, and synchronization primitives. Everything that you would expect from a commercial runtime system is presented in explicit detail.

This includes the source code and documentation for a full set of development tools (like a bytecode assembler, symbolic debugger, and binary analyzer).

There is also an extended discussion of how the book's virtual machine can be ported to other platforms. To this end, the author offers a critical path analysis of the development process so that the reader can build their own virtual machine. This is followed by a critical path analysis of the procedures necessary to build an entire operating system!

The author obviously knows what he is doing and is coming from a heavy 80x86 background. There are several points in the book where the author discusses actual hardware implementations of system I/O, paging, and interrupts. You can tell that Barry Brey was the technical editor.

What I liked best was the authors explanation of how object-oriented  concepts are implemented in bytecode. Probably the most concise discussion of exceptions, encapsulation, and inheritance that I have ever seen. Cool.
867354
This is a really good book. The journey through this book teaches many things to build a strong foundation to be Android Programmer. It teaches things that you would never do in the wild but, you need to understand why. The curious and challenges sections are gold.
it's a must have!
991024
Data Science from Scratch takes you through a journey that somewhat simulates the real-life demands on programmers today.
While the emphasis is on Python, the content also enables those from other disciplines to appreciate the common issues that underpin  the various languages across the programming world.

If you have some foundation in math and aspire to be a hacker (or vice versa), this may be a useful read!
1265442
This is a book for everyone: whether you are seeking sound and proven career advice, or whether you manage teams and people, this book is packed with gems. I especially like the "Mobility Mindset" feature, which gives specific examples of what other people and companies have done. The book is organized into six chapters. Each chapter elaborates on a career move: lateral, exploratory, enrichment, realignment, relocation and vertical. The last chapter of the book (Go For It) shows how to take concrete next steps. The book is a fast read, and easy to random-access based on need and interest.
4621645
I seem to be on a kick lately where I'm reading books that have nuggets of programming wisdom that force you to contemplate what you do and how you do it. This month's book is no different... "97 Things Every Programmer Should Know: Collective Wisdom from the Experts". Presented by a number of technical gurus and visionaries, these 97 two-page thoughts will probably cause you to feel a mixture of emotions, from assurance that you are doing some things correctly, through guilt over taking shortcuts to come, and finally to some frustration over disagreements. In any case, you *will* walk away with a number of ideas to change what you're doing.

There is no pattern or flow to the material as you read through the 97 chapters. In fact, the main order is by alphabetizing the titles of each chapter. But the editor does provide a secondary table of contents to group the contributions by category, so you can choose to read the material in logical groupings if you so desire. It's also important to keep in mind that this is really a "crowdsourced" compilation of what programmers should know. Given that there is no "one true way" to do things, you may find that some of the ideas and contributors don't necessarily agree with each other on all points. But that's OK, as you should read the material and think about what's being said, knowing that your angle or approach may be slightly different (and potentially just as valid) than what you just read.

Even in the short time I've had since finishing the book, I've already started to refer back to some of the information. For instance, "Ask 'What Would the User Do?' (You Are Not the User)" was driven home the other day when I was debugging an application issue that seemingly could not be reproduced. As the developer, I followed the steps exactly as designed, and always got the correct answer. The problem is, the users *didn't* follow the designed path, and I was blind to a very valid and understandable path they would take. I need to remember... I am not the user.

Another one that haunted me just last week (fortunately, I was not the offender) was "A Message to the Future." The contributor makes the case that every line of our code should be a message to the future, to the smart person who will inevitably have to solve a problem with this code. Make them want to say "This is great code, and it's an elegant solution. I can understand it immediately!" If you can code in such a way to make the world better for Phil (the smart person you haven't met yet), then the world truly will be a better place. I only wish the person who had left me a really nasty bug in one of their agents had been practicing that idea...

Some of these ideas might not be where you currently live in the tech world, but you will find a number of contributions that *do* hit you right where you live and breathe each day. And since just one great idea can change your whole perspective, "97 Things" is a very good investment in yourself, your career, and your future.
3476667
I am lucky to have had the opportunity to be a student of John Carlis, so the readability and quality of this book was no surprise.  Anyone who has even discussed computer science with him would assure you that his focus is not simply on amassing tools, but on mastering them.  This book was loaned to me on the job, and served as an excellent introduction, and as a wonderful reference.

The simplicity and power of LDS makes it an excellent tool for software developers.  In a discussion with Carlis, he explained to me the appeal that LDS had to him.  He said its simple, limited set of components allows you to use data modeling not as a reference to understand software, but as a way to plan it, and think about the consequences of each decision you make.

Buy this because it's a great read, a great introduction, and an invaluable reference.  No software developer's desk should be without it.
606407
Ken Kousen has written a marvelous survey of Groovy with his book "Making Java Groovy".

For those unfamiliar, Groovy is one of those Java Virtual Machine languages, a language that compiles down to Java bytecode, which enables it to run wherever Java is used. Because of this, Groovy can often stand in for Java, but Ken writes "I'm more interested in helping Java than replacing it". His proposal to Java developers: stir in a little Groovy with your Java code, and be amazed at the power of dynamic programming. With Ken's book, you'll see where and how to mix this nifty language that really breathes some new life into Java.

Ken writes: "A phrase often used when describing Java is that the essence is buried in the ceremony." He's hit the nail on the head here, and it mirrors my own experience with programming Java. As a fan of dynamic languages like Perl, PHP, and Python, anytime I find myself writing Java I'm often struck with how much boilerplate I have to write just to do something simple. Not so with Groovy.

The strength of Ken's book are his heavy use of sample code. In fact, all of his examples are available on his personal Github, and his medium to large-sized examples show just how succinctly you can express yourself using Groovy. His big examples cover Spring, JDBC, REST and Grails. Difficult tasks like consuming XML or JSON, or writing succinct tests are much simpler in Groovy. Ken demystifies Abstract Syntax Trees, and Groovy's metaclass, which is where a lot of Groovy's "ease of use" comes from.

People who have cut their teeth with Spring, or EJBs, will find themselves amazed that the JVM now has a lightweight language that they can use to ease their programming burdens. People who are more familiar with modern dynamic languages will hopefully recognize that Groovy is right up their alley.

I also appreciated Ken's earnest sense of humor, and his numerous nods to many of the lead Groovy developers. Ken also shows much respect for "Groovy in Action", which is also published by Manning. Groovy is becoming a strong complement to Java, and Ken's book shows you why that's so.

Disclaimer: I received a copy of this book for review from the publisher. I'm also a technical reviewer.
2661758
For a book on software engineering that has been printed and sold more than quarter million copies, there is little to be said.  At the same time it is an eye opener to see how well its messages have been embedded into the software engineering teaching and preaching.  Almost in every essay, I found something that was mentioned to me through some medium: explaining the code review comments, explaining the project plan, review comments on software sizing, and so on.  The greatness of this book lies in assembling some of the time tested essays that refuse to lose its shine even after four decades.

The book is a collection of nineteen essays including the three added after twenty years of initial publish.  The novelty starts from the first page of each essay through the illustration of the central theme of that essay.  Those illustrations are drawn from the non-software facets of our lives: mythology, literature, menu card of a restaurant, etc.  As a result, we learn the relationship between time and quality through the menu card of a New Orleans' restaurant that says "Good cooking takes time.  If you are made to wait, it is to serve you better, and to please you."  Also, we see how Noah's ark and the tower of Babel easily fit to explain the complexity of managing large software development teams.  The essays also bring up the details of project workbook (present days' software project plan), specification, planning for changes or change requests (Plan to Throw One Away), and above all, the importance of communication with clarity.  All of these are relevant today to its fullest extent.

Some of the essays may have little practical use in today's software development projects, simply because the technology, processes, and people skills have leapfrogged many folds in the last four decades.  As a result, we see the essay #3 "The Surgical Team" documents nine roles in a team of ten (one role called secretaries require two individuals), largely drawn from Harlan Mill's proposal.  About five of those nine roles are no longer required to be filled by full time individuals; some of those like language lawyers are not at all required today due to advancement of standards and open architecture.  Even surgery today, does not require so much support staff, largely due to advancement of surgical procedures.  Nevertheless, this is a good academic experience to gain insights the challenges faced by the software engineers four decades back.

In its initial edition, the last essay "No Silver Bullet" attempted to establish a hypothesis that there is (or will be) no single development, in either technology or management technique, which by itself promises even one order-of-magnitude improvement within a decade in productivity, in reliability, in simplicity.  For the subsequent twenty years, this hypothesis attracted a lot of criticism, adverse and constructive included.  In the anniversary edition, the author tried to respond to the adverse critiques by adding one more essay "No Silver Bullet Re-fired".  While the proponents and opponents of the hypothesis had their own argumentative strengths, the evolution of software engineering itself has taken some phenomenal turns in last four decades.  As a result, software today, is not just for a mainframe, it's for everyday lives of billions around the world.  Hence, the book as a whole stands up stronger than any single essay.

For all software engineers, aspirants included, this book is a recommended reading.
1278485
This is a wonderful book for people who want to learn X++ programming and also how to use it in practice.
The first seven chapters introduce the reader to the concepts and syntax of X++ and how to use it in integrating external data via a text file, XML or ODBC data.  Chapter 8 explains in clear term how to solve many real tasks a programmer will face like integrating with the standard AX module (with examples of Inventory, General Ledger, Account Receivable and Payable).The last chapters cover programming using .Net, writing WEB services and programming the Enterprise Portal.

It covers in an excellent way all the arguments useful for an AX developer, and it is easy to read and complete in the explanations and examples.
1356172
This is the book I wish Id had when I was starting out in the software development industry 20 years ago. The great thing is you don't have to be a newbie to benefit from Johns wisdom. Many of the topics covered in this book apply to my career as well. My only issue is that I wish John had named it The Complete Software Engineers or Software technologists Guide because it applies to everyone in the software development field -- not just developers.
2380469
Although this is an introductory book, I also recommend it to advanced programmers. Concise and well written, it is a joy to read. Programmers who have little knowledge of modern functional languages will benefit immensely from this book. It is a great recreational read.
3060014
John Smiley presents a complete learning environment that builds a solid programming foundation.  Each book individually and collectively engages and immerses the novice programmer into the richness of the Visual Basic  development environment without overwhelming you in its complexity. From  Learn to Program with Visual Basic, through Databases and Objects I found  learning VB programming fun, and instructive at the same time.  John's use  of examples to support the development of a "real world"  programming task proved important in understanding VB programming, the  Integrated Development Environment and it various features or tools.  Using  the same program, you helped create, through three books dealing with  different aspects of VB programming helped solidify the programming  experience, and enhance learning.  More than anything else, John comes out  of those pages as your guide and mentor allowing you to pick up those  intangibles that come from a skilled programmer, and educator.  He leaves  you, and encourages further study, having given you the fundamentals to go  on and tackle more advanced VB topics, because you now know how to program  with VB. I kid you not.  I jumped into learning VB using the MS Visual  Basic Programmer's guide, and various MSDN materials.  It was like going up  hill in snow and ice, I wasn't getting anywhere fast!  After going through  John's three books, MS VB programmers guide, and other materials just fell  into place, because I now had the VB skills and knowledge to appreciate and  understand the presented material.
2822334
I have gifted this book to two aspirant programmers. One inhaled the contents and found several nuggets of truth that were worth the reading. It's written in short blocks of text for the commuting reader, and the flow is up to the reader. Find what interests you and dig in. There is one obvious plug for Ruby--and the definitive work when this book was published was written by the authors.
1453555
This book belongs on the bookshelf of every programmer engaged in time-triggered embedded systems.
No that's wrong, it belongs on their desk - it should have post-it notes hanging out the sides, the binding should be broken and numerous stains of coffee should mar the pages. It is the most pragmatic guide to building embedded systems programs I've seen in my 25+ years of experience with such systems.
This book lives up to the dreams and goals of the patterns community; namely the capturing of wisdom in a way that can be shared with others. Pont's collection of patterns oozes wisdom on each page, from concept to implementation. The topical organization of patterns ranges from early project development issues such as selection of the right microcontroller to detail design questions of interfacing to switches, keypads, LED's and LCD panels. Along the way Pont tackles some of the most baffling topics in embedded systems - co-operative, pre-emptive and shared-clock schedulers; and the interfacing of multi-processor systems.
If you are a programmer new to embedded systems development, then careful, methodical study, will rapidly help you through multiple learning curves - time-based architectures; digital, analog and electromechanical sub-systems often connected to microcontrollers; interfacing to the variety of communications protocols you might encounter; data acquisition; control strategies; feedback systems; and so much more.
If you have experience building embedded systems then this is a book that deserves to be treated as a reference book or a handbook - that is, it should be browsed from cover to cover to discover the comprehensive nature of topics; then as new work is assigned to you, or new problems arise, it should be the first book you consult for ideas, pointers and solutions.
This book has a depth that suggests many years of research. It brings together and cross-correlates so many diverse topics, I suspect it was difficult to write. I appreciate the hard work and dedication it must have taken to finish this project. I thank Michael Pont, as with this book, he has made my job easier.