Michael's bookshelf: programming en-US Wed, 02 Oct 2024 16:14:17 -0700 60 Michael's bookshelf: programming 144 41 /images/layout/goodreads_logo_144.jpg <![CDATA[The Pragmatic Programmer: Your Journey to Mastery, 20th Anniversary Edition]]> 52715562 The Pragmatic Programmer, Andrew Hunt and David Thomas codify many of the truths they've discovered during their respective careers as designers of software and writers of code.

Some of the authors' nuggets of pragmatism are concrete, and the path to their implementation is clear. They advise readers to learn one text editor, for example, and use it for everything. They also recommend the use of version-tracking software for even the smallest projects, and promote the merits of learning regular expression syntax and a text-manipulation language. Other (perhaps more valuable) advice is more light-hearted. In the debugging section, it is noted that, "if you see hoof prints think horses, not zebras." That is, suspect everything, but start looking for problems in the most obvious places. There are recommendations for making estimates of time and expense, and for integrating testing into the development process. You'll want a copy of The Pragmatic Programmer for two reasons: it displays your own accumulated wisdom more cleanly than you ever bothered to state it, and it introduces you to methods of work that you may not yet have considered. Working programmers will enjoy this book. --David Wall

Topics covered: A useful approach to software design and construction that allows for efficient, profitable development of high-quality products. Elements of the approach include specification development, customer relations, team management, design practices, development tools, and testing procedures. This approach is presented with the help of anecdotes and technical problems.]]> 352 Dave Thomas 0135956919 Michael 4 own, programming
Tone aside, the concepts in the book are really really solid and I think it's what we all should strive for. But reality is often disappointing. These suggestions work in the real world, and yes it would be interesting to work in a place that had all of these suggestions. But it'd also be nice if unicorns were real.

I also didn't particularly like how the coding examples were all in different languages depending on the section. It's not that it's hard to understand, but wouldn't it have been easier to lock in the concept more solidly if I could see it in my "native language?" The authors boast about the automation of their publishing scripts, so why couldn't one of those steps have been replacing all the code samples with a particular language. Naturally, you would end up with a litany of versions, but since they own the publishing company (and the website), this feels easily manageable using the PDF version. Now perhaps this is me missing the point, but I think it would still be beneficial. For example, during the section discussing the use of preconditions, post-conditions, and invariants, I had to look up online how my favorite language, C#, handles the process. And it was significantly different than the ideal example they presented in the book, and really isn't nearly as practical as they made it sound, nor as recommended.

Overall, I would tell everyone to read this book, but I would also say take it an open mind. These are things the ideal programmer should be doing, not the average programmer. Take steps to meet these goals but don't beat yourself up if you don't attain all of them within the next decade.]]> 4.49 1999 The Pragmatic Programmer: Your Journey to Mastery, 20th Anniversary Edition
author: Dave Thomas
name: Michael
average rating: 4.49
book published: 1999
rating: 4
read at: 2020/01/27
date added: 2024/10/02
shelves: own, programming
review:
While I think this book has a lot of really great advice, I didn't particularly enjoy the writing style. Everything seems so finite and certain, despite the fact that they repeatedly walked back on arguments they had made in the first edition. The tone of the book was just a little too casual. It felt like I was getting a lecture by my grandfather instead of a professor.

Tone aside, the concepts in the book are really really solid and I think it's what we all should strive for. But reality is often disappointing. These suggestions work in the real world, and yes it would be interesting to work in a place that had all of these suggestions. But it'd also be nice if unicorns were real.

I also didn't particularly like how the coding examples were all in different languages depending on the section. It's not that it's hard to understand, but wouldn't it have been easier to lock in the concept more solidly if I could see it in my "native language?" The authors boast about the automation of their publishing scripts, so why couldn't one of those steps have been replacing all the code samples with a particular language. Naturally, you would end up with a litany of versions, but since they own the publishing company (and the website), this feels easily manageable using the PDF version. Now perhaps this is me missing the point, but I think it would still be beneficial. For example, during the section discussing the use of preconditions, post-conditions, and invariants, I had to look up online how my favorite language, C#, handles the process. And it was significantly different than the ideal example they presented in the book, and really isn't nearly as practical as they made it sound, nor as recommended.

Overall, I would tell everyone to read this book, but I would also say take it an open mind. These are things the ideal programmer should be doing, not the average programmer. Take steps to meet these goals but don't beat yourself up if you don't attain all of them within the next decade.
]]> Functional Programming in C# 58127263
In Functional Programming in C#, Second Edition you will learn how

Use higher-order functions to reduce duplication and do more with less code
Use pure functions to write code that is easy to test and optimize
Write pleasant APIs that accurately describe your program's behavior
Use dedicated types to handle nullability, system errors, and validation rules predictably and elegantly
Write composable code without the overhead of an IoC container

