Best 93 quotes in «computer science quotes» category

No program can say what another will do. Now, I won’t just assert that, I’ll prove it to you. I will prove that although you might work till you drop, You cannot tell if computation will stop.

Overstimulation has been the real drawback. I need to find ways to stop thinking about analysis of algorithms, in order to do various other things that human beings ought to do.

Reusability is key in reducing bugs and coding quickly. The more I use a piece of code, the more confident and familiar I become with it, which in turn significantly speeds up my development time.

Q: Why bother doing proofs about programming languages? They are almost always boring if the definitions are right. A: The definitions are almost always wrong. - Anonymous

Simple things should be simple, complex things should be possible.

Simply In Depth......

Seemingly innocuous language like 'Oh, I'm flexible' or 'What do you want to do tonight?' has a dark computational underbelly that should make you think twice. It has the veneer of kindness about it, but it does two deeply alarming things. First, it passes the cognitive buck: 'Here's a problem, you handle it.' Second, by not stating your preferences, it invites the others to simulate or imagine them. And as we have seen, the simulation of the minds of others is one of the biggest computational challenges a mind (or machine) can ever face.

Tests are stories we tell the next generation of programmers on a project.

Suppose whatever we can recognize we can find. We can if P=NP.

The business we're in is more sociological than technological, more dependent on workers' abilities to communicate with each other than their abilities to communicate with machines.

The clarity offered by software as metaphor - and the empowerment allegedly offered to us who know software - should make us pause, because software also engenders a sense of profound ignorance. Software is extremely difficult to comprehend. Who really knows what lurks behind our smiling interfaces, behind the objects we click and manipulate? Who completely understands what one’s computer is actually doing at any given moment? Software as a metaphor for metaphor troubles the usual functioning of metaphor, that is, the clarification of an unknown concept through a known one. For, if software illuminates an unknown, it does so through an unknowable (software). This paradox - this drive to grasp what we do not know through what we do not entirely understand… does not undermine, but rather grounds software’s appeal. Its combination of what can be seen and not seen, can be known and no known - it’s separation of interface from algorithm, of software from hardware - makes it a powerful metaphor for everything we believe is invisible yet generates visible effects, from genetics to the invisible hand of the market, from ideology to culture. Every use entails an act of faith.

The component structure cannot be designed from the top down. It is not one of the first things about the system that is designed, but rather evolves as the system grows and changes.

The computer only gives back ourselves. It is a faithful mirror that reflects the human traits that are brought to it.

The DQN AI system of Google DeepMind can accomplish a slightly broader range of goals: it can play dozens of different vintage Atari computer games at human level or better. In contrast, human intelligence is thus far uniquely broad, able to master a dazzling panoply of skills. A healthy child given enough training time can get fairly good not only at any game, but also at any language, sport or vocation. Comparing the intelligence of humans and machines today, we humans win hands-down on breadth, while machines outperform us in a small but growing number of narrow domains, as illustrated in figure 2.1. The holy grail AI research is to build “general AI” (better known as artificial general intelligence, AGI) that is maximally broad: able to accomplish virtually any goal, including learning.

The great paradox of automation is that the desire to eliminate human labor always generates new tasks for humans.

The most important property of a program is whether it accomplishes the intention of its user.

The ocean is a Turing machine, the sand is its tape; the water reads the marks in the sand and sometimes erases them and sometimes carves new ones with tiny currents that are themselves a response to the marks.

Perhaps the most important principle for the good algorithm designer is to refuse to be content.

The question of whether a computer can think is no more interesting than the question of whether a submarine can swim.

The silicon microchips themselves might be cheap (relative to times past, anyway), but CPU cycles are not cheap. Every CPU cycle consumes clock time. Clock time is latency. A wasteful application makes its users wait longer than they need to, and if there’s anything users hate, it’s waiting. For web systems, latency in the application has a dual effect. The added processing directly increases the burden on the application servers themselves. Suppose that an application takes just 250 milliseconds of extra processing per transaction. If the system processes a million transactions a day, that extra 250 milliseconds per transaction makes for an extra 69.4 hours of compute time every day. Assuming an 80% load factor on each server, you’ll need four additional servers to handle this load.

The cost of electrons and photons is getting cheaper all the time!

The string is a stark data structure and everywhere it is passed there is much duplication of process. It is a perfect vehicle for hiding information.

[The study of prime numbers] becoming pivotal in cryptography and online security. As it happens, it is much easier to multiply primes together than to factor them back out. In modern encryption, secret primes known only to the sender and recipient get multiplied together to create huge composite numbers that can be transmitted publicly without fear, since factoring the product would take eavesdropper way too long to be worth attempting.

There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors.

The very last stage of any memory hierarchy is necessarily the outside world—that is, the outside world as far as the machine is concerned, i.e. that part of it with which the machine can directly communicate, in other words, the input and the output organs of the machine. These are usually punched paper tapes or cards, and on the output side, of course, also printed paper.

Ultimately, I try to think of my application’s main codebase as just stringing together various components and code from many sources. It just controls logic and flow. The real nitty-gritty is handled behind the scenes. This is why frameworks like Backbone are so important — they hide a lot of the details in the background and allow you to just focus on the flow and control of your application.

