First Quote Added
April 10, 2026
Latest Quote Added
"is sometimes necessary on a distributed team, but never in my career have I seen it taken to the level that GitHub has. Asynchronous communication is definitely not my strongest area. When I see a text box on screen, I tend to be very terse and direct instead of typing out a wall of text."
"Values that are expressed but that don't change behavior are not really values, they are lies that you tell yourself."
"I was well aware of 's very problematic past, from its promotion of meritocracy in place of a management system to the horrible treatment and abuse of its female employees and other people from diverse backgrounds. I myself had experienced harassment on GitHub. As an example, a couple of years ago someone created a dozen repositories with racist names and added me to the repos, so my GitHub profile had racial slurs on it until their support team got around to shutting them down a few days after I reported the incident. I didn't get the sense that the company really cared about harassment."
"As a seasoned developer I have certain quirks, opinions, and common patterns that I fall back on. Having to explain to another person why I am approaching a problem in a particular way is really good for helping me break bad habits and challenge my assumptions, or for providing validation for good problem solving skills."
"The United States, as you point out, has been actually freer than most in terms of offering access to information. It doesn't have to be this way. Openness is not the default in terms of how if you look back in time, or even around the world. We need to show how openness works better. That you end up with companies that thrive better. That you have, with standards, you have more competition that builds more jobs. That openness is a win."
"He [Kahle] noted that libraries historically tend to grow in societies that prioritize education and decline in societies where power is being concentrated, and he’s worried about where the US is headed. That makes it hard to predict if IA—or any library project—will be supported in the long term."
"If they succeed in destroying our books or even making many of them inaccessible, there will be a chilling effect on the hundreds of other libraries that lend digitized books as we do. This could be the burning of the Library of Alexandria moment—millions of books from our community's libraries—gone."
"Here's the problem with the web — this is so cool, it's worth it. The internet is decentralized in the sense that you can kind of nuke any part of it and it still works. That was its original design. The World Wide Web isn't that way. You go and knock out any particular piece of hardware, it goes away. Can we make a reliable web that's served from many different places, kind of like how the Amazon cloud works, but for everybody? The answer is yes, you can. You can make kind of a pure to pure distribution structure, such that the web becomes reliable. Another is that we can make it private so that there's reader privacy. Edward Snowden has brought to light some really difficult architectural problems of the current World Wide Web. The GCHQ, the secret service of the British, watched everybody using WikiLeaks, and then offered all of those IP addresses, which are personally identifiable in the large part, to the NSA. The NSA had conversations about using that as a means to go and... monitor people at an enhanced level that those are now suspects. Libraries have long had history with people being rounded up for what they've read and bad things happening to them. We have an interest in trying to make it so that there’s reader privacy."
"It never ceases to amaze me how far people have to stretch in order to denounce the one corporation that gives away everything for free"
"Tech companies expropriate ad money from capitalists to build a superintelligence & don’t pay dividends! ... Silicon Valley is firmly post-capitalist. There just isn’t a name for it yet, nor an intellectual (assessment)"
"she has become an astroturfer par excellence for the company, including showing up in a comment section to bash my reporting on Google’s vast for-profit surveillance operation"
"Doug McIlroy's influence on the development of both C and C++ cannot be overestimated. I cannot remember a single critical design decision in C++ that I have not discussed at length with Doug."
"... speaking of Doug, he's the unsung hero of Unix. He was manager of the group that produced it and a huge creative force in the group, but he's almost unknown in the Unix community. He invented a couple of things you might have heard of: pipes and — get this — macros. Well, someone had to do it and that someone was Doug. As Ken once said when we were talking one day in the Unix room, "There's no one smarter than Doug.""
"I don't know the counts of Unix and Linux servers. I do know that my heart sinks whenever I look under the hood in Linux. It is has been so overfed by loving hands. Over 240 system calls! Gigabytes of source! A C compiler with a 250-page user manual (not counting the language definition)! A simple page turner, 'less,' has over 40 options and 60 commands! It's proof that open-source can breed monsters just like the commercial pros. Miraculously, though, this monster works."
"McIlroy ... is the smartest of all of us and the least remembered or written down of all of us [programmers at Bell Labs' Computing Techniques Research Department]."
"Word and Excel and PowerPoint and other Microsoft programs have intimate — one might say promiscuous — knowledge of each others' internals. In Unix, one tries to design programs to operate not specifically with each other, but with programs as yet unthought of."
"The notion of "intricate and beautiful complexities" is almost an oxymoron. Unix programmers vie with each other for "simple and beautiful" honors — a point that's implicit in these rules, but is well worth making overt."
"Everything was small... and my heart sinks for Linux when I see the size of it. [...] The manual page, which really used to be a manual page, is now a small volume, with a thousand options... We used to sit around in the Unix Room saying, 'What can we throw out? Why is there this option?' It's often because there is some deficiency in the basic design — you didn't really hit the right design point. Instead of adding an option, think about what was forcing you to add that option."
"Ritchie and Thompson made an amazing team; and they played Unix and C like a fine instrument. They sometimes divided up work almost on a subroutine-by-subroutine basis with such rapport that it almost seemed like the work of a single person. In fact, as Dennis has recounted, they once got their signals crossed and both wrote the same subroutine. The two versions did not merely compute the same result, they did it with identical source code! Their output was prodigious. Once I counted how much production code they had written in the preceding year − 100,000 lines! Prodigious didn’t mean slapdash. Ken and Dennis have unerring design sense. They write code that works, code that can be read, code that can evolve."
"This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface."
"Like structured design, the term object-oriented design (OOD) means different things to different people. For example, OOD has been used to imply such things as"
"Work on what was to become “structured design” began in the early 1960s. Structured design, as a well-defined and named concept, did not achieve appreciable visibility until the publication of an article in the IBM Systems Journal in 1974 (Stevens et al., 1974). There is more than one way to accomplish a “structured design.”"
"Object-oriented domain analysis seeks to identify reusable items localized around objects e.g., classes, instances, systems of interacting objects, and kits."
"Walking on water and developing software from a specification are easy if both are frozen."
"An object which is used to create instances, i.e., a template, description, pattern, or "blueprint" of a category or collection of very similar items. Among other things, a class describes the interface the these items will present to the outside world, i.e., the available and appropriate methods, constants, and exceptions. A class represents an abstraction of the items. A class may itself be parameterized (i.e., it actually represents a family of very closely related classes), in which case we refer to it as a parameterized class. Class is a recursive concept. Specifically, we may define classes as being composed of other classes (i.e., heterogeneous composite classes and homogeneous composite classes), in terms of itself (a recursively defined class), as inheriting characteristics from one or more other classes (i.e., the superclasses of the class), and as providing characteristics to other classes (i.e., the subclasses of the class). In some places, classes are defined as "the set of all instances of a type," and the term "type" is given the above definition for class."
"Software people seem to have a love-hate relationship with metrics. On one hand, they despise and distrust anything that sounds or looks like a measurement. They are quick to point out the "flaws" in the arguments of anyone who talks about measuring software products, software processes, and (especially) software people. On the other hand, these same people seem to have no problems identifying which programming language is the best, the stupid things that managers do to "ruin" projects, and who's methodology works in what situations."
"Recently, I have had conversations with a number of people who were attempting their first object-oriented project. Most of these people claimed to be using “use cases” in their object-oriented analysis and design approaches. However, listening to them describe their projects, it became quite apparent to me that there is a great deal of confusion regarding the definition, context, and use of use cases. This confusion can (and often does) lead to poorly-designed systems."
"In order to better understand object-oriented methodologies in general, it helps to understand the people who make up the "object-oriented community" itself. Far from being monolithic, there is a great deal of diversity within this community. Many object-oriented people, for example, seem to focus almost entirely on programming language issues. They tend to cast all discussions in terms of the syntax and semantics of their chosen object-oriented programming language. These people find it impossible (for all intents and purposes) to discuss any software engineering activity (e.g., analysis, design, and testing) without direct mention of some specific implementation language. Outside of producing executable "prototypes", people who emphasize programming languages seldom have well-defined techniques for analyzing their clients' problems or describing the overall architecture of the software product. A great deal of what they do is intuitive. If they happen to have a natural instinct/intuition for good analysis or good design, their efforts on small-to-medium, non-critical projects can result in respectable software solutions."
"Objects are the real and conceptual things we find in the world around us. An object may be hardware, software, a concept (e.g., velocity), or even "flesh and blood." Objects are complete entities, i.e., they are not "simply information" or "simply information and actions." Software objects strive to capture as completely as possible the characteristics of the "real world" objects which they represent. Finally, objects are "black boxes," i.e., their internal implementations are hidden from the outside world, and all interactions with an object take place via a well-defined interface."
"An object in OOA represents a single typical but unspecified instance of something in the real world - any airplane, I don't care which one, as long as it is typical. The object-oriented analyst distinguishes this concept from that of a specified instance: Airplane number N2713A, Air Force One, or The Spirit of St. Louis, for example."
"The key books about object-oriented graphical modeling languages appeared between 1988 and 1992. Leading figures included Grady Booch [Booch,OOAD]; Peter Coad [Coad, OOA], [Coad, OOD]; Ivar Jacobson (Objectory) [Jacobson, OOSE]; Jim Odell [Odell]; Jim Rumbaugh (OMT) [Rumbaugh, insights], [Rumbaugh, OMT]; Sally Shlaer and Steve Mellor [Shlaer and Mellor, data], [Shlaer and Mellor, states] ; and Rebecca Wirfs-Brock (Responsibility Driven Design) [Wirfs-Brock]."
"While a small domain (consisting of fifty or fewer objects) can generally be analyzed as a unit, large domains must be partitioned to make the analysis a manageable task. To make such a partitioning, we take advantage of the fact that objects on an information model tend to fall into clusters: groups of objects that are interconnected with one another by many relationships. By contrast, relatively few relationships connect objects in different clusters. When partitioning a domain, we divide the information model so that the clusters remain intact... Each section of the information model then becomes a separate subsystem. Note that when the information model is partitioned into subsystems, each object is assigned to exactly one subsystem."
"Experienced object designers explore the design space from many different angles. They refine ideas of how their system should respond while they are in the middle of building and discarding ideas about how their design should work. Getting a design to gel involves making assumptions, seeing how they play out, changing one’s mind or perspective slightly and re-iterating. Design is a difficult, involved task. It inherently is a non-linear process. Yet, we are asked to trace our design results back to system requirements. And, if we uncover some implications during design, we’d like to tune our system requirements to reflect necessary design compromises."
"Object-oriented programming increases the value of these metrics by managing this complexity. The most effective tool available for dealing with complexity is abstraction. Many types of abstraction can be used, but encapsulation is the main form of abstraction by which complexity is managed in object-oriented programming. Programming in an object-oriented language, however, does not ensure that the complexity of an application will be well encapsulated. Applying good programming techniques can improve encapsulation, but the full benefit of object-oriented programming can be realized only if encapsulation is a recognized goal of the design process."
"is inspired by the client/server model. It focuses on the contract by asking:"
"Use cases, scenarios or scripts are roughly synonymous terms for important ways to focus our design activities. I prefer the term use case (although quickly saying it three times can leave your tongue tied) because it emphasizes usage. A use case is a textual description of a sequence of interactions between an actor (roughly corresponding to an external agent or class of users) and the system we are designing. Use cases were first described by Ivar Jacobson in his book “Object Oriented Software Engineering A Use Case Driven Approach.” Use cases have been around in various forms for quite some time. Jacobson, however, made the keen observation that use cases can be treated as refineable, extensible and even reusable specifications of system requirements. We’ve had these same goals for object designs. We know that it is harder to actually accomplish them than it is to talk about them."
"An action which is suffered by, or required of, an object. Operations may be selectors, constructors, or iterators. An operation is contained in an object's interface and has its details described in a corresponding method. Operations may be composite, i.e., composed of other operations. However, encapsulation of composite operations within the interface to an object is not encouraged."
"A conceptual level view of an object design describes the key abstractions. While someone might think of key abstractions as being nothing more or nothing less than high-level descriptions of "candidate classes", I prefer to consider a conceptual design from a slightly different angle--I'm thinking about design at a slightly different level. An object-oriented application is a set of interacting objects. Each object is an implementation of one or more roles. A role supports a set of related (cohesive) responsibilities. A responsibility is an obligation to perform a task or know certain information. And objects don't work in isolation, they collaborate with others in a community to perform the overall responsibilities of the application. So a conceptual view, at least to start, is a distillation of the key object roles and their responsibilities (stated at a fairly high level). More than likely (unless you form classification hierarchies and use inheritance and composition techniques) many candidates you initially model will map directly to a single class in some inheritance hierarchy. But I like to open up possibilities by think first of roles and responsibilities, and then as a second step towards a specification-level view, mapping these candidates to classes and interfaces."
"Frameworks are skeletal structures of programs that must be fleshed out to build a complete application. For example, a windowing system or a simulation system can both be viewed as frameworks fleshed out by a windowed application or a simulation, respectively."
"Frameworks are white boxes to those that make use of them. Application developers must be able to quickly understand the structure of a framework, and how to write code that will fit into the framework. Frameworks are reusable designs as well as reusable code."
"A subsystem is a set of classes (and possibly other subsystems) collaborating to fulfill a set of responsibilities. Although subsystems do not exist as the software executes, they are useful conceptual entities."
"Users can work with analysts and object designers to formulate and tune system requirements. People from business, analytical and object design disciplines can come together, learn from each other and generate meaningful descriptions of systems that are to be built. Each participant and each project has slightly different concerns and needs. Practical application of use cases can go a long way to improve our ability to deliver just what the customer ordered."
"Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can only be realized if encapsulation is maximized during the design process. We argue that design practices which take a data-driven approach fail to maximize encapsulation because they focus too quickly on the implementation of objects. We propose an alternative object-oriented design method which takes a responsibility-driven approach. We show how such an approach can increase the encapsulation by deferring implementation issues until a later stage."
"Encapsulation is the key to increasing the value of such software metrics as reusability, refinability, testability, maintainability, and extensibility. Object-oriented languages provide a number of mechanisms for improving encapsulation, but it is during the design phase that the greatest leverage can be realized. The data-driven approach to object-oriented design focuses on the structure of the data in a system. This results in the incorporation of structural information in the definitions of classes. Doing so violates encapsulation. The responsibility-driven approach emphasizes the encapsulation of both the structure and behavior of objects. By focusing on the contractual responsibilities of a class, the designer is able to postpone implementation considerations until the implementation phase. While responsibility-driven design is not the only technique addressing this problem, most other techniques attempt to enforce encapsulation during the implementation phase. This is too late in the software life-cycle to achieve maximum benefits."
"The goal of is to improve encapsulation. It does so by viewing a program in terms of the client/server model."
"Responsibility-driven design specifies object behavior before object structure and other implementation considerations are determined. We have found that it minimizes the rework required for major design changes."
"Dr. James Rumbaugh is one of the leading object-oriented methodologists. He is the chief developer of the Object Modeling Technique (OMT) and the lead author of the best-selling book Object-Oriented Modeling and Design. Before joining Rational Software Corporation in October 1994, he worked for more than 25 years at General Electric Research and Development Center in Schenectady, New York."
"The name of a class should reflect its intrinsic nature and not a role that it plays in an association. For example, Owner would be a poor name for a class in a car manufacturer's database. What if a list of drivers is added later? What about persons who lease cars? The proper class is Person (or possibly Customer), which assumes various different roles, such as owner, driver, and lessee."