Functional Programming in C# has helped thousands of developers apply functional thinking to C# code. Its practical examples and spot-on treatment of FP concepts makes it the perfect guide for proficient C# programmers. This second edition is fully revised to cover new functional-inspired features in the most recent releases of C#, including tuples, async streams, pattern matching, and records. Each chapter is packed with awesome perspectives and epiphany moments on how functional programming can change the way you code.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the technology
Turbocharge your C# code. Good functional techniques will improve concurrency, state management, event handling, and maintainability of your software. This book gives you practical answers to why, how, and where to add functional programing into your C# coding practice.

About the book
Functional Programming in C#, Second Edition teaches functional thinking for real-world problems. It reviews the C# language features that allow you to program functionally and through many practical examples shows the power of function composition, data-driven programming, and immutable data structures. All code examples work with .NET 6 and C# 10.

What's inside

Higher-order functions reduce duplication and do more with less code
Code based on pure functions is easy to test and optimize
Write pleasant APIs that accurately describe your program’s behavior
Write a Web API in a functional style
Monadic composition with LINQ

About the reader
For intermediate C# programmers.

About the author
Enrico Buonanno studied Computer Science at Columbia University and has over 15 years of experience as a developer, architect, and trainer.

Table of Contents
PART 1 GETTING STARTED
1 Introducing functional programming
2 Thinking in functions
3 Why function purity matters
PART 2 CORE TECHNIQUES
4 Designing function signatures and types
5 Modeling the possible absence of data
6 Patterns in functional programming
7 Designing programs with function composition
PART 3 FUNCTIONAL DESIGNS
8 Functional error handling
9 Structuring an application with functions
10 Working effectively with multi-argument functions
11 Representing state and change
12 A short introduction to functional data structures
13 Event A functional approach to persistence
PART 4 ADVANCED TECHNIQUES
14 Lazy computations, continuations, and the beauty of monadic composition
15 Stateful programs and stateful computations
16 Working with asynchronous computations
17 Traversable and stacked monads
18 Data streams and the Reactive Extensions
19 An introduction to message-passing concurrency]]> 448 Enrico Buonanno 1617299820 Michael 4 own, programming
If I were to re-write this book (not that I could), I would focus on using idiomatic C# concepts to perform function actions, rather than using more functional concepts. Using `Select` instead of a `Map` function or `SelectMany` rather than `Bind`. While it is mentioned in the books how these concepts are essentially interchangeable, it would simplify my understanding of the concepts if each time I didn't need to perform the translation in my head. It would also be beneficial to use a more established library like `LanguageExt` rather than rolling a custom library (`LaYumba`), which would alleviate some of the tribulations I encountered when attempting to apply these concepts with new vocabulary that didn't match those taught in the author's library.

But on a more uplifting note, I think the book did effectively introduce me to concepts. I found that it didn't give me a deep enough understanding of them that I could effectively use them without much issue (there was a lot of stumbling when I attempted to apply these concepts to a demo application without any handholding). However, it did make me aware of the concepts and help me know what I needed to look up; it gave me a glimpse of the end goal so that I could pave my own way there.

I'm not sure I would recommend this book as a good way to learn a functional language. I think there may be other, better alternatives out there that use C# as a demonstration. However, I don't think I would discourage anyone from trying it and wouldn't try to convince them to pick an alternative if they've already decided on this one. The book was reasonably effective and I cannot fault it for it's ability to introduce concepts.]]> 4.33 Functional Programming in C#
author: Enrico Buonanno
name: Michael
average rating: 4.33
book published:
rating: 4
read at: 2022/06/08
date added: 2022/07/27
shelves: own, programming
review:
The most useful aspect of this book, in my opinion as a C# programmer, would be the introduction of functional concepts through examples of C#. However, after completing this book I came to the conclusion that C# just isn't the language to perform functional programming in. There are a lot of trials and tribulations that come with attempting to make an object-oriented language perform functional actions, and many of those woes could seemingly be overcome by utilizing a more purpose-driven language like F#, Haskel, or any of the other functional-first languages. There is more than one occasion in which the author mentioned a functional concept that just simply wasn't possible in C#.

If I were to re-write this book (not that I could), I would focus on using idiomatic C# concepts to perform function actions, rather than using more functional concepts. Using `Select` instead of a `Map` function or `SelectMany` rather than `Bind`. While it is mentioned in the books how these concepts are essentially interchangeable, it would simplify my understanding of the concepts if each time I didn't need to perform the translation in my head. It would also be beneficial to use a more established library like `LanguageExt` rather than rolling a custom library (`LaYumba`), which would alleviate some of the tribulations I encountered when attempting to apply these concepts with new vocabulary that didn't match those taught in the author's library.

