Programmer Code Quotes

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Bad programmers worry about the code. Good programmers worry about data structures and their relationships.

Slaves are not allowed to say no. Laborers may be hesitant to say no. But professionals are expected to say no. Indeed, good managers crave someone who has the guts to say no. It’s the only way you can really get anything done.

I’m not a great programmer; I’m just a good programmer with great habits.

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.

All great programmers learn the same way. They poke the box. They code something and see what the computer does. They change it and see what the computer does. They repeat the process again and again until they figure out how the box works.

It is not the language that makes programs appear simple. It is the programmer that make the language appear simple!

At forty, I was too old to work as a programmer myself anymore; writing code is a young person’s job.

Don't be a slave to history. Don't let existing code dictate future code. All code can be replaced if it is no longer appropriate. Even within one program, don't let what you've already done constrain what you do next -- be ready to refactor... This decision may impact the project schedule. The assumption is that the impact will be less than the cost of /not/ making the change.

You are reading this book for two reasons. First, you are a programmer. Second, you want to be a better programmer. Good. We need better programmers.

Why do most developers fear to make continuous changes to their code? They are afraid they’ll break it! Why are they afraid they’ll break it? Because they don’t have tests.

Names are deeply meaningful to your brain, and misleading names add chaos to your code.

Don't gloss over a routine or piece of code involved in the bug because you "know" it works. Prove it. Prove it in this context, with this data, with these boundary conditions.

I'm a programmer. I like programming. And the best way I've found to have a positive impact on code is to write it.

I will, in fact, claim that the difference between a bad programmer and a good one is whether he considers his code or his data structures more important. Bad programmers worry about the code. Good programmers worry about data structures and their relationships.

One difference between a smart programmer and a professional programmer is that the professional understands that clarity is king. Professionals use their powers for good and write code that others can understand.

The problem is that we view estimates in different ways. Business likes to view estimates as commitments. Developers like to view estimates as guesses. The difference is profound.

Novice programmers don’t yet have the skills to write simple code.

Programmers must avoid leaving false clues that obscure the meaning of code.

Write code as if you had to support it for the rest of your life.

What would happen if you allowed a bug to slip through a module, and it cost your company $10,000? The nonprofessional would shrug his shoulders, say “stuff happens,” and start writing the next module. The professional would write the company a check for $10,000!

Real programmers can write assembly code in any language.

Think twice, code once.

While overpaid CEOs take long vacations and hide behind e-mail autoresponders, some programmer is working eighteen-hour days coding the start-up that will destroy that CEO’s business.

The amount of surprise you feel when something goes wrong is directly proportional to the amount of trust and faith you have in the code being run.

When you are working on a problem, you sometimes get so close to it that you can’t see all the options. You miss elegant solutions because the creative part of your mind is suppressed by the intensity of your focus. Sometimes the best way to solve a problem is to go home, eat dinner, watch TV, go to bed, and then wake up the next morning and take a shower.

Debugging: what an odd word. As if "bugging" were the job of putting in bugs, and debugging the task of removing them. But no. The job of putting in bugs is called programming. A programmer writes some code and inevitably makes the mistakes that result in the malfunctions called bugs. Then, for some period of time, normally longer than the time it takes to design and write the code in the first place, the programmer tries to remove the mistakes.

If your code needs comments, consider refactoring it so it doesn’t.

You see, programmers tend to be arrogant, self-absorbed introverts. We didn’t get into this business because we like people.

In an article in the April 1999 CACM, Robert Glass summarizes research that seems to indicate that, while code inspection is effective, conducting reviews in meetings is not.

Ask a programmer to review ten lines of code, he’ll find ten issues. Ask him to do five hundred lines, and he’ll say it looks good.

In programs, there are conditions, which the programmer must follow. Otherwise, the code won’t run. Throwing dead animals is a condition. Some may say it’s a ritual one needs to complete before the intention installs, before the will sets … But who is installing intentions? Who wants to program the universe? Was it him? Most importantly: Bother? Or not bother?

