software engineering literature topic home

An artist needs to know the tools of his trade, master materials and techniques. But no matter your specialty and technical capabilities, you'll always be affected by the human factors of the discipline. Engineering literature, specifically for software or not (due to the young age of informatics, it helps to look at other, more established branches) distinguishes the professional from the hobbyist, provides the terms, patterns, and proven approaches, and helps in dealing with the related project leadership and management.

I'm proud to have read many classics and learned invaluable lessons from these books:

Tom Roden and Ben Williams, Fifty Quick Ideas to Improve Your Retrospectives; a double page is dedicated to each idea (with a barely relevant illustration to lighten up the layout), describing the issue, key benefits, and how to make it work; if you already know about retrospectives and follow some Agile process, this can give some new impulses (and it's a quick read, anyway); Neuri Consulting, 2015

Mark Seemann, Code That Fits in Your Head; Heuristics for Software Engineering; the book introduces sane software engineering basics like checklists, Git source control, automated testing, and incremental development in vertical slices; none of that is new, and many books (like the Clean Code series) have already been written about them. The unique approach of this book is a single example project whose code accompanies and directly (and very concretely) motivates each practice. For an experienced programmer, this refresher (and the occasional tip) makes this a worthwhile read despite having little new information; a beginner finds a good and uncontroversial set of practices to start with. The casual writing style and many anecdotes virtually guarantee that this book will be read cover-to-cover, ample references and bibliography provide many pointers to further one's education; Pearson, 2022

Gojko Adzic, Specification by Example; the author argues that the best way to capture requirements is to write executable specifications in the form of acceptance tests; the main benefit comes from the collaboration of user (representatives) / business stakeholders, developers and testers, who develop a shared understanding and vocabulary; care must be taken to avoid mixing technical concepts with the specification, as the end goal is living documentation that surpasses the actual implementation and provides benefits beyond regression testing. The book provides many guidelines and is filled with case studies and snippets from interviews, but doesn't offer any concrete examples, neither as obfuscated real-life data nor a demo project; Manning, 2011

Kent Beck, Extreme Programming Explained; Second Edition; short introduction to one of the core Agile methods that is especially focused on the programming side; the author highlights the core tenets, compares with the other agile practices, and offers some anecdotes; other books (like the Clean Code series) offer deeper and more applicable material, so this one's relevance is mostly for the historical perspective; Addison-Wesley, 2005

Nassim Nicholas Taleb, Antifragile; Things that Gain from Disorder; the opposite of fragility is not robustness, but there's antifragility; i.e. things that actually benefit from random events or shocks, and many of those can be found in nature, whereas the things that our techno-society develops are often the most fragile (employment-type jobs, infrastructure, finance). By trying to maintain stability for a long time, our society sets itself up for occasional but catastrophic disruptions; it would be better to promote localized independence; the Swiss governance model resembles the Roman empire. The author references medicine, the mafia, global history, and Arabic wisdoms in a writing style that is strenuous (in my opinion the author is too fond of his intellectualism and his personal encounters with the intelligentsia) but also enlightening. A strikingly topical read for today's crises (financial turmoil, pandemic, war); Penguin Books, 2012

Robert C. Martin, Clean Craftsmanship; Disciplines, Standards, and Ethics; great recap of Agile practices like TDD, Refactoring, and collaborative programming. The author aims both for breadth and width, covering a wide range of topics (including historical backgrounds), yet also going into details with a classification of test doubles, several programming examples (some even captured on video), and a deep dive into the history of version control. The second half of the book pivots from the technical to the soft-skill topics of customer / manager relations, estimations, and quality. The author argues for a professional code of ethics that every programmer should adhere to, and shows how each rule is motivated by Agile practices. If you liked previous books from Uncle Bob, you'll certainly love this one, too. As the fifth book in this series, it's a bit jumbled almost by nature, but the mixture of technical and social stuff also gives the book a nice balance. To me, it's astounding that Uncle Bob still comes up with new insights, and his contagious enthusiasm makes you want to become a better developer, too. Pearson, 2021

Cyrille Martraire, Living Documentation; Continuous Knowledge Sharing by Design; a heavy proponent of modern development approaches like BDD, the author highlights the shortcomings of traditional, documentation-heavy approaches (in Word or dedicated tools like Wikis), and emphasizes internal documentation that is close to the source, e.g. via custom code annotations that can either be directly used in the IDE or be extracted via custom tools (e.g. generating diagrams via Graphviz). This avoids the need for huge external documentation, so only a few evergreen documents with unchanging content need to be maintained; the remainder of the communication is spontaneous, person-to-person. The author echoes some ideas I've had, and though many are corroborated by code examples and stories, the book offers impulses and food for thought, but unfortunately no complete solution. The diagrams and comics (drawn by the author's wife) are meant to lighten up the text- and code-heavy contents, but are just an annoying distraction; overall, this important topic (that has the potential to create an instant classic like Design Patterns or Refactoring) is not tackled satisfactorily yet; Pearson 2019