But on a more uplifting note, I think the book did effectively introduce me to concepts. I found that it didn't give me a deep enough understanding of them that I could effectively use them without much issue (there was a lot of stumbling when I attempted to apply these concepts to a demo application without any handholding). However, it did make me aware of the concepts and help me know what I needed to look up; it gave me a glimpse of the end goal so that I could pave my own way there.

I'm not sure I would recommend this book as a good way to learn a functional language. I think there may be other, better alternatives out there that use C# as a demonstration. However, I don't think I would discourage anyone from trying it and wouldn't try to convince them to pick an alternative if they've already decided on this one. The book was reasonably effective and I cannot fault it for it's ability to introduce concepts.
]]> <![CDATA[Entity Framework Core in Action]]> 40375490
Entity Framework Core in Action teaches you how to access and update relational data from .NET applications. Following the crystal-clear explanations, real-world examples, and around 100 diagrams, you'll discover time-saving patterns and best practices for security, performance tuning, and unit testing.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

There's a mismatch in the way OO programs and relational databases represent data. Entity Framework is an object-relational mapper (ORM) that bridges this gap, making it radically easier to query and write to databases from a .NET application. EF creates a data model that matches the structure of your OO code so you can query and write to your database using standard LINQ commands. It will even automatically generate the model from your database schema.

About the Book

Using crystal-clear explanations, real-world examples, and around 100 diagrams, Entity Framework Core in Action teaches you how to access and update relational data from .NET applications. You'l start with a clear breakdown of Entity Framework, long with the mental model behind ORM. Then you'll discover time-saving patterns and best practices for security, performance tuning, and even unit testing. As you go, you'll address common data access challenges and learn how to handle them with Entity Framework.

What's Inside


About the Reader

For .NET developers with some awareness of how relational databases work.

About the Author

Jon P Smith is a full-stack developer with special focus on .NET Core and Azure.

Table of Contents]]> 520 Jon P. Smith 161729456X Michael 0 own, programming 3.83 Entity Framework Core in Action
author: Jon P. Smith
name: Michael
average rating: 3.83
book published:
rating: 0
read at:
date added: 2022/07/26
shelves: own, programming
review:

]]> Operating System Concepts 40097751 Operating System Concepts  has been revised to keep it fresh and up-to-date with contemporary examples of how operating systems function, as well as enhanced interactive elements to improve learning and the student’s experience with the material. It combines instruction on concepts with real-world applications so that students can understand the practical usage of the content. End-of-chapter problems, exercises, review questions, and programming exercises help to further reinforce important concepts. New interactive self-assessment problems are provided throughout the text to help students monitor their level of understanding and progress. A Linux virtual machine (including C and Java source code and development tools) allows students to complete programming exercises that help them engage further with the material.]]> 1040 Abraham Silberschatz 1119124891 Michael 4 programming, csu, own 4.33 1985 Operating System Concepts
author: Abraham Silberschatz
name: Michael
average rating: 4.33
book published: 1985
rating: 4
read at: 2022/07/26
date added: 2022/07/26
shelves: programming, csu, own
review:

]]> OAuth 2 in Action 30102872 Summary

OAuth 2 in Action teaches you the practical use and deployment of this HTTP-based protocol from the perspectives of a client, authorization server, and resource server. You'll learn how to confidently and securely build and deploy OAuth on both the client and server sides. Foreword by Ian Glazer.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

Think of OAuth 2 as the web version of a valet key. It is an HTTP-based security protocol that allows users of a service to enable applications to use that service on their behalf without handing over full control. And OAuth is used everywhere, from Facebook and Google, to startups and cloud services.

About the Book

OAuth 2 in Action teaches you practical use and deployment of OAuth 2 from the perspectives of a client, an authorization server, and a resource server. You'll begin with an overview of OAuth and its components and interactions. Next, you'll get hands-on and build an OAuth client, an authorization server, and a protected resource. Then you'll dig into tokens, dynamic client registration, and more advanced topics. By the end, you'll be able to confidently and securely build and deploy OAuth on both the client and server sides.

What's Inside




Covers OAuth 2 protocol and design
Authorization with OAuth 2
OpenID Connect and User-Managed Access
Implementation risks
JOSE, introspection, revocation, and registration
Protecting and accessing REST APIs
About the Reader

Readers need basic programming skills and knowledge of HTTP and JSON.

About the Author

Justin Richer is a systems architect and software engineer. Antonio Sanso is a security software engineer and a security researcher. Both authors contribute to open standards and open source.

Table of Contents