Legacy code. The phrase strikes disgust in the hearts of programmers. It conjures images of slogging through a murky swamp of tangled undergrowth with leaches beneath and stinging flies above. It conjures odors of murk, slime, stagnancy, and offal. Although our first joy of programming may have been intense, the misery of dealing with legacy code is often sufficient to extinguish that flame.

By coding at a higher level of abstraction, you are free to concentrate on solving domain problems, and can ignore petty implementation details.

Launch is just another point in software’s life. Not the end-all and be-all.

The revolution has to be customised

Quality must be enforced, otherwise it won't happen. We programmers must be required to write tests, otherwise we won't do it.

If you are tired or distracted, do not code.

Don't leave "broken windows" (bad designs, wrong decisions, or poor code) unrepaired. Fix each one as soon as it is discovered. If there is insufficient time to fix it properly, then board it up. Perhaps you can comment out the offending code, or display a "Not Implemented" message, or substitute dummy data instead. Take some action to prevent further damage and to show that you're on top of the situation.

You should plan on working 60 hours per week. The first 40 are for your employer. The remaining 20 are for you. During this remaining 20 hours you should be reading, practicing, learning, and otherwise enhancing your career.

The fundamental assumption underlying all software projects is that software is easy to change. If you violate this assumption by creating inflexible structures, then you undercut the economic model that the entire industry is based on. In

They always need fresh, enthusiastic programmers. More important: they need programmers chosen by a star programmer. Magic Mama told her all about how recruiting happens in well-known companies. Unlike small companies, they depend more on shining logos. Logos like The Resolution Race Champion, The Gold Winner of Code the Crude, or Year’s Best Thesis Contributor are gems in their crowns. Everyone loves collecting gems. Talents are the gems big companies prefer plucking in reduced expenses. The best gems are the hard-working Low Grades and the non-citizens from the Junk Land. Who wouldn’t love a talent born in the gutters?—Just lure them with citizenship.

Programmers working with high-level languages achieve better productivity and quality than those working with lower-level languages. Languages such as C++, Java, Smalltalk, and Visual Basic have been credited with improving productivity, reliability, simplicity, and comprehensibility by factors of 5 to 15 over low-level languages such as assembly and C (Brooks 1987, Jones 1998, Boehm 2000). You save time when you don't need to have an awards ceremony every time a C statement does what it's supposed to.

An estimate is not a number. An estimate is a distribution.

The unit tests are documents. They describe the lowest-level design of the system.

Software lives and matures over time.

So much of leadership is learning to give a damn about other people, something that we programmers are notoriously bad at.

The problem with this premise, of course, is that whereas other children had programmers who fed their brains with love and kindness, my programmers were evil. My code is flawed.

Reading other people's code is particularly hard. Not necessarily because other people's code is bad, but because they probably think and solve problems in a different way to you.

QA and Development should be working together to ensure the quality of the system. The

After all, computer science was man-made. All the answers had to be there.

All the obstacles existed solely in code, I thought.

We must not blame programmers for their bugs. They belong to them only until the code is merged to the repository. After that, all bugs are ours!

We, newbies and young programmers, don't like chaos because it makes us dependent on experts. We have to beg for information and feel bad

Automated testing is a safety net that protects the program from its programmers

In the same way a woodworker invests the time in a jig, a programmer can build a code generator. Once built, it can be used throughout the life of the project at virtually no cost.

Beautiful code is short and concise, so if you were to give that code to another programmer they would say, “oh, that’s well written code.” It’s much like as if you were writing a poem.

When you cannot concentrate and focus sufficiently, the code you write will be wrong. It will have bugs. It will have the wrong structure. It will be opaque and convoluted. It will not solve the customers’ real problems. In short, it will have to be reworked or redone. Working while distracted creates waste.

We programmers are weird creatures. We love writing code. But when it comes to reading it we usually shy away. After all, writing code is so much more fun, and reading code is hard — sometimes almost impossible.

