Want to Read saving…. Want to Read Currently Reading Read. Other editions. Enlarge cover. Error rating book. Refresh and try again. Open Preview See a Problem? Details if other :.
Thanks for telling us about the problem. Return to Book Page. Get A Copy. Paperback , pages. Published April 6th by Yaknyam Press first published More Details Other Editions 3. Friend Reviews. To see what your friends thought of this book, please sign up. To ask other readers questions about A Philosophy of Software Design , please sign up.
Is it well optimized on iPhone's iBook? Code snippets are always a bit challenging, but they are quite concise and don't necessarily …more FWIW, I read the kindle ebook version and that was fine. Code snippets are always a bit challenging, but they are quite concise and don't necessarily add a ton of value.
See 1 question about A Philosophy of Software Design…. Lists with This Book. Community Reviews. Showing Average rating 4. Rating details. Sort order. Start your review of A Philosophy of Software Design. Aug 13, Cesar Diez Sanchez rated it liked it. I have mixed feelings in order to rate the book. First of all, it's worth saying that I wish I had read this book when I was in college or just after starting my professional career.
The author has clear and good ideas about how Software should be written properly. I think this should be a mandatory read for everyone studying computer science, and it should be used as a tool while developing a small project.
From a student point of view, I would probably give a 4 or 5 stars review. I don't consider I have mixed feelings in order to rate the book. I don't consider myself an incredible programmer, but I've been in the industry for a while. I'm going to give constructive feedback in order to try to help the author to create a second version of the book with some improvements.
I don't know if the author tried to avoid using well-known terms in the software development world in order to tag those explanations, but I think it could have been a good idea using terms since the reader could assimilate those concepts easily.
While reading the book I sometimes felt I got lost in the author's thoughts and non-contextual examples used in the book. It could have been helpful for the reader to have a small open-source project as a guide for the concepts explained in the book.
Well-documented commits in a repository could be used to define each of the refactoring steps towards creating a well-designed system. Ideas brought from the Effective Java book and other concepts like hiding implementation details, using single responsibility principle, don't repeat yourself DRY , continuous integration, continuous delivery, and so on; are explained in a very educational way and I think the author should mention some of these terms when talking about these concepts because it would help new developers to communicate what they've read with their colleagues.
The book's edition could improve since I've spotted some mistakes in the author's grammar and syntax. Hope that improves in a posterior edition. Sometimes the author focuses on really small details that are difficult to digest when developing a product, like "general-purpose" and "special-purpose" interfaces.
Overall I agree with the majority of the concepts explained, but I think the chapter 15 "Write The Comments First" and the others chapters talking about comments could be misleading. Comments are good as an abstract way to explain certain kind of implementation, for instance when doing tricky things like developing APIs or specific case scenarios with algorithms involved. Instead, try to use good naming and right design patterns and concepts, the methods should be self-explanatory.
So instead of writing documentation explaining what your code does, try to write more tests to cover what the developer is trying to do. I do agree with the author though, that TDD could sometimes not be a good way to approach programming. Some key points of the book: - Decompose your problems - Delaying tests, documentation, and refactoring means not doing it. Later equals never. It's a rule I can verify it works in the industry.
It's a very important rule that is going to help make behavioral changes in your classes. Hope this was useful. View 1 comment. I really enjoyed the first half of the book, when the author discusses complexity, deep vs shallow modules, information hiding, general vs special-purpose interfaces, levels of abstraction, the criteria to split or keep code methods together, pull push? It made me see modularity and complexity in a slightly different way. The second half of the book is not so great.
The emphasis on code comments goes against the idea of Clean Code. The chapter on name and the chapter on consistency are very simplistic, as most of the other chapters in the second half. Not much original content here. I recommend the book for its first half. View all 4 comments. Sep 23, Rafael rated it it was amazing. I really enjoyed reading this book. Ousterhout's book is a very brief book pages , but it builds a thoughtful and solid work about how to design software to avoid complexity.
The book reasonings are a higher level of abstraction than the typical book about software design, however, it also turns to very good specific examples when it's needed.
I liked how the author is able to discover a convincing corpus of interesting principles, practices, reflections and "red flags" about the design of s I really enjoyed reading this book.
I liked how the author is able to discover a convincing corpus of interesting principles, practices, reflections and "red flags" about the design of software by pulling out his fundamental thesis against complexity in software The book is full of great insights. A lot of these ideas are not new in our field, but they are shown in a very clear way and, above all, the author relates each of them with the complexity leitmotiv. I especially like principles like "deep vs shallow modules", "different layers should have different abstractions", "design it twice" or "the increments in software development should be abstractions, not features".
Finally, I like the book is very courageous. Ousterhout dares to express his critiques and doubts about some ideas very well-established in the developers' collective conscience, like the "comments are always an error" of the Clean Code movement, agile development leading to a mainly tactical programming or TDD: "Although I am a strong advocate of unit testing, I am not a fan of test-driven development.
The problem with test-driven development is that it focuses attention on getting specific features working, rather than finding the best design. This is tactical programming pure and simple, with all of its disadvantages.
This turned out to be a mixed bag for me. Some chapters are really good, whereas some e. Having said that, most of the chapters are examples of very clear writing, backed not only by strong pedagogical foundations, but also the industrial experience of the author that had to support complex software products used by hundreds of thousands of users; and I wouldn't expect anything le This turned out to be a mixed bag for me.
Having said that, most of the chapters are examples of very clear writing, backed not only by strong pedagogical foundations, but also the industrial experience of the author that had to support complex software products used by hundreds of thousands of users; and I wouldn't expect anything less than that from Ousterhout. RAMCloud , then most of the advice will make sense to you, outlining straightforwards methods and techniques of dealing with complexity in your, or, let's be realistic, mostly somebody else's, software designs.
Of course, some of that advice is so generic that it'll even apply if you're working on LOB Line of Business apps, or boring, good old CRUD apps just don't get overexcited. As a unique selling point of this book, I might add that it includes probably the most in-depth discussions on how to write and structure source code comments, and their relationships to source code control, overall documentation, pitfalls, etc. Almost all of the great software designers I know try to draw important and useful relationships between effective communication in natural language and software programming, and Ousterhout is no exception.
Another nice aspect of the book is something external to it: Ousterhout created a discussion forum on Google Groups dedicated to the book, and I strongly recommend reading some of the discussions and criticism because some of them will definitely enrich your understanding of the book, especially the discussions about practical, strongly-typed functional programming, which, in a sense, strongly relates to the author's "define errors out of existence" principle.
I can't say I learned much from this book, but I've still enjoyed it, and can recommend it to people who have a few years of software industry experience, or undergraduates working on software-intensive projects. Apart from that, I think I'll rely on this book when I need to communicate some of my ideas to junior software developers some of the examples and communication techniques in the book are too good to ignore!
Jan 19, Mircea rated it it was amazing. Oct 27, Michael Dubakov rated it liked it Shelves: programming. Book with a promising name, but very mixed content. Two good thoughts: 1. Modules should be deep. It is better to have fewer deep modules than more shallow modules 2. The increments of development should be abstractions, not features.
When you need an abstraction, invest time and design it clearly There are many good advices, but on my opinion the book is not deep enough to have this promising title. Also, it's a crime to spend 30 pages of to how to write comments. I gave this a pretty low rating for me. I still think the book is valuable to read, even though it frustrated me immensely personally.
I whole heartedly agree with the premise that software design is important and as developers we should be focused on reducing complexity. There are plenty of parts in this book I would give 5 stars, but there are others I would easily give 1. I found this book incredibly polarizing personally.
In order to stay abreast of the cutting-edge research in the field, it is vital for academics and practitioners to stay involved and studied with the latest publications.
This volume contains a wide range of subject matters, levels of technical expertise and development, and new technological advances within the field, and will serve as an excellent resource both as a handbook and a research manual. This Guide provides an ambitious state-of-the-art survey of the fundamental themes, problems, arguments and theories constituting the philosophy of computing. A complete guide to the philosophy of computing and information.
Comprises 26 newly-written chapters by leading international experts. Provides a complete, critical introduction to the field. Each chapter combines careful scholarship with an engaging writing style. Includes an exhaustive glossary of technical terms. Ideal as a course text, but also of interest to researchers and general readers.
The traditional debate among philosophers of mathematics is whether there is an external mathematical reality, something out there to be discovered, or whether mathematics is the product of the human mind. This provocative book, now available in a revised and expanded paperback edition, goes beyond foundationalist questions to offer what has been called a "postmodern" assessment of the philosophy of mathematics--one that addresses issues of theoretical importance in terms of mathematical experience.
By bringing together essays of leading philosophers, mathematicians, logicians, and computer scientists, Thomas Tymoczko reveals an evolving effort to account for the nature of mathematics in relation to other human activities. These accounts include such topics as the history of mathematics as a field of study, predictions about how computers will influence the future organization of mathematics, and what processes a proof undergoes before it reaches publishable form.
This expanded edition now contains essays by Penelope Maddy, Michael D. Resnik, and William P. Thurston that address the nature of mathematical proofs. The editor has provided a new afterword and a supplemental bibliography of recent work. Software has become a key component of contemporary life and algorithmic techniques that rank, classify, or recommend anything that fits into digital form are everywhere.
This book approaches the field of information ordering conceptually as well as historically. Building on the philosophy of Gilbert Simondon and the cultural techniques tradition, it first examines the constructive and cumulative character of software and shows how software-making constantly draws on large reservoirs of existing knowledge and techniques. It then reconstructs the historical trajectories of a series of algorithmic techniques that have indeed become the building blocks for contemporary practices of ordering.
Developed in opposition to centuries of library tradition, coordinate indexing, text processing, machine learning, and network algorithms instantiate dynamic, perspectivist, and interested forms of arranging information, ideas, or people.
Embedded in technical infrastructures and economic logics, these techniques have become engines of order that transform the spaces they act upon. This book is designed to provide easy means of problem solving based on the science philosophical and logical rules that lead to effective and reliable software at the service of professional earth system scientists through numerical scientific computation techniques. Science aspects that are concerned with earth systems need numerical computation procedures and algorithms of data collected from the field measurements or laboratory records.
The same is also valid for data processing in social sciences and economics. Some of the data assessment and processing procedures are at the large scales and complex, and therefore, require effective and efficient computer programs. Data reduction and graphical display in addition to probabilistic and statistical calculations are among the general purposes of the book. Especially, potential users of MATLAB in earth systems need a guidance book that covers a variety of practically applicable software solutions.
Discover the untapped features of object-oriented programming and use it with other software tools to code fast, efficient applications. Key Features Explore the complexities of object-oriented programming OOP Discover what OOP can do for you Learn to use the key tools and software engineering practices to support your own programming needs Book Description Your experience and knowledge always influence the approach you take and the tools you use to write your programs.
With a sound understanding of how to approach your goal and what software paradigms to use, you can create high-performing applications quickly and efficiently. A strong stance against exceptions Chapter 10 was an interesting read. John argues that exceptions introduce one of the worst sources of complexity and advocates for writing code that needs no exceptions to run.
This is a section that seems to build on John's own experience, and him analyzing Windows APIs and does not bring classroom examples. For backend systems, I view exceptions as a good thing: as long as they are thoroughly monitored and alerted on , targeting a zero exceptions policy. For client-side software like mobile apps and desktop apps, I agree that exceptions make for more complex logic. In these cases, exception masking - and logging - that John suggests in Chapter 10 can be a good solution.
He lists the option of deciding that it's fine to crash the application on an exception: which would not fly in areas like mobile development. Calling out event-driven programming as something that makes the code less obvious Chapter 18 is an interesting take, that I would have hesitated to phrase as such. While event-driven programming is certainly more complex, due to no clear flow of control, in real-world scenarios, this is a necessity. Both in the case of distributed systems, as well as multi-threaded environments, there is no other option.
John's suggestion to add a comment for event handlers doesn't cut it in my book. Instead, monitoring errors, alerting for backend code and logging, uploading, and analyzing logs for client-side applications is one way to stay on top of the system working correctly at all times. Much of modern programming, from messaging services to frameworks like Fx is moving towards an asynchronous model, where dealing with this complexity is part of the job.
John is quite in favor of writing comments , an approach I have less love for. Three chapters - chapters 12, 13, and 15 are dedicated to this topic, looking at it from different angles.
In general, I like to think of inline comments being an invitation for refactoring. This is especially true for code that is well-tested with unit and other automated tests.
For junior engineers, the advice of writing comments first Chapter 15 on is solid. The part I do agree with John is how comments should describe things that aren't obvious from the code Chapter After exchanging emails with John, we both agreed that if there are important ideas that cannot be conveyed through the code, then comments are appropriate for them. Still, I like to challenge the code instead, asking if refactoring would help eliminate the need for a comment.
While the book does a good job covering architecture concepts when writing code, there are several areas that it does not touch on. Most of these are outside the scope of the software design course itself. However, some reference to these would have been useful. Writing up, sharing, and debating design with other peers is a practice more and more common in tech companies.
This includes both whiteboarding and presenting to a group of peers, as well as more formal RFC-like design processes. While it might be less applicable to the course John taught, it's a practice that comes with many benefits.
These days, as shared editing and commenting tools are more common, with editors like Google Docs and O Sharing design ideas upfront and opening a debate using these tools is a great way to build more sturdy architecture. Especially when applying the "design it twice" principle, and writing up alternative designs considered, and the tradeoffs why the other design was not chosen.
Testing was absent from the book, save for the last part, mentioned at the end of the book, in In my view, good architecture and testability go hand-in-hand and would have welcomed this topic mentioned earlier. John dedicates discussing strategies to modify existing code in-depth in Chapter His two pieces of advice are on staying strategic in modifying the design and maintaining the comments.
This does not match my reality. The surest and safest way I know to modify existing code is to have tests. With tests in place, go ahead and make whatever change is necessary - and sensible. If there are no tests, start by writing tests. If there are tests, major refactors that wildly modify the existing design can also fly - the tests should give a safety net to do so.
And with tests in place, comments become an afterthought: if there is a test for it, a comment is not that necessary. Note that after exchanging emails with John, he pointed out he focused the book on architecture, treating other topics deliberately out of scope.
The book is an easy read, thanks to its short sections and good bolding. It lends itself to both skimming through, and in-depth reading. The concepts are fresh and a welcome read. Most importantly, the book stays humble, does not try to convince, but offers perspectives backed by easy to follow examples.
I very much recommend the first half of the book - chapters and chapter 14 - for all software engineers to read , digest, and consider applying.
0コメント