Part 1 - First stepsWhat is OAuth 2.0 and why should you care?
The OAuth dance Part 2 - Building an OAuth 2 environmentBuilding a simple OAuth client
Building a simple OAuth protected resource
Building a simple OAuth authorization server
OAuth 2.0 in the real world Part 3 - OAuth 2 implementation and vulnerabilitiesCommon client vulnerabilities
Common protected resources vulnerabilities
Common authorization server vulnerabilities
Common OAuth token vulnerabilities Part 4 - Taking OAuth furtherOAuth tokens
Dynamic client registration
User authentication with OAuth 2.0
Protocols and profiles using OAuth 2.0
Beyond bearer tokens
Summary and conclusions]]> 360 Justin Richer 161729327X Michael 0 own, programming, to-read 4.31 OAuth 2 in Action
author: Justin Richer
name: Michael
average rating: 4.31
book published:
rating: 0
read at:
date added: 2022/01/12
shelves: own, programming, to-read
review:

]]> API Design Patterns 51192053 480 J.J. Geewax 161729585X Michael 0 own, programming, to-read 3.84 API Design Patterns
author: J.J. Geewax
name: Michael
average rating: 3.84
book published:
rating: 0
read at:
date added: 2022/01/12
shelves: own, programming, to-read
review:

]]> The Design of Web APIs 38743240 392 Arnaud Lauret 1617295108 Michael 3 programming
The book gets so close to being really good, but unfortunately it just wasn't technical enough for my personal preference. It is very much written to be read by someone of low to moderate technical knowledge.

I'm a software engineer, so I naturally wanted a more technical guide. For instance, there was only one small section on auto-generated specifications, which only listed the cons of using such a process (there was another mention in the final chapter but wasn't given its own section). I would have enjoyed an explanation of why you might use a generation library, what an example usage might be, and compare that to the manual process.

The best thing the book did was to give me an overview of what needs to be done, and an awareness that API guidelines exist and should be considered before reinventing the wheel.

Another complaint I have is that the book is full of huge diagrams with paragraphs of filler. The author creates these often complicated diagrams that are self-descriptive and can be fully understood without much supporting text, then proceeds to describe each part of the diagram in excruciating detail. Or throws in redundant diagrams that add nothing to my comprehension or paragraphs that seem to repeat early points. It felt very much like filler to make sure the book met some quota on length.]]> 3.85 The Design of Web APIs
author: Arnaud Lauret
name: Michael
average rating: 3.85
book published:
rating: 3
read at:
date added: 2021/09/30
shelves: programming
review:
3.5* = It was a decent book, but I likely wouldn't read it again unless someone did some serious convincing.

The book gets so close to being really good, but unfortunately it just wasn't technical enough for my personal preference. It is very much written to be read by someone of low to moderate technical knowledge.

I'm a software engineer, so I naturally wanted a more technical guide. For instance, there was only one small section on auto-generated specifications, which only listed the cons of using such a process (there was another mention in the final chapter but wasn't given its own section). I would have enjoyed an explanation of why you might use a generation library, what an example usage might be, and compare that to the manual process.

The best thing the book did was to give me an overview of what needs to be done, and an awareness that API guidelines exist and should be considered before reinventing the wheel.

Another complaint I have is that the book is full of huge diagrams with paragraphs of filler. The author creates these often complicated diagrams that are self-descriptive and can be fully understood without much supporting text, then proceeds to describe each part of the diagram in excruciating detail. Or throws in redundant diagrams that add nothing to my comprehension or paragraphs that seem to repeat early points. It felt very much like filler to make sure the book met some quota on length.
]]> React in Action 33376063 React in Action introduces front-end developers to the React framework and related tools. This clearly written, example-rich book begins by introducing you to React, diving into some of the fundamental ideas in React, and working with components. In the second section, you'll explore the different ways that data works in React as well as learning more about components. You'll also find several useful appendixes covering related topics like React tooling and the React ecosystem.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology
Facebook created React to help deliver amazing user experiences on a website with thousands of components and an incomprehensible amount of traffic. The same powerful tools are available to you too! The key is a clever design for managing state, data flow, and rendering, so your application is easy to think about and runs smoothly. Add an incredibly rich ecosystem of components and libraries, and you've got a recipe for building web apps that will delight both developers and users.

About the Book
React in Action teaches you to think like a pro about user interfaces and building them with React. This practical book gets you up and running quickly with hands-on examples in every chapter. You'll master core topics like rendering, lifecycle methods, JSX, data flow, forms, routing, integrating with third-party libraries, and testing. And the included application design ideas will help make your apps pop. As you learn to integrate React into full-stack applications, you'll explore state management with Redux and server-side rendering, and even dabble in React Native for mobile UIs.