Good programming is not born from mere technical competence. I've seen highly intellectual programmers who can produce intense and impressive algorithms, who know their language standard by heart, but who write the most awful code.

You see, programmers tend to be arrogant, self-absorbed introverts. We didn’t get into this business because we like people. Most of us got into programming because we prefer to deeply focus on sterile minutia, juggle lots of concepts simultaneously, and in general prove to ourselves that we have brains the size of a planet, all while not having to interact with the messy complexities of other people.

It's more than a little ironic that many of us preach safety first to our children, nieces, and nephews but in our roles as programmers scream for freedom, a hybrid of the Wild West gunslinger and teenage driver. Give us freedom, give us the resources, and watch us fly.

Almost every software development organization has at least one developer who takes tactical programming to the extreme: a tactical tornado. The tactical tornado is a prolific programmer who pumps out code far faster than others but works in a totally tactical fashion. When it comes to implementing a quick feature, nobody gets it done faster than the tactical tornado. In some organizations, management treats tactical tornadoes as heroes. However, tactical tornadoes leave behind a wake of destruction. They are rarely considered heroes by the engineers who must work with their code in the future. Typically, other engineers must clean up the messes left behind by the tactical tornado, which makes it appear that those engineers (who are the real heroes) are making slower progress than the tactical tornado.

In 1953, Allen Dulles, then director of the USA Central Intelligence Agency (CIA), named Dr Sidney Gottlieb to direct the CIA's MKULTRA programme, which included experiments conducted by psychiatrists to create amnesia, new dissociated identities, new memories, and responses to hypnotic access codes. In 1972, then-CIA director Richard Helms and Gottlieb ordered the destruction of all MKULTRA records. A clerical error spared seven boxes, containing 1738 documents, over 17,000 pages. This archive was declassified through a Freedom of Information Act Request in 1977, though the names of most people, universities, and hospitals are redacted. The CIA assigned each document a number preceded by "MORI", for "Managament of Officially Released Information", the CIA's automated electronic system at the time of document release. These documents, to be referenced throughout this chapter, are accessible on the Internet (see: abuse-of-power (dot) org/modules/content/index.php?id=31). The United States Senate held a hearing exposing the abuses of MKULTRA, entitled "Project MKULTRA, the CIA's program of research into behavioral modification" (1977).

The Joel Test 1. Do you use source control? 2. Can you make a build in one step? 3. Do you make daily builds? 4. Do you have a bug database? 5. Do you fix bugs before writing new code? 6. Do you have an up-to-date schedule? 7. Do you have a spec? 8. Do programmers have quiet working conditions? 9. Do you use the best tools money can buy? 10. Do you have testers? 11. Do new candidates write code during their interview? 12. Do you do hallway usability testing?

Here is a minimal list of the things that every software professional should be conversant with: • Design patterns. You ought to be able to describe all 24 patterns in the GOF book and have a working knowledge of many of the patterns in the POSA books. • Design principles. You should know the SOLID principles and have a good understanding of the component principles. • Methods. You should understand XP, Scrum, Lean, Kanban, Waterfall, Structured Analysis, and Structured Design. • Disciplines. You should practice TDD, Object-Oriented design, Structured Programming, Continuous Integration, and Pair Programming. • Artifacts: You should know how to use: UML, DFDs, Structure Charts, Petri Nets, State Transition Diagrams and Tables, flow charts, and decision tables. Continuous

Programmers are like magicians who fool everyone into thinking they are perfect and never wrong, but it’s all an act. They make mistakes all the time.

Providing too much detail can be an invitation for micro-management.

The DRY principle tells us to keep the low-level knowledge in the code, where it belongs, and reserve the comments for other, high-level explanations.

We are confidently commanding, in precise detail, the behaviors of a machine that could otherwise do incalculable damage. And so, programming is an act of supreme arrogance.

While humans have been cooking, making music, and building for thousands of years, archaeologists have yet to discover those cave paintings of Man at His DeskTyping

Metaphor has a devilish way of blinding us to the truth.