Eric Steven Raymond, The Cathedral and the Bazaar (and other collected essays); history of hackers with the two tribes of ITS / LISP vs. Unix / C; how Linux toppled the belief that large-scale development cannot be done by a loosely connected group of volunteers; the birth of the open source movement (and the creation of Mozilla); the cultural expectations of open source projects, and how this evolved in astounding unison; great insights from one of the (inadvertent) poster boys of the revolution, offering a unique, sometimes deeply philosophical view of the now well-established community of volunteers; self-published on the author's website; 2002

Gojko Adzic, Humans vs. Computers; humorous short stories (more like blog posts) about computer bugs and their funny or annoying effects in the real world; fun and easy to read, but also containing tidbits of software / security / usability engineering advice (more as a refresher; though the last chapter is dedicated to common mistakes and misconceptions and how to avoid them, it's lighter than even Joel Spolski's series of blog posts; Neuri Consulting, 2017

Ross Anderson, Security Engineering; A Guide to Building Dependable Distributed Systems, 3rd Edition; an impressive 1000+ pages tome that covers all corners of (computer and general) security; peppered with captivating examples (including the NSA leaks, the author describes the persons and psychology of attackers, the usability of security devices, does a broad sweep across cryptography and ciphers, common tools and protocols, then covers the whole IT stack from operating systems to networks and the modern mobile web service world, segues along warfare, copyright, election safety, surveillance and terrorism, and ending with risk management, secure lifecycles, and certifications; naturally, this cannot go into much detail (but there are great many references), but the author succeeded in collecting likely the most comprehensive overview and managed to put in a great deal of information, refreshers, and helps the reader going through it by a vivid style and great many practical examples and stories; Wiley, 2020

James Coplien and Gertrud Bjørnvig, Lean Architecture: for Agile Software Development; the first half recounts the fundamentals of the Lean philosophy and its roots in manufacturing, with its tenets of preventing waste and rework, and contrasts that with the Agile manifesto's bias towards collaborative reaction to change and doing things at the last responsible moment; apart from that clever confrontation, nothing new can be found here; the second half segues into architecture that is mostly defined by code instead of documentation, yet tries to closely follow the customer / user perspective; using a money transfer as an example, the book argues that domain classes (what the system is) have different stability than functionality (what the system does), that the complexities are better captured in use case scenarios than Agile's simple user stories, and offers an extension of the classic object-oriented MVC design in the form of Data, Context, and Interaction (DCI architecture), with the example sketched in both Ruby and C++; with the first half of the book only tangentially related to DCI, the second half cannot develop a fully convincing case, sticking just to one simplistic example which fails to prove the superiority in the face of future changes; implementations in other languages are given in the appendix, but without further commentary (and one instance unnecessarily using a different example domain); doing DCI in Java is difficult, and the referenced Qi4J framework apparently has been abandoned by now, so despite the good intentions of the authors, this probably has far less practical applicability for most readers; Wiley, 2010

Robert C. Martin, Clean Agile; Back to Basics; very interesting inside look into the history of the Agile movement, its reasons, and how it often is misunderstood and only poorly implemented (as a diatribe I can very well emphasize with, as the same has been happening to me; many of Uncle Bob's anecdotes have an eery similarity to what has happened to me); this is the more surprising as the manifesto got so many things right from the beginning, but then companies focused on the business and project practices while neglecting the programming practices, and got hooked on certifications and "scaling agile" frameworks; despite only being a personal opinion piece (which the book disclaims early on), very few books have resonated to well with me; it is a heartening appeal to (finally) make agile right, and points to the Software Craftsmanship movement for a solution; Pearson Education, 2020

Adam Tornhill, Software Design X-Rays; Fix Technical Debt with Behavioral Code Analysis; with the simple idea of using the change history of the revision control system, the author shows analysis steps for files, individual changes, and modules, using chained Git commands, an open source tool, and a commercial offering that the author is associated with; interesting approach that takes the simple Git wrappers that I've come up with much further; Pragmatic Programmers, 2018

John Ousterhout, A Philosophy of Software Design; complexity is caused by dependencies and obscurity, which can be tackled by strategic programming and an investment mentality instead of tactical minimal changes; modules should be deep (small interface and large hidden implementation) to have proper information hiding and the right abstractions; with few examples and anecdotes, the author gives very practical and convincing advice, and clearly marks the few controversion parts of his (timeless) advice; great design tips and style guidelines that I haven't yet found in such concise and compelling form; Yaknyam Press, 2018

David West and Rebecca Rikner, Design Thinking; the key to enterprise agility, innovation and sustainability; tries to bridge the gap between technical engineering and artisanal designing, first by analyzing the traditional conflicts between the disciplines, arguing that in today's complex world of composite systems both are needed to solve the wicked problems, then presenting a list of patterns (following Christopher Alexander's work in architecture as well as the software patterns movement) in the hope to establish the basis of a future joint language; a highly unconventional book (both compared to West's previous Object Thinking and business books in general); unfortunately, the right-brain approach makes it hard to digest for a technical person like me, and readability suffers due to pervasive editing errors and an idiosyncratic layout; Author's Press International, 2018

Tom Hombergs, Get Your Hands Dirty on Clean Architecture; A Hands-on Guide to Creating Clean Web Applications with Code Examples in Java; well-made booklet that illustrates the important features (dependencies and their inversion, controllers, use cases, adapters, services, ports, persistence) and trade-offs (boundary mappings vs. shared models, module visibility) of an hexagonal architecture with examples; revision 0.4; Leanpub, 2019

Bruce Schneier, Secrets & Lies; Digital Security in a Networked World; old but in no way outdated tome on computer and Internet security, starting with basics in cryptography, network defenses, software reliability and testing, social engineering, then arguing about looking beyond prevention (which only works well in general in encryption algorithms, even there is easily defeated through the human component, and will only be successful against casual attacks, not professional or even state-sponsored actors), and into risk management (withstanding a certain length of attack and available financial resources of attackers), deterring attacks through detection and response (by going after the criminals); Wiley, 2000

May-2019 Ralf Westphal, Informed Test-Driven Development; booklet on a TDD variant that emphasizes thinking before coding, in my opinion based on a misunderstanding or narrow interpretation (caused by the often stripped-down and unrealistic TDD examples) — I've practiced TDD always with some thinking ahead; a bit of a saving grace is the interesting approach of starting with a high-level breakdown (often into a simple architectural pattern like a pipeline), mocking subcomponents, then building (and potentially recursively refining) them, using unit tests of the private implementations, which are finally deleted / migrated to the toplevel test; Leanpub, 2014

Carola Lilienthal, Langlebige Software-Architekturen; Technische Schulden analysieren, begrenzen und abbauen; starting with a bit of theory about quality and technical debt, how to achieve it via design patterns and hierarchies, admonishments to prevent erosion of the architecture (also using psychology about chunking), the book devotes a large part to real-life examples to illustrate various good and bad architectures; the author presents a convincing and structured approach, that unfortunately is solely based on a commercial tool (that costs thousands of €), so it'll be hard to directly apply this to one's own work; dpunkt.verlag, 2017

Sam Newman, Building Microservices; Designing fine-grained systems; outlining the characteristic properties of small autonomous distributed systems, and how to get there from monolithic legacy applications, covering both technical and organizational issues, with brief examples from companies like Netflix; O'Reilly, 2015

Sandi Metz and Katrina Owen, 99 Bottles of OOP; A Practical Guide to Object-Oriented Design; using a simple fun Ruby program to discuss implementation approaches, choosing an (unexpected) simplistic first winner, and developing that through (meticulously documented) refactorings into a perfect OO design; evocative illustration of how simple TDD principles and rules help arrive at a good solution; beta-2 ebook, 2016

Gerald M. Weinberg, Perfect Software and other illusions about testing; starting a bit slow, with many mini-examples and philosophical musings, it highlights crucial differences between testing and debugging, and the defensive reactions of testers and developers; the second half is more geared towards project managers, and highlights common fallacies and misconceptions, culminating in vendor and psychological scams; well written, but maybe not the author's best work; Dorset House, 2008

Mary Shaw and David Garlan, Software Architecture; perspectives on an emerging discipline; dated collection of mostly drivel about architecture and design, some case studies taken from academic papers, and some useful characterizations of pipes and filters, event-based, layered, repository, and blackboard systems; interesting to see how those early attempts at formalizing architecture have mostly (practically) fizzled out, and that twenty years later, we're still mostly drawing arbitrary diagrams of boxes and lines when talking about architecture; Prentice Hall, 1996

Gene Kim, Kevin Behr & George Spafford, Projekt Phoenix; Der Roman über IT und DevOps; Neue Erfolgsstrategien für Ihre Firma; first part is a gripping story about a company where everything about IT goes wrong (and one can easily identify with), second part introduces Lean, CI/CD and DevOps approaches for eventual success; an imaginary yet convincing story, a bit light on theory, but it provides ample references to many common works by other authors; O'Reilly, 2015

Andrew Hunt and David Thomas, The Pragmatic Programmer; a philosophy and rules for maintainable code and project success; not as detailed as the newer Clean Code series, but a classic that provides a good summary, unfortunately still not heeded by much of the industry; Addison Wesley, 1999

Erik van Ommeren et al, Design to Disrupt; Mastering Digital Disruption with DevOps; booklet about lean startup ideas taking hold in digital companies, showcasing approaches by Spotify and ING Bank to reorganize highly motivated teams into squads, tribes, chapters, and guilds; Sogeti Labs, 2017

Robert C. Martin, Clean Architecture: A Craftsman's Guide to Software Structure and Design; characteristics of maintainable and extensible applications based on (well-known and previously publicized) principles like SOLID; lamentation that behavior (functionality) is almost always favored over structure (cleanliness); recommends acyclic dependencies towards the domain objects that leads to a hexagonal "ports and adapters" architecture that keeps frameworks, libraries and IO at the outer boundaries; contains valuable nuggets among a lot of repetition and anecdotes; Pearson Education, 2018

Robert C. Martin, The Clean Coder; A Code of Conduct for Professional Programmers; using analogies with other professions (doctors, lawyers), appeals for responsible craftsmanship, following the (agile) rules laid out in Clean Code; TDD, Katas, time management, estimation and collaboration; each chapter starts with a personal story, and brings across the message without additional fluff; book loses a bit of coherence and quality in the later chapters, though; Pearson Education, 2011

Diomidis Spinellis, Code Quality - the Open Source perspective; using freely available code snippets to illustrate various quality attributes (reliability, security, performance, portability, maintainability); practical and encompassing overview, and interesting approach; Pearson, 2006

Toby Segaran, Jeff Hammerbacher, Beautiful Data; visualization, statistics, interpretation and management of data, combining different data sets and making sense of inconsistencies and missing values; O'Reilly, 2009

Andy Oram, John Viega, Beautiful Security; psychology, online commerce and advertising, web of trust, what to measure, and how to detect intrusions and malware; O'Reilly, 2009

Diomidis Spinellis and Georgios Gousios, Beautiful Architecture; the difference between maintainable and messy software systems, REST principles, tricks for virtualization or fault tolerance, open source organization and how to deal with featurism, OO vs. functional programming; a diverse mixture of essays; O'Reilly, 2009

iX Developer, Altlasten im Griff; architecture and design practices, technical debt, dealing with legacy applications, migration strategies for mainframe software and various programming languages; Verlag Heinz Heise, 1/2017

Tim Riley and Adam Goucher, Beautiful Testing; leading professionals reveal how they improve software; short essays on particular techniques like fuzzing, exploratory testing, using statistics, tools for provisioning and collaboration, and how to build communities and cooperation with other stakeholders; O'Reilly, 2010

iX special Multitalent Open Source; enterprise and office applications (and how to customize and interact with commercial software) and IT administration, licensing; Verlag Heinz Heise, 2016

Allen Holub, Holub on Patterns; Learning Design Patterns by Looking at Code; two outrageously beautiful, well-designed real-world examples, discussed pattern by pattern, with an emphasis on the interaction of multiple patterns; design advice and commentary by the author sprinkled in between; short pattern reference at the end; brilliantly complements the famous GoF book; Apress, 2004

Joshua J. Arnold, Özlem Yüce, Black Swan Farming using Cost of Delay, how Maersk Line applied Cost of Delay at the feature level to better prioritize the critical money-earning features that must not be delayed; why project-based releases are bad; Liberio, 2016

Ivars Peterson, Fatal Defect: Chasing Killer Computer Bugs, both a history of the birth of software engineering, with portraits of people like David Parnas and Victor Basili, and recalling of famous incidents like Therac-25 and many minor glitches, to highlight the dangers of program, design, and usability bugs; Times Books, 1995

Matthew Linderman and Jason Fried, Defensive Design for the Web, How to improve error messages, help, forms, and other crisis points; a (somewhat dated) collection of how to handle web application errors and user interaction via forms, search, and help; New Riders, 2004

Robert V. Binder, Testing Object-Oriented Systems; a 1000+-page thick tome about flattening inheritance trees, state machines, testing scopes, automation, and many more; unfortunately, I found very little practical advice; some things are just unnecessarily formulaic versions of basic knowledge I already have, some are just covered by research and have little practical use, and many are so complex or time-consuming that I doubt any company would actually employ; Addison Wesley Longman, 2000.

Krzysztof Cwalina, Brad Abrams, Framework Design Guidelines; Conventions, Idioms, and Patterns for Reusable .NET Libraries; scenario-driven design fundamentals, guidelines around naming, extensibility, exceptions, and patterns; Pearson, 2008

Jaroslav Tulach, Practical API Design; Confessions of a Java Framework Architect; do's and don'ts found during the evolution of the NetBeans IDE, and philosophical musings from the author; Apress, 2008

Peter Schuh, Integrating Agile Development in the Real World; Comparison of XP, Scrum, FDD, Crystal, ASD, DSDM, and Lean; introduction of agile practices, both programming and project disciplines, all with a focus on enterprise development; Charles River Media, 2005

Ken Segall, Insanely Simple; The Obsession that drives Apple's Success; enumerating the values of Apple, as seen from a creative director who closely worked with Apple as well as with traditional corporate clients; vividly illustrated with many personal stories about Steve Jobs and the history of Apple; Portfolio / Penguin, 2012

Donald G. Reinertsen, The Principles of Product Development FLOW; Second generation lean product development; academically grounded rules around queues, variability, batch size, WIP, feedback and decentralization, motivating the move to Agile methodologies in (software) product development, and highlighting differences to manufacturing (where many of these came from); Celeritas Publishing, 2009

Henrik Ingo, Open Life; The Philosophy of Open Source; tracing the history of Linux and hacker culture and its principles of no deadlines, scratching one's own itch, laziness, tolerance, and diversity; including a history of companies going Open Source and how they fared, ending with an outlook on Wikipedia, Creative Commons, etc. that came up at the book's publication date; Self-published on, 2006

Robert C. Martin, Clean Code; A Handbook of Agile Software Craftsmanship; a great (if somewhat jumbled) collection of rules and common wisdoms that most senior devs should know by heart, but often forget to apply in the turbulent daily business; quality is the result of a million selfless acts of care, and caring means being meticulous and test-driven; Pearson Education, 2009

Luke Hohmann, Beyond Software Architecture; Creating and Sustaining Winning Solutions; a broad swipe over Marketecture vs. Tarchitecture, and how the different functions need to collaborate to drive them, discussing business models, licensing, deployment, integration and extension, brand and usability, installation, configuration, and security; covers the entirety of enterprise software development like no other book, unfortunately, each good discussion can only scratch the surface of the topic; Addison-Wesley, 2003

Steven Casey, Set Phasers on Stun and other true tales of design, technology, and human error (second edition); entertaining short stories about accidents and their causes (unfortunately without thorough analysis); Aegean, 1998

Joachim Baumann, Ronald Hötschl, Bastian Spanneberg, Continuous Delivery ein Überblick; short booklet about Agile transition to Deployment Pipeline and Continuous Delivery, the technical as well as organizational challenges for analysis, architecture, dev, build, testing, deployment, and operations; dpunkt.verlag, 2014

Jakob Freund, Bernd Rücker, Praxishandbuch BPMN 2.0; syntax and best practices of business process modeling, from the strategic overview over precise operative models to a technical model that can be fed to a business process engine; contrast with BPEL, XML implementation details, business rules; Carl Hanser Verlag, 2010

Gregor Hohpe, Bobby Woolf, Enterprise Integration Patterns; designing, building, and deploying messaging solutions; a catalog of patterns around messaging, nicely illustrated by architecture diagrams and examples using JMS and MSMQ; Pearson Education, 2004

Martin Fowler, UML Distilled, second edition; a brief recap of the most important diagram types of UML 1.4, with additional commentary on how the author uses these; Addison-Wesley, 2000

Tom DeMarco, Why Does Software Cost So Much? And Other Puzzles of the Information Age; a hodgepodge of (mostly previously published) essays containing the expected software engineering and management wisdom of great sage and good writer DeMarco, but also some articles that are out of place; Dorset House, 1995

John Vlissides, Pattern Hatching; Design Patterns Applied; additional contemplations about Composite, Visitor, and Singleton as part of a design example; new patterns Generation Gap and Type Laundering; insights into the challenges of Pattern discovery with the example of Multicast vs. Observer; Addison-Wesley, 1998

HP Corporate Engineering, Software Quality and Productivity Guide; FURPS+, design through data flow diagrams (in a pre-OO world), and a surprising emphasis on unit and function testing, metrics for defects and maintenance; Part No. 5959-1606, 6/1988

iX Developer, Bessere Software; Application Lifecycle Management tools in the Agile context; version control, especially with Git; Continuous Integration and Delivery, DevOps and TDD; Verlag Heinz Heise, 3/2013

Serge Demeyer, Stéphane Ducasse, Oscar Nierstrasz, Object-Oriented Reengineering Patterns; a pattern language around social, testing, and refactoring patterns to adapt and maintain an inherited software application; First Open-Source Edition, 2008

Michael T. Nygard, Release It! Design and Deploy Production-Ready Software; best practices to ensure stability and capacity in modern web applications (with great war stories), and how to design software for the operations people; Pragmatic Programmers, 2007

Robin Williams, The Non-Designer's Design Book; visual design principles, page layout for common business papers, and an introduction into typography, with many illustrations; Peachpit Press, 2008

David Sibbet, Visual Meetings; how graphics, sticky notes, and idea mapping can transform group productivity; use of simple visual templates in various forms of meetings to engage people and avoid passive PowerPoint poisoning, various examples of successful visual facilitation; Wiley, 2010

Daniel Brolund, Ola Ellnestam, Behead your Legacy Beast: Refactor and Restructure relentlessly with the Mikado Method; Morph a system towards a goal through naive steps that are continuously reverted until you arrive at a leaf change, to avoid delving into a can of worms without escape; restructuring techniques and the use of refactoring; online book draft, Feb-2013

Jason Cohen, Steven Teleki, Eric Brown, Best Kept Secrets of Peer Code Review; Making a convincing case for code reviews, advocating for a modern, collaborative tool-based approach, which is more efficient than traditional, high-ceremony meetings with prior preparation. Tips on overcoming obstacles and not-so-subtle advertising for their CodeCollaborator tool; SmartBear software, 2012

Konrad Lischka, Fehlfunktion; Warum Frischhaltefolie nie gerade abreißt und andere Alltagsärgernisse; Sinn- und Unstimmigkeiten in Gegenständen des täglichen Umgangs, und warum dies so ist; Goldmann, 2010

John McWade, Before & After: Graphics for Business; Logos, Typography, layout, and colors for newsletters, stationery, reports and forms, described through various example projects; Peachpit Press, 2005

Jeff Atwood, Effective Programming: More Than Writing Code; Favorite blog essays on programming, security and testing, hiring and building a community; Hyperink Blog to Book Series, 2012

c't extra soziale Netze: privacy, control, and business models in Facebook, Google+, LinkedIn, Twitter, etc.; Verlag Heinz Heise, 2/2012

Eric Evans, Domain-Driven Design: Tackling complexity in the heart of software; Short, but expressive examples illustrate what a domain model is and how it can be refactored to a supple design and an ubiquitous language, Addison-Wesley, 2004

Alistair Cockburn, Writing Effective Use Cases; Formats, scopes, writing, and management of use cases, with many examples and critiques of UML alternatives; Addison-Wesley, 2001

brand eins, Geld verdienen im Netz Schwerpunkt Digitale Wirtschaft; Urheberrecht, Digitalkopie, Geschäftsmodelle, Startups; 07/2012

37signals, Getting Real; The smarter, faster, easier way to build a successful web application; short articles about lean startups, with contributing quotes and examples from Basecamp and the other 37signals products.

Amy Brown and Greg Wilson, The Architecture of Open Source Applications, Volume II; sketches of 24 architectures, core design features, and lessons learned; 2012

Amy Brown and Greg Wilson, The Architecture of Open Source Applications, Volume I; sketches of 25 architectures, core design features, and lessons learned; 2011

John McWade, Before & After: How to Design Cool Stuff; Typography, layout, colors, and photos, described through various example projects; Peachpit Press, 2010

Andy Oram and Greg Wilson, Making Software; What really works, and why we believe it; selected software engineering studies to move beyond the anecdotal stories about reviews, pair programming, TDD, design patterns, code quality, and many more; O'Reilly, 2010

William Lidwell, Kritina Holden, Jill Butler, Universal Principles of Design a cross-disciplinary reference; 125 ways to enhance usability, influence perception, increase appeal, make better design decisions, and teach through design; from the 80/20 Rule to the von Restorff Effect; Rockport Publishers, 2010

Karl Fogel, Producing Open Source Software; How to Run a Successful Free Software Project; technical infrastructure, good communications, encouraging and fostering collaboration of volunteers; a first-person account from a main Subversion contributor; self-published, free e-book, 2005

Stevel Levy, Hackers; Heroes of the Computer Revolution; From the origins of Lisp and Unix at MIT, through the hardware freaks like Woz building the first home computers, which enabled the rise of the famous game programmers and software startups, and how commercialization and the desired ubiquity finally ends the age of the hacker, with only residual echos in the free/open source communities; Penguin Books, 1984

Henrik Kniberg, Scrum and XP from the Trenches; How we do Scrum; Practical examples for sprint planning, execution, and the work environment from an early practitioner; C4Media, 2006
Henrik Kniberg & Mattias Skarin, Kanban and Scrum making the most of both; timeboxing vs. pull, differences to limiting WIP, a practical case study of an ops team switching to Kanban; C4Media, 2010

Henning Wolf, Arne Roock et al., agile review 2010; Articles on Scrum, FDD, Kanban and Lean Development; SOLID principles, acceptance tests with FIT; it-agile, 2010

iX kompakt Software-Qualität, usability and accessibility, testing, code quality and maintenance, migration and offshoring; Verlag Heinz Heise, 1/2011

Jessica Livingston, Founders at Work, stories of startups' early days; interviews with 33 founders of tech startups reveal the culture and stories before, during, and after the tech bubble, and what it takes to be an entrepreneur; Apress, 2008

Bob Walsh, Micro-ISV: From Vision to Reality; how to develop web and desktop applications and sell them over the Internet, the business side of software; interviews and portraits of successful founders; Apress, 2006

James Shore & Shane Warden, The Art of Agile Development; Agile methods as exemplified by Xtreme Programming, highlighting the interconnectedness of individual practices and how this fits into the big picture of Agility; O'Reilly, 2007

Michael Doyle, David Straus, How to Make Meetings Work; the new Interaction Method; structure meetings via dedicated facilitator and recorder roles, and try to attain collaborative win-win solutions; Jove, 1976

Michael C. Feathers, Working Effectively with Legacy Code, A discussion of common problems in legacy code and a catalog of dependency-breaking techniques; Prentice Hall, 2005

Erfolgreiches IT-Projektmanagement: Offshore-Projekte, Gruppendynamik, Chancen von agiler Entwicklung; iX magazine special, Verlag Heinz Heise, 3/2009

Phil Simon, Why new systems fail — theory and practice collide; Outlines the risks involved in system activation and migration of HR and ERP systems, using case studies and many real-life examples; AuthorHouse, 2009

Gerald M. Weinberg, The psychology of computer programming, Silver anniversary edition; Reading and evaluating the quality of programs, the social, team and motivational aspects of software development; Dorset House, 1998

Steve McConnell, Software Estimation - Demystifying the Black Art; Estimation techniques and challenges; Microsoft Press, 2006

Robert L. Glass, Facts and Fallacies of Software Engineering; A brief discussion of frequently forgotten fundamentals in management, life cycle and quality; Pearson Education, 2003

Dan Roam, The back of the napkin: solving problems and selling ideas with pictures A visual thinking process based on four steps (look, see, imagine, show), five questions (SQVID), and the six ways we see and show (who/what, how much, where, when, how, why); Portfolio, 2008

Steve Krug, Don't Make Me Think! A Common Sense Approach to Web Usability, Second Edition: Behavior and expectations of web users, home page design, navigation, accessibility; New Riders, 2006

Pete Goodliffe, Code Craft: The Practice of Writing Excellent Code: Proven code-writing and software engineering techniques in a competitive team environment from the real world software factories; No Starch Press, 2007

Ian Graham, Business Rules Management and Service Oriented Architecture: A Pattern Language; Aligning IT and business via SOA-based rules, expert systems and knowledge induction; John Wiley & Sons, 2006

Bruce Schneier, The Psychology of Security: Human factors and heuristics in assessing risks; Internet article, 2007

Richard P. Gabriel, Patterns of Software: Tales from the Software Community. Essays on reuse, piecemeal growth, code habitability and design patterns; a personal history about a startup around AI and Lisp and a discussion about its eventual failure, leading into insights about markets and innovation and the Worse is Better principle. Oxford University Press, 1996

Martin Fowler, Patterns of Enterprise Application Architecture: Layering, organizing domain logic, mapping to relational databases, presentation, distribution and concurrency patterns, Addison-Wesley, 2003

IBM Object-Oriented Technology Center, Developing Object-Oriented Software: An experience-based approach; Work Product-centered development from initiation through analysis, design, coding and testing; advice and guidance on processes and methodologies, Prentice Hall, 1997

Neal Stephenson, In the Beginning was the Command Line: The history and market forces of various operating systems; different user interfaces for different users, essay, 1999

Brian Foote and Joseph Yoder, Big Ball of Mud: A discussion of the most prevalent structure in software architectures, PLoP'97 conference paper, 1999
Brian Foote and Joseph Yoder, Evolution, Architecture, and Metamorphosis: Architecture patterns that allow to grow and evolve software over time, PLoP'95 conference paper, 1995
Brian Foote and Joseph Yoder, The Selfish Class: Reuse and replications seen from the source code perspective, PLoP'96 conference paper, 1997
Brian Foote and William F. Opdyke, Lifecycle and Refactoring Patterns that Support Evolution and Reuse, PLoP'94 conference paper, 1994

Gerald M. Weinberg, An Introduction to General Systems Thinking: Use basic algebraic principles to explore new approaches to projects, products, organizations and other kinds of systems; silver anniversary edition, Dorset House, 2001

Luis Felipe Cabrera, Christopher Kurt, Don Box, An Introduction to the Web Services Architecture and Its Specifications (51 pages), Microsoft Corporation, 2004

Cem Kaner, James Bach, Bret Pettichord, Lessons Learned in Software Testing: 293 lessons distilled from 30 years of testing practice, Wiley, 2002

Craig Larman, Applying UML and Patterns Third Edition - An Introduction to Object-Oriented Analysis and Design and Iterative Development, Prentice Hall, 2005

Allen Holub, Holub on Patterns - Learning Design Patterns by Looking at Code, Apress, 2004

Steve McConnell, Rapid Development: Taming Wild Software Schedules, Microsoft Press, 1996

Robert C. Martin, Dirk Riehle, Frank Buschmann (editors), Pattern languages of program design 3, Addison-Wesley, 1998

Simson Garfinkel, Daniel Weise, and Steven Strassmann, The UNIX-HATERS Handbook, IDG Books, 1994

Mike Gancarz, Linux and the Unix Philosophy: tenets and software engineering principles applied in the Unix operating system family, Digital Press, 2003

Tom DeMarco & Timothy Lister, Peopleware: productive projects and teams (2nd ed.), Dorset House, 1999

Frederick P. Brooks, The mythical man-month: essays on software engineering (anniversary edition), Addison-Wesley, 1995

Martin Fowler, Refactoring: Improving the Design of Existing Code, Addison-Wesley, 2000

Gamma et al., Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994

Steve McConnell, Code Complete: A Practical Handbook of Software Construction, Microsoft Press, 1993

Bernd Oesterreich, Objektorientierte Softwareentwicklung mit der UML, Oldenbourg, 1997

Computerviren - die neue Bedrohung: Detailed analysis of the Robert T. Morris Internet worm; early floppy-based homecomputer viruses; interviews with John McAfee on new threats