What's Inside

About the Reader
Written for developers familiar with HTML, CSS, and JavaScript.

About the Author
Mark Thomas is an experienced software engineer who works daily with React, JavaScript, and Node.js. He loves clean code, beautiful systems, and good coffee.

Table of Contents
PART 1 - MEET REACT

PART 2 - COMPONENTS AND DATA IN REACT

PART 3 - REACT APPLICATION ARCHITECTURE]]> 360 Mark Tielens Thomas 1617293857 Michael 2 programming, own The examples would have been far better suited as small, self-contained demonstrations instead of trying to connect to a larger website. At the very least they could have been integrated better. Pages of the book were dedicated entirely to examples which were nearly carbon copies of previous examples.

If you're going to learn React, I'd recommend just reading the React Documentation. It reads easier than you'd think and is much more beginner-friendly.]]> 3.43 React in Action
author: Mark Tielens Thomas
name: Michael
average rating: 3.43
book published:
rating: 2
read at: 2021/03/24
date added: 2021/03/24
shelves: programming, own
review:
At this point, this book is pretty far out of date. It doesn't cover hooks at any point, which is the main casualty of the publish date. The book is so old at this point that the demo website doesn't even work any longer; the code may work, but the code-base is so large that it's overwhelming and I found that I had zero interest in pulling it down.
The examples would have been far better suited as small, self-contained demonstrations instead of trying to connect to a larger website. At the very least they could have been integrated better. Pages of the book were dedicated entirely to examples which were nearly carbon copies of previous examples.

If you're going to learn React, I'd recommend just reading the React Documentation. It reads easier than you'd think and is much more beginner-friendly.
]]> .NET Core in Action 33508897 .NET Core in Action shows .NET developers how to build professional software applications with .NET Core. Learn how to convert existing .NET code to work on multiple platforms or how to start new projects with knowledge of the tools and capabilities of .NET Core.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology
.NET Core is an open source framework that lets you write and run .NET applications on Linux and Mac, without giving up on Windows. Built for everything from lightweight web apps to industrial-strength distributed systems, it's perfect for deploying .NET servers to any cloud platform, including AWS and GCP.

About the Book
.NET Core in Action introduces you to cross-platform development with .NET Core. This hands-on guide concentrates on new Core features as you walk through familiar tasks like testing, logging, data access, and networking. As you go, you'll explore modern architectures like microservices and cloud data storage, along with practical matters like performance profi ling, localization, and signing assemblies.

What's Inside




About the Reader
All examples are in C#.

About the Author
Dustin Metzgar is a seasoned developer and architect involved in numerous .NET Core projects. Dustin works for Microsoft.

Table of Contents]]> 288 Dustin Metzgar 1617294276 Michael 4 own, programming 3.56 .NET Core in Action
author: Dustin Metzgar
name: Michael
average rating: 3.56
book published:
rating: 4
read at:
date added: 2021/01/03
shelves: own, programming
review:

]]> <![CDATA[Refactoring: Improving the Design of Existing Code]]> 35135772 Fully Revised and Updated-Includes New Refactorings and Code Examples "Any fool can write code that a computer can understand. Good programmers write code that humans can understand."
--M. Fowler (1999) 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 refactorings 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 Includes free access to the canonical web edition, with even more refactoring resources. (See inside the book for details about how to access the web edition.)]]> 448 Martin Fowler 0134757599 Michael 3 programming
Unfortunately, I found myself very disappointed by the book. The first four chapters could be compared to Clean Code in many ways; they introduce some good practices of coding and how to perform a refactoring safely. But beyond that it is just a reference list of all the different types of refactoring. On some level I understand why he went into as much detail as he did, but there were a few that just felt extremely long-winded for how simple they are. I don't really need an example of `rename field`.

But that was another criticism I had about this book; the refactoring difficulty levels were wildly different. Some of the refactoring steps were so simple that any modern IDE can handle it without even pausing (rename field, move declaration, delete unused code), while others were very highly involved changes that could have long reaching impacts across the entire system, most notably "introduce polymorphism". So in terms of the book, renaming a variable is equivalent to introducing a series of classes and polymorphism into your application. Perhaps what the book needs is some sort of difficulty rating, that way I at least get the sense the author realizes not all refactorings were created equal.

Rants about difficult levels aside, this book really does turn into a reference book. It simply lists every refactoring, no matter how trivial, and tells the motivation, process, and an example (or several). That's it. The motivation is almost never more than a paragraph or two, so in terms of hard thinking, you won't be doing much for this book. I would certainly not recommend this book to a programming book club; we found ourselves struggling to come up with topics of conversation at times since everything was so straightforward. And we found ourselves skipping most, if not all, of the examples by the end of the book. It just wasn't worth the time to read how to do the refactoring.