Undo, Cut, or Revert aren’t viable options when building a skyscraper

we programmers spend our lives writing code so that our fellow human beings no longer need to write code

not just asking questions, having discussions, and taking notes, but asking questions and having discussions while you’re actually coding.

To paraphrase an old joke among programmers, “Writing code accounts for 90 percent of programming. Debugging code accounts for the other 90 percent.” Your computer will do only what you tell it to do; it won’t read your mind and do what you intended it to do. Even professional programmers create bugs all the time, so don’t feel discouraged if your program has a problem.

It is not enough for code to work. Code that works is often badly broken. Programmers who satisfy themselves with merely working code are behaving unprofessionally. They may fear that they don’t have time to improve the structure and design of their code, but I disagree. Nothing has a more profound and long-term degrading effect upon a development project than bad code.

A very simple but particularly useful technique for finding the cause of a problem is simply to explain it to someone else. The other person should look over your shoulder at the screen, and nod his or her head constantly (like a rubber duck bobbing up and down in a bathtub). They do not need to say a word; the simple act of explaining, step by step, what the code is supposed to do often causes the problem to leap off the screen and announce itself.[7] [7] Why "rubber ducking"? While an undergraduate at Imperial College in London, Dave did a lot of work with a research assistant named Greg Pugh, one of the best developers Dave has known. For several months Greg carried around a small yellow rubber duck, which he'd place on his terminal while coding. It was a while before Dave had the courage to ask....

Oftentimes, the whole reason we became programmers in the first place is because we wanted to move beyond being a mere player and change the game, control it, modify its parameters, maybe even create our own games.

Programmers can practice in a similar fashion using a game known as ping-pong.8 The two partners choose a kata, or a simple problem. One programmer writes a unit test, and then the other must make it pass. Then they reverse roles.

Programmers are always surrounded by complexity; we cannot avoid it. Our applications are complex because we are ambitious to use our computers in ever more sophisticated ways. Programming is complex because of the large number of conflicting objectives for each of our programming projects. If our basic tool, the language in which we design and code our programs, is also complicated, the language itself becomes part of the problem rather than part of its solution.

I am a non-accredited, overly logical psychologist, therapist, mechanic, diplomat, businessman, and Teacher working in an industry that is still defining itself each and every day. That is as concise a definition I can give for the modern-day programmer.

Poke the box How do computer programmers learn their art? Is there a step-by-step process that guarantees you’ll get good? All great programmers learn the same way. They poke the box. They code something and see what the computer does. They change it and see what the computer does. They repeat the process again and again until they figure out how the box works. The box might be a computer or it might be a market or it might be a customer or it might be your boss. It’s a puzzle, one that can be solved in only one way—by poking.

One of her secret fantasies had been that, as a girl who could code, she would work in the one place where a geeky fat girl could get dates. It had not been entirely untrue. But as someone had pointed out to her in school, although the odds are good, the goods are odd.

I write them to improve my productivity as a programmer. Making the quality assurance department happy is just a side effect. Unit tests are highly localized. Each test class works within a single package. It tests the interfaces to other packages, but beyond that it assumes the rest just works. Functional tests are a different animal. They are written to ensure the software as a whole works. They provide quality assurance to the customer and don't care about programmer productivity. They should be developed by a different team, one who delights in finding bugs.

Hiro walks straight through the display, and it vanishes. Amusement parks in the Metaverse can be fantastic, offering a wide selection of interactive three-dimensional movies. But in the end, they’re still nothing more than video games. Hiro’s not so poor, yet, that he would go and write video games for this company. It’s owned by the Nipponese, which is no big deal. But it’s also managed by the Nipponese, which means that all the programmers have to wear white shirts and show up at eight in the morning and sit in cubicles and go to meetings. When Hiro learned how to do this, way back fifteen years ago, a hacker could sit down and write an entire piece of software by himself. Now, that’s no longer possible. Software comes out of factories, and hackers are, to a greater or lesser extent, assembly-line workers. Worse yet, they may become managers who never get to write any code themselves.