Unix is not so much a product as it is a painstakingly compiled oral history of the hacker subculture. It is our Gilgamesh epic: a living body of narrative that many people know by heart, and tell over and over again—making their own personal embellishments whenever it strikes their fancy. The bad embellishments are shouted down, the good ones picked up by others, polished, improved, and, over time, incorporated into the story. […] Thus Unix has slowly accreted around a simple kernel and acquired a kind of complexity and asymmetry about it that is organic, like the roots of a tree, or the branchings of a coronary artery. Understanding it is more like anatomy than physics.

Underlying our approach to this subject is our conviction that "computer science" is not a science and that its significance has little to do with computers. The computer revolution is a revolution in the way we think and in the way we express what we think. The essence of this change is the emergence of what might best be called procedural epistemology—the study of the structure of knowledge from an imperative point of view, as opposed to the more declarative point of view taken by classical mathematical subjects. Mathematics provides a framework for dealing precisely with notions of "what is". Computation provides a framework for dealing precisely with notions of "how to".

The spectacle's instruction and the spectators' ignorance are wrongly seen as antagonistic factors when in fact they give birth to each other. In the same way, the computer's binary language is an irresistible inducement to the continual and unreserved acceptance of what has been programmed according to the wishes of someone else and passes for the timeless source of a superior, impartial and total logic. Such progress, such speed, such breadth of vocabulary! Political? Social? Make your choice. You cannot have both. My own choice is inescapable. They are jeering at us, and we know whom these programs are for. Thus it is hardly surprising that children should enthusiastically start their education at an early age with the Absolute Knowledge of computer science; while they are still unable to read, for reading demands making judgements at every line; and is the only access to the wealth of pre-spectacular human experience. Conversation is almost dead, and soon so too will be those who knew how to speak.

Want to guarantee nasty conflicts? Take a word with multiple, fuzzy, definitions, force people to strike an agreement on it, attach large amounts of money to it, and then watch them fight about it a year or two later.

We can think of life as a self-replicating information-processing system whose information (software) determines both its behavior and the blueprints for its hardware.

Well, writing novels is incredibly simple: an author sits down…and writes. Granted, most writers I know are a bit strange. Some, downright weird. But then again, you’d have to be. To spend hundreds and hundreds of hours sitting in front of a computer screen staring at lines of information is pretty tedious. More like a computer programmer. And no matter how cool the Matrix made looking at code seem, computer programmers are even weirder than authors.

We will start by sketching the recursive algorithm and then add details to get to a full description of the algorithm. Footnote : Translation: We will add details till the mess becomes both undecipherable and incomprehensible at the same time. Hopefully, the inner poetical and rhythmical beauty of the text will keep the reader going.

What one programmer can do in one month, two programmers can do in two months.

What's in your hands I think and hope is intelligence: the ability to see the machine as more than when you were first led up to it that you can make it more.

When human beings acquired language, we learned not just how to listen but how to speak. When we gained literacy, we learned not just how to read but how to write. And as we move into an increasingly digital reality, we must learn not just how to use programs but how to make them. In the emerging highly programmed landscape ahead, you will either create the software or you will be the software. It’s really that simple: Program, or be programmed.

When the ANSI C standard was under development, the pragma directive was introduced. Borrowed from Ada, #pragma is used to convey hints to the compiler, such as the desire to expand a particular function in-line or suppress range checks. Not previously seen in C, pragma met with some initial resistance from a gcc implementor, who took the “implementation-defined” effect very literally—in gcc version 1.34, the use of pragma causes the compiler to stop compiling and launch a computer game instead! The gcc manual contained the following: The “#pragma” command is specified in the ANSI standard to have an arbitrary implementation-defined effect. In the GNU C preprocessor, “#pragma” first attempts to run the game “rogue”; if that fails, it tries to run the game “hack”; if that fails, it tries to run GNU Emacs displaying the Tower of Hanoi; if that fails, it reports a fatal error. In any case, preprocessing does not continue. —Manual for version 1.34 of the GNU C compiler

Worse yet is the rejection of upfront requirements. The basic observation is correct: requirements will change, and are hard anyway to capture at the beginning. In no way, however, does it imply the dramatic conclusion that upfront requirements are useless! What it does imply is that requirements should be subject to change, like all other artifacts on the software process. [...] The agile advice here is irresponsible and serious software projects should ignore it.The sound practice is to start collecting requirements at the beginning, produce a provisional version prior to engaging in design, and treat the requirements as a living product that undergoes constant adaptation throughout the project.

You are not reading this book because a teacher assigned it to you, you are reading it because you have a desire to learn, and wanting to learn is the biggest advantage you can have.

why bother with null and java 8 has optional

An algorithm must be seen to be believed.

Computer Science is embarrassed by the computer.

Computer science is the operating system for all innovation.

Computer science has as much to do with computers as astronomy has to do with telescopes.

Science is to computer science as hydrodynamics is to plumbing.

Most of the good programmers do programming not because they expect to get paid or get adulation by the public, but because it is fun to program.

I'm basically a computer science nerd.

Most papers in computer science describe how their author learned what someone else already knew.

Trees sprout up just about everywhere in computer science.

A code, which according to Turing's schema is supposed to make one machine behave as if it were another specific machine (which is supposed to make the former imitate the latter) must do the following things. It must contain, in terms that the machine will understand (and purposively obey), instructions (further detailed parts of the code) that will cause the machine to examine every order it gets and determine whether this order has the structure appropriate to an order of the second machine. It must then contain, in terms of the order system of the first machine, sufficient orders to make the machine cause the actions to be taken that the second machine would have taken under the influence of the order in question.