I won't say that the book is bad, because it isn't. And it certainly isn't a bad concept. But I will say it wasn't an exciting book. I didn't learn anything new that I'm excited to implement in my daily programming life. It's like brushing my teeth; it's not fun, it's not exciting, but it's very important to do.]]> 4.30 1999 Refactoring: Improving the Design of Existing Code
author: Martin Fowler
name: Michael
average rating: 4.30
book published: 1999
rating: 3
read at: 2020/12/22
date added: 2020/12/25
shelves: programming
review:
I went into this book with pretty large expectations. I had heard the book was great, but I realize now I never really heard why it was great. The rumor mill just told me that it was the book to read if you wanted to learn refactoring.

Unfortunately, I found myself very disappointed by the book. The first four chapters could be compared to Clean Code in many ways; they introduce some good practices of coding and how to perform a refactoring safely. But beyond that it is just a reference list of all the different types of refactoring. On some level I understand why he went into as much detail as he did, but there were a few that just felt extremely long-winded for how simple they are. I don't really need an example of `rename field`.

But that was another criticism I had about this book; the refactoring difficulty levels were wildly different. Some of the refactoring steps were so simple that any modern IDE can handle it without even pausing (rename field, move declaration, delete unused code), while others were very highly involved changes that could have long reaching impacts across the entire system, most notably "introduce polymorphism". So in terms of the book, renaming a variable is equivalent to introducing a series of classes and polymorphism into your application. Perhaps what the book needs is some sort of difficulty rating, that way I at least get the sense the author realizes not all refactorings were created equal.

Rants about difficult levels aside, this book really does turn into a reference book. It simply lists every refactoring, no matter how trivial, and tells the motivation, process, and an example (or several). That's it. The motivation is almost never more than a paragraph or two, so in terms of hard thinking, you won't be doing much for this book. I would certainly not recommend this book to a programming book club; we found ourselves struggling to come up with topics of conversation at times since everything was so straightforward. And we found ourselves skipping most, if not all, of the examples by the end of the book. It just wasn't worth the time to read how to do the refactoring.

I won't say that the book is bad, because it isn't. And it certainly isn't a bad concept. But I will say it wasn't an exciting book. I didn't learn anything new that I'm excited to implement in my daily programming life. It's like brushing my teeth; it's not fun, it's not exciting, but it's very important to do.
]]> <![CDATA[Algorithms to Live By: The Computer Science of Human Decisions]]> 29566029
In a dazzlingly interdisciplinary work, Brian Christian and Tom Griffiths show how algorithms developed for computers also untangle very human questions. They explain how to have better hunches and when to leave things to chance, how to deal with overwhelming choices and how best to connect with others. From finding a spouse to finding a parking spot, from organizing one's inbox to peering into the future, Algorithms to Live By transforms the wisdom of computer science into strategies for human living.]]> 351 Brian Christian 1250118360 Michael 0 4.13 2016 Algorithms to Live By: The Computer Science of Human Decisions
author: Brian Christian
name: Michael
average rating: 4.13
book published: 2016
rating: 0
read at:
date added: 2020/06/03
shelves: audiobook, programming, to-read
review:

]]> C# in Depth 38088316 C# has changed significantly since it was first introduced. With the many upgraded features, C# is more expressive than ever. However, an in depth understanding is required to get the most out of the language.

C# in Depth, Second Edition concentrates on the high-value features that make C# such a powerful and flexible development tool. Rather than re-hashing the core of C# that's essentially unchanged since it hit the scene, this book brings readers up to speed with the features and practices that have changed with C# from version 2.0 onwards.

This completely revamped Second Edition is extremely current, covering the new features of C# 4 as well as Code Contracts. Readers will master the subtleties of C#, learning how to tame the trickier bits and apply them to best advantage. Insider tips teach readers how to avoid hidden pitfalls. This book is designed for readers who have learned the basics of C#.

]]> 528 Jon Skeet 1617294535 Michael 5 own, programming 4.50 2008 C# in Depth
author: Jon Skeet
name: Michael
average rating: 4.50
book published: 2008
rating: 5
read at: 2020/05/29
date added: 2020/06/03
shelves: own, programming
review:

]]> <![CDATA[The Mythical Man-Month: Essays on Software Engineering]]> 13629 The added chapters contain (1) a crisp condensation of all the propositions asserted in the original book, including Brooks' central argument in The Mythical Man-Month: that large programming projects suffer management problems different from small ones due to the division of labor; that the conceptual integrity of the product is therefore critical; and that it is difficult but possible to achieve this unity; (2) Brooks' view of these propositions a generation later; (3) a reprint of his classic 1986 paper "No Silver Bullet"; and (4) today's thoughts on the 1986 assertion, "There will be no silver bullet within ten years."

]]> 322 Frederick P. Brooks Jr. 0201835959 Michael 0 to-read, programming, own 4.00 1975 The Mythical Man-Month: Essays on Software Engineering
author: Frederick P. Brooks Jr.
name: Michael
average rating: 4.00
book published: 1975
rating: 0
read at:
date added: 2020/02/03
shelves: to-read, programming, own
review:

]]> <![CDATA[Working Effectively with Legacy Code]]> 44919
In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars, techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control.