there is any moral to this story, it’s that, when you are writing code, remember that someone may have to comb through it and check everything when it is being repurposed in the future. It could even be you, long after you have forgotten the original logic behind the code. For this reason, programmers can leave “comments” in their code, which are little messages to anyone else who has to read their code. The programmer mantra should be “Always comment on your code.” And make the comments helpful. I’ve reviewed dense code I wrote years before, to find the only comment is “Good luck, future Matt.

As you’re reading through code, you will find things that you would have never done. You will find things you might have never even thought of. Why? What was the developer thinking? What were his or her motivations? You can even learn from bad code with this kind of critical, self-aware exploration of an existing work.

Managers of programming projects aren’t always aware that certain programming issues are matters of religion. If you’re a manager and you try to require compliance with certain programming practices, you’re inviting your programmers’ ire. Here’s a list of religious issues: ■ Programming language ■ Indentation style ■ Placing of braces ■ Choice of IDE ■ Commenting style ■ Efficiency vs. readability tradeoffs ■ Choice of methodology—for example, Scrum vs. Extreme Programming vs. evolutionary delivery ■ Programming utilities ■ Naming conventions ■ Use of gotos ■ Use of global variables ■ Measurements, especially productivity measures such as lines of code per day

One broken window—a badly designed piece of code, a poor management decision that the team must live with for the duration of the project—is all it takes to start the decline. If you find yourself working on a project with quite a few broken windows, it's all too easy to slip into the mindset of "All the rest of this code is crap, I'll just follow suit.

Pham Nuwen spent years learning to program/explore. Programming went back to the beginning of time. It was a little like the midden out back of his father’s castle. Where the creek had worn that away, ten meters down, there were the crumpled hulks of machines—flying machines, the peasants said—from the great days of Canberra’s original colonial era. But the castle midden was clean and fresh compared to what lay within the Reprise’s local net. There were programs here that had been written five thousand years ago, before Humankind ever left Earth. The wonder of it—the horror of it, Sura said—was that unlike the useless wrecks of Canberra’s past, these programs still worked! And via a million million circuitous threads of inheritance, many of the oldest programs still ran in the bowels of the Qeng Ho system. Take the Traders’ method of timekeeping. The frame corrections were incredibly complex—and down at the very bottom of it was a little program that ran a counter. Second by second, the Qeng Ho counted from the instant that a human had first set foot on Old Earth’s moon. But if you looked at it still more closely. . .the starting instant was actually some hundred million seconds later, the 0-second of one of Humankind’s first computer operating systems. So behind all the top-level interfaces was layer under layer of support. Some of that software had been designed for wildly different situations. Every so often, the inconsistencies caused fatal accidents. Despite the romance of spaceflight, the most common accidents were simply caused by ancient, misused programs finally getting their revenge. “We should rewrite it all,” said Pham. “It’s been done,” said Sura, not looking up. She was preparing to go off-Watch, and had spent the last four days trying to root a problem out of the coldsleep automation. “It’s been tried,” corrected Bret, just back from the freezers. “But even the top levels of fleet system code are enormous. You and a thousand of your friends would have to work for a century or so to reproduce it.” Trinli grinned evilly. “And guess what—even if you did, by the time you finished, you’d have your own set of inconsistencies. And you still wouldn’t be consistent with all the applications that might be needed now and then.” Sura gave up on her debugging for the moment. “The word for all this is ‘mature programming environment.’ Basically, when hardware performance has been pushed to its final limit, and programmers have had several centuries to code, you reach a point where there is far more signicant code than can be rationalized. The best you can do is understand the overall layering, and know how to search for the oddball tool that may come in handy—take the situation I have here.” She waved at the dependency chart she had been working on. “We are low on working fluid for the coffins. Like a million other things, there was none for sale on dear old Canberra. Well, the obvious thing is to move the coffins near the aft hull, and cool by direct radiation. We don’t have the proper equipment to support this—so lately, I’ve been doing my share of archeology. It seems that five hundred years ago, a similar thing happened after an in-system war at Torma. They hacked together a temperature maintenance package that is precisely what we need.” “Almost precisely.