The topics covered include:

Understanding the mechanics of software change, adding features, fixing bugs, improving design, optimizing performance
Getting legacy code into a test harness
Writing tests that protect you against introducing new problems
Techniques that can be used with any language or platform, with examples in Java, C++, C, and C#
Accurately identifying where code changes need to be made
Coping with legacy systems that aren't object-oriented
Handling applications that don't seem to have any structure

This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.]]> 464 Michael C. Feathers 0131177052 Michael 0 to-read, programming, own 4.13 2004 Working Effectively with Legacy Code
author: Michael C. Feathers
name: Michael
average rating: 4.13
book published: 2004
rating: 0
read at:
date added: 2020/02/03
shelves: to-read, programming, own
review:

]]> <![CDATA[Test-Driven Development: By Example]]> 387190 216 Kent Beck 0321146530 Michael 0 programming, to-read 4.10 2002 Test-Driven Development: By Example
author: Kent Beck
name: Michael
average rating: 4.10
book published: 2002
rating: 0
read at:
date added: 2020/01/27
shelves: programming, to-read
review:

]]> <![CDATA[The Art of Unit Testing: With Examples in .NET]]> 6487349 Rare book 296 Roy Osherove 1933988274 Michael 5 programming 4.08 2009 The Art of Unit Testing: With Examples in .NET
author: Roy Osherove
name: Michael
average rating: 4.08
book published: 2009
rating: 5
read at:
date added: 2020/01/23
shelves: programming
review:

]]> <![CDATA[Design Patterns: Elements of Reusable Object-Oriented Software]]> 85009
The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk.

]]> 416 Erich Gamma 0201633612 Michael 0 to-read, programming 4.19 1994 Design Patterns: Elements of Reusable Object-Oriented Software
author: Erich Gamma
name: Michael
average rating: 4.19
book published: 1994
rating: 0
read at:
date added: 2020/01/21
shelves: to-read, programming
review:

]]> <![CDATA[CompTIA A+ Certification All-in-One Exam Guide (A+ Certification All in One Exam)]]> 391120 The Number-One CompTIA A+ Exam Guide

"The most comprehensive publication on the market." -Certification Magazine

Completely revised and updated for all four new exams and reviewed and approved by CompTIA, this definitive volume covers everything you need to know to pass the CompTIA A+ Essentials exam and CompTIA A+ Exams 220-602, 220-603, and 220-604. Mike Meyers, the leading authority on CompTIA A+ certification and training, has helped hundreds of thousands of people pass the CompTIA A+ exams-and now he can help you too. Inside, you'll find detailed coverage of the exam format, helpful exam tips, end-of-chapter practice questions, and hundreds of photographs and illustrations. After you ace the exams, this comprehensive guide will serve as an essential on-the-job reference.

Full details on all exam objectives, including how to:

Work with CPUs, RAM, and motherboards Install, partition, and format hard drives Work with portable PCs, PDAs, and wireless technologies Install, upgrade, and troubleshoot Windows 2000 Professional and Windows XP Install sound and video cards Manage printers and connect to networks Implement security measures Understand safety and environmental issues Establish good communication skills and adhere to privacy policies

The CD-ROM features:

Eight full practice exams covering CompTIA A+ Essentials and Exams 220-602, 220-603, & 220-604 One hour of LearnKey video training featuring Mike Meyers teaching key A+ topics Electronic copy of the book Complete exam objective map for all four exams List of official CompTIA A+ acronyms Useful tools and utilities for PC technicians ]]> 1171 Mike Meyers 0072263113 Michael 0 to-read, programming, own 4.03 2006 CompTIA A+ Certification All-in-One Exam Guide (A+ Certification All in One Exam)
author: Mike Meyers
name: Michael
average rating: 4.03
book published: 2006
rating: 0
read at:
date added: 2020/01/21
shelves: to-read, programming, own
review:

]]> <![CDATA[Concurrency in .NET: Modern patterns of concurrent and parallel programming]]> 42052388 568 Riccardo Terrell 1617292990 Michael 1 programming, own
There are a litany of errors, ranging from typos to copy-pasted links and sentences. I took to pulling out an orange highlighter every time I read just so I could record all the errors. Most don't hamper your understanding, which is good, but the real issue is that it speaks to the quality of the book and its editing. If they can't even catch such simple errors, how can I trust the book?