The label “jack-of-all-trades but master of none” is normally meant to be derogatory, implying that the labelee lacks the focus to really dive into a subject and master it. But, when your online shopping application is on the fritz and you’re losing orders by the hundreds as each hour passes, it’s the jack-of-all-trades who not only knows how the application’s code works but can also do low-level UNIX debugging of your web server processes, analyze your RDBMS’s configuration for potential performance bottlenecks, and check your network’s router configuration for hard-to-find problems. And, more important, after finding the problem, the jack-of-all-trades can quickly make architecture and design decisions, implement code fixes, and deploy a new fixed system to production. In this scenario, the manufacturing scenario seems quaint at best and critically flawed at worst.

Alan Turing appears to be becoming a symbol of the shift towards computing, not least because of his attitude of open-minded defiance of convention and conventional thinking. Not only did he conceptualise the modern computer – imagining a simple machine that could use different programmes – but he put his thinking into practice in the great code breaking struggle with the Nazis in World War II, and followed it up with pioneering early work in the mathematics of biology and chaos.

This wasn’t the only mistake they made. They also botched the cleanup operation on the servers they could access. They had created a script called LogWiper.sh to erase activity logs on the servers to prevent anyone from seeing the actions they had taken on the systems. Once the script finished its job, it was also supposed to erase itself, like an Ouroboros serpent consuming its own tail. But the attackers bungled the delete command inside the script by identifying the script file by the wrong name. Instead of commanding the script to delete LogWiper.sh, they commanded it to delete logging.sh. As a result, the LogWiper script couldn’t find itself and got left behind on servers for Kaspersky to find. Also left behind by the attackers were the names or nicknames of the programmers who had written the scripts and developed the encryption algorithms and other infrastructure used by Flame. The names appeared in the source code for some of the tools they developed. It was the kind of mistake inexperienced hackers would make, so the researchers were surprised to see it in a nation-state operation. One, named Hikaru, appeared to be the team leader who created a lot of the server code,

There were other strange signals and signs. Another day, suddenly felt an almost overwhelming urge to travel to Balitmore. I wanted to 'kidnap' a helicoper fly it there if I didn't drive the there', she explains. 'I had no idea where I was to go, only that I was certain I would know my destination as I encountered signs and certain landmarks along the way. I was not even certain who I was to meet, or what my mission was, but I felt I must go.' Beginning to heal by this time with Talbon's help, she resisted that urge. Yet she sensed she would be summoned for three more Cat Woman missions: two in 1999 and one in 2000. As for the code words for activating her, those had been erased from Cheryl's conscious memory. Buried deep in her unconscious mind, however, the words, when called up, cause her to react as her programmers want her to. Though she can't remember the activation codes, Cheryl knows her handlers said the same things every time. 'I'm working on unblocking the words in therapy. Once I know what the words are, I can learn how to stop their effect on me. I did it already when I learned the control code. Standing in front of a mirror, I said the control code words over and over until I was completely desensitised to them. That's what I have to do for the activation code words... but I have not been able to recall all of them as yet.' Dr. Talbon was struck by another very important thing. 'It all hung together. The stories Cheryl told - even though it was upsetting to think people could do stuff like that - they were not disjointed. They were not repetitive in terms of "I've heard this before". It was not just trying consciously or unconsciously to get attention. She'd really processed them out and was done with them. She didn't come up with it again [after telling the story once and dealing with it]. Once it was done, it was done. And I think that was probably the biggest factor for me in her believability. I got no sense that she was using these stories to make herself a really interesting person to me so I'd really want to work with her, or something.

More proof that Lynn is still meant to continue with the government programme occurred during the winter of 2000, when she was sitting at a cafeteria table at the area college. It was later in the afternoon when a few people congregated there with books spread out so they could study while drinking coffee or snacking. Many tables were empty, yet after Lynn had been sitting for a few moments, an elderly man sat down across from her. The old man seemed familiar to Lynn, though, at first, she pretended to ignore him. He said nothing, just sat there as someone might when all the tables are filled and it is necessary to share space with a stranger. His presence made her uncomfortable, yet there was nothing specific that alerted her. A short while later, Mac, the man who had been Lynn's handler in Mexico, came out of the shadows and stopped at the table. He was younger than the old man. His clothes were military casual, the type of garments that veteran students who have military experience might recognise, but not think unusual. He leaned over Lynn and kissed her gently on the forehead, spoke quietly to her, and then said 'Wake up, Sleeping Beauty.' Those were the code words that would start the cover programme of which she was still part. The words led to her being switched from the control of the old man, a researcher she now believes may have been part of Dr Ewen Cameron's staff before coming to the United States for the latter part of his career, to the younger man. The change is like a re-enlistment in an army she never willingly joined. In a very real way, she is a career soldier who has never been paid, never allowed to retire and never given a chance to lead a life free from the fear of what she might do without conscious awareness.

So which theory did Lagos believe in? The relativist or the universalist?" "He did not seem to think there was much of a difference. In the end, they are both somewhat mystical. Lagos believed that both schools of thought had essentially arrived at the same place by different lines of reasoning." "But it seems to me there is a key difference," Hiro says. "The universalists think that we are determined by the prepatterned structure of our brains -- the pathways in the cortex. The relativists don't believe that we have any limits." "Lagos modified the strict Chomskyan theory by supposing that learning a language is like blowing code into PROMs -- an analogy that I cannot interpret." "The analogy is clear. PROMs are Programmable Read-Only Memory chips," Hiro says. "When they come from the factory, they have no content. Once and only once, you can place information into those chips and then freeze it -- the information, the software, becomes frozen into the chip -- it transmutes into hardware. After you have blown the code into the PROMs, you can read it out, but you can't write to them anymore. So Lagos was trying to say that the newborn human brain has no structure -- as the relativists would have it -- and that as the child learns a language, the developing brain structures itself accordingly, the language gets 'blown into the hardware and becomes a permanent part of the brain's deep structure -- as the universalists would have it." "Yes. This was his interpretation." "Okay. So when he talked about Enki being a real person with magical powers, what he meant was that Enki somehow understood the connection between language and the brain, knew how to manipulate it. The same way that a hacker, knowing the secrets of a computer system, can write code to control it -- digital namshubs?" "Lagos said that Enki had the ability to ascend into the universe of language and see it before his eyes. Much as humans go into the Metaverse. That gave him power to create nam-shubs. And nam-shubs had the power to alter the functioning of the brain and of the body." "Why isn't anyone doing this kind of thing nowadays? Why aren't there any namshubs in English?" "Not all languages are the same, as Steiner points out. Some languages are better at metaphor than others. Hebrew, Aramaic, Greek, and Chinese lend themselves to word play and have achieved a lasting grip on reality: Palestine had Qiryat Sefer, the 'City of the Letter,' and Syria had Byblos, the 'Town of the Book.' By contrast other civilizations seem 'speechless' or at least, as may have been the case in Egypt, not entirely cognizant of the creative and transformational powers of language. Lagos believed that Sumerian was an extraordinarily powerful language -- at least it was in Sumer five thousand years ago." "A language that lent itself to Enki's neurolinguistic hacking." "Early linguists, as well as the Kabbalists, believed in a fictional language called the tongue of Eden, the language of Adam. It enabled all men to understand each other, to communicate without misunderstanding. It was the language of the Logos, the moment when God created the world by speaking a word. In the tongue of Eden, naming a thing was the same as creating it. To quote Steiner again, 'Our speech interposes itself between apprehension and truth like a dusty pane or warped mirror. The tongue of Eden was like a flawless glass; a light of total understanding streamed through it. Thus Babel was a second Fall.' And Isaac the Blind, an early Kabbalist, said that, to quote Gershom Scholem's translation, 'The speech of men is connected with divine speech and all language whether heavenly or human derives from one source: the Divine Name.' The practical Kabbalists, the sorcerers, bore the title Ba'al Shem, meaning 'master of the divine name.'" "The machine language of the world," Hiro says.