The book states early on that a knowledge of F# is not necessary to read, and that you can get along just fine. Yet every chapter, half the pages will be in F# and expect me to understand what the language is doing. And if you are going to read the book, do yourself a favor and don't read the appendix on F#; it will only serve to confuse you and in some spots give false information.

I really wanted to like the book, I have purchased many Manning publications in the past, but there was just too much wrong with it. I may try again some day when I have more time on my hands to really focus in and do web-searches for all the concepts, but I imagine I won't get a full benefit from the book until I know F# in depth.]]> 3.58 Concurrency in .NET: Modern patterns of concurrent and parallel programming
author: Riccardo Terrell
name: Michael
average rating: 3.58
book published:
rating: 1
read at:
date added: 2020/01/15
shelves: programming, own
review:
I never got to the end of this book because of how poorly it was written. Every explanation is done in a long-winded manner that only serves to confuse me more than it does explain things. The first chapter starts off with an explanation about the difference between parallelism and concurrency; it took this author an entire chapter to confuse me about the concept, and it took the authors of The Pragmatic Programmer (which I started reading a while after) only one paragraph. I was forced to seek external sources just to understand the simple concept.

There are a litany of errors, ranging from typos to copy-pasted links and sentences. I took to pulling out an orange highlighter every time I read just so I could record all the errors. Most don't hamper your understanding, which is good, but the real issue is that it speaks to the quality of the book and its editing. If they can't even catch such simple errors, how can I trust the book?

The book states early on that a knowledge of F# is not necessary to read, and that you can get along just fine. Yet every chapter, half the pages will be in F# and expect me to understand what the language is doing. And if you are going to read the book, do yourself a favor and don't read the appendix on F#; it will only serve to confuse you and in some spots give false information.

I really wanted to like the book, I have purchased many Manning publications in the past, but there was just too much wrong with it. I may try again some day when I have more time on my hands to really focus in and do web-searches for all the concepts, but I imagine I won't get a full benefit from the book until I know F# in depth.
]]> <![CDATA[JavaScript: The Good Parts: The Good Parts]]> 6590008
Considered the JavaScript expert by many people in the development community, author Douglas Crockford identifies the abundance of good ideas that make JavaScript an outstanding object-oriented programming language-ideas such as functions, loose typing, dynamic objects, and an expressive object literal notation. Unfortunately, these good ideas are mixed in with bad and downright awful ideas, like a programming model based on global variables.

When Java applets failed, JavaScript became the language of the Web by default, making its popularity almost completely independent of its qualities as a programming language. In The Good Parts, Crockford finally digs through the steaming pile of good intentions and blunders to give you a detailed look at all the genuinely elegant parts of JavaScript,

SyntaxObjectsFunctionsInheritanceArraysRegular expressionsMethodsStyleBeautiful featuresThe real beauty? As you move ahead with the subset of JavaScript that this book presents, you'll also sidestep the need to unlearn all the bad parts. Of course, if you want to find out more about the bad parts and how to use them badly, simply consult any other JavaScript book.

With The Good Parts, you'll discover a beautiful, elegant, lightweight and highly expressive language that lets you create effective code, whether you're managing object libraries or just trying to get Ajax to run fast. If you develop sites or applications for the Web, this book is an absolute must.]]> 100 Douglas Crockford 0596107137 Michael 4 own, programming 4.24 2008 JavaScript: The Good Parts: The Good Parts
author: Douglas Crockford
name: Michael
average rating: 4.24
book published: 2008
rating: 4
read at: 2019/03/21
date added: 2019/12/18
shelves: own, programming
review:

]]> <![CDATA[Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)]]> 6607720
Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin 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 a 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.]]> 466 Robert C. Martin Michael 5 own, programming 4.42 2007 Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)
author: Robert C. Martin
name: Michael
average rating: 4.42
book published: 2007
rating: 5
read at:
date added: 2019/12/18
shelves: own, programming
review:

]]> ASP.NET Core in Action 37836790
ASP.NET Core in Action is for C# developers without any web development experience who want to get started and productive using ASP.NET Core to build web applications.]]> 750 Andrew Lock 1617294616 Michael 5 own, programming 4.55 2018 ASP.NET Core in Action
author: Andrew Lock
name: Michael
average rating: 4.55
book published: 2018
rating: 5
read at:
date added: 2019/12/18
shelves: own, programming
review:

]]>