Tom Demarco, a principal of the Atlantic Systems Guild team of consultants ... and his colleague Timothy Lister devised a study called the Coding War Games. The purpose of the games was to identify the characteristics of the best and worst computer programmers; more than six hundred developers from ninety-two different companies participated. Each designed, coded, and tested a program, working in his normal office space during business hours. Each participant was also assigned a partner from the same company. The partners worked separately, however, without any communication, a feature of the games that turned out to be critical. When the results came in, they revealed an enormous performance gap. The best outperformed the worst by a 10:1 ratio. The top programmers were also about 2.5 times better than the median. When DeMarco and Lister tried to figure out what accounted for this astonishing range, the factors that you'd think would matter — such as years of experience, salary, even the time spent completing the work — had little correlation to outcome. Programmers with 10 years' experience did no better than those with two years. The half who performed above the median earned less than 10 percent more than the half below — even though they were almost twice as good. The programmers who turned in "zero-defect" work took slightly less, not more, time to complete the exercise than those who made mistakes. It was a mystery with one intriguing clue: programmers from the same companies performed at more or less the same level, even though they hadn't worked together. That's because top performers overwhelmingly worked for companies that gave their workers the most privacy, personal space, control over their physical environments, and freedom from interruption. Sixty-two percent of the best performers said that their workspace was acceptably private, compared to only 19 percent of the worst performers; 76 percent of the worst performers but only 38 percent of the top performers said that people often interrupted them needlessly.

Why is programming fun? What delights may its practitioner expect as his reward? First is the sheer joy of making things. As the child delights in his first mud pie, so the adult enjoys building things, especially things of his own design. I think this delight must be an image of God’s delight in making things, a delight shown in the distinctness and newness of each leaf and each snowflake. Second is the pleasure of making things that are useful to other people. Deep within, we want others to use our work and to find it helpful. In this respect the programming system is not essentially different from the child’s first clay pencil holder “for Daddy’s office.” Third is the fascination of fashioning complex puzzle-like objects of interlocking moving parts and watching them work in subtle cycles, playing out the consequences of principles built in from the beginning. The programmed computer has all the fascination of the pinball machine or the jukebox mechanism, carried to the ultimate. Fourth is the joy of always learning, which springs from the nonrepeating nature of the task. In one way or another the problem is ever new, and its solver learns something; sometimes practical, sometimes theoretical, and sometimes both. Finally, there is the delight of working in such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures. (As we shall see later, this very tractability has its own problems.) Yet the program construct, unlike the poet’s words, is real in the sense that it moves and works, producing visible outputs separate from the construct itself. It prints results, draws pictures, produces sounds, moves arms. The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard and a display screen comes to life, showing things that never were nor could be. Programming then is fun because it gratifies creative longings built deep within us and delights sensibilities we have in common with all men.

The thing about Web companies is there's always something severely fucked-up. There is always an outage, always lost data, always compromised customer information, always a server going offline. You work with these clugey internal tools and patch together work-arounds to compensate for the half-assed, rushed development, and after a while the fucked-upness of the whole enterprise becomes the status quo. VPs insecure that they're not as in touch as they need to be with conditions on the ground insert themselves into projects midstream and you get serious scope creep. You present to the world this image that you're a buttoned-down tech company with everything in its right place but once you're on the other side of the firewall it looks like triage time in an emergency room, 24/7. Systems break down, laptops go into the blue screen of death, developers miskey a line of code, error messages appear that mean absolutely nothing. The instantaneousness with which you can fix stuff creates a culture that works by the seat of its pants. I swear the whole Web was built by virtue of developers fixing one mistake after another, constantly forced to compensate for the bugginess of their code.