general-purpose programming language

Terraform: Up and Running: Writing Infrastructure as Code
by Yevgeniy Brikman
Published 13 Mar 2017

Running an ad hoc script on your server For example, here is a Bash script called setup-webserver.sh that configures a web server by installing dependencies, checking out some code from a Git repo, and firing up the Apache web server: # Update the apt-get cache sudo apt-get update # Install PHP sudo apt-get install -y php # Install Apache 20 | Chapter 1: Why Terraform sudo apt-get install -y apache2 # Copy the code from repository sudo git clone https://github.com/brikis98/php-app.git /var/www/html/app # Start Apache sudo service apache2 start The great thing about ad hoc scripts is that you can use popular, general-purpose pro‐ gramming languages and you can write the code however you want. The terrible thing about ad hoc scripts is that you can use popular, general-purpose programming languages and you can write the code however you want. Whereas tools that are purpose-built for IAC provide concise APIs for accomplishing complicated tasks, if you’re using a general-purpose programming language, you have to write completely custom code for every task. Moreover, tools designed for IAC usually enforce a particular structure for your code, whereas with a general-purpose programming language, each developer will use their own style and do something different. Neither of these problems is a big deal for an eight-line script that installs Apache, but it gets messy if you try to use ad hoc scripts to manage hundreds of servers, databases, load balancers, network configurations, and so on.

…

Two environments, each with its own load balancer, web server cluster, and database With just a staging environment, the file layout for your Terraform code looked something like this: stage └ services └ webserver-cluster └ main.tf └ (etc) └ data-stores └ mysql └ main.tf └ (etc) global └ s3 └ main.tf └ (etc) If you were to add a production environment, you’d end up with the following file layout: stage └ services └ webserver-cluster └ main.tf └ (etc) 98 | Chapter 4: How to create reusable infrastructure with Terraform modules └ data-stores └ mysql └ main.tf └ (etc) prod └ services └ webserver-cluster └ main.tf └ (etc) └ data-stores └ mysql └ main.tf └ (etc) global └ s3 └ main.tf └ (etc) How do you avoid duplication between the staging and production environments? How do you avoid having to copy and paste all the code in stage/services/ webserver-cluster into prod/services/webserver-cluster and all the code in stage/data-stores/mysql into prod/data-stores/mysql? In a general-purpose programming language (e.g. Ruby, Python, Java), if you had the same code copied and pasted in several places, you could put that code inside of a function and reuse that function in multiple places throughout your code: def example_function() puts "Hello, World" end # Other places in your code example_function() With Terraform, you can put your code inside of a Terraform module and reuse that module in multiple places throughout your code.

…

Even the database details are hard-coded because the main.tf file you copied into modules/services/webservercluster is using a terraform_remote_state data source to figure out the database address and port, and that terraform_remote_state is hard-coded to look at the staging environment. To fix these issues, you need to add configurable inputs to the webserver-cluster module so it can behave differently in different environments. Module inputs To make a function configurable in a general-purpose programming language, you can add input parameters to that function: def example_function(param1, param2) puts "Hello, #{param1} #{param2}" end # Other places in your code example_function("foo", "bar") In Terraform, modules can have input parameters too. To define them, you use a mechanism you’re already familiar with: input variables.

Masterminds of Programming: Conversations With the Creators of Major Programming Languages
by Federico Biancuzzi and Shane Warden
Published 21 Mar 2009

If you can instead create your domain-specific language out of a base that is a general-purpose programming language, then I think you’re much better off than starting out fresh every time. One of the things that is problematic with general-purpose programming languages today is they’re getting better at creating internal DSLs, and you could view LINQ as an example of that. But what they’re not good at currently is capturing the correct usage patterns of those internal DSLs. In some ways, when you create internal DSLs you actually want to limit the things that you can do with the general-purpose programming language. You want to be able to shut off the general-purposeness of the language, and you want to only reveal it in certain spots in your DSL.

…

I’m speaking only for myself on this, but the mental picture that I have started out with is almost always a little language, something very small and simple, not meant to do big things, not meant to be a general-purpose programming language. But if it’s useful, people start to push its limits and they want more. And typically the things they want are the features of general-purpose programming languages that make them programmable rather than just declarative. They want ways to repeat things, they want ways to avoid having to say the same thing over and over again, and these lead to loops and macros or functions.

…

This is because we learned how to use the abstractions in AWK even more effectively than we initially had thought. Did you find deficiencies in the design of AWK when you wrote the book? Al: When people started using AWK for many other tasks than we initially thought, it exposed certain aspects of the language where we hadn’t intended it to be a general-purpose programming language. I wouldn’t call these “deficiencies,” but it showed that AWK was a specialized language that was not intended for some of the applications that people were trying to use it for. Were you able to address some of those, or did you strongly resist making AWK more general purpose? Al: After the initial version of AWK was created, the language evolved for about a decade with the addition of new constructs and new operators, but it stayed a pattern-action language, a language that was intended for solving data-processing problems.

The C++ Programming Language
by Bjarne Stroustrup
Published 2 Jan 1986

Thus, providing a tool, language, framework, etc., that makes the result of such work available to thousands is a way for programmers and designers to escape the trap of becoming craftsmen of one-of-a-kind artifacts. It is most important that a specification system or a foundation library be able to interface effectively with a general-purpose programming language. Otherwise, the framework provided is inherently limiting. This implies that specification systems and direct-manipulation systems that generate code at a suitable high level into an accepted general-purpose programming language have a great advantage. A proprietary language is a long-term advantage to its provider only. If the code generated is so low-level that general code added must be written without the benefits of abstraction, then reliability, maintainability, and economy are lost.

…

Naturally, the features added and resolutions made since the original edition are integral parts of the presentation. They include refined overloading resolution, memory management facilities, and access control mechanisms, type-safe linkage, ccoonnsstt and ssttaattiicc member functions, abstract classes, multiple inheritance, templates, and exception handling. C++ is a general-purpose programming language; its core application domain is systems programming in the broadest sense. In addition, C++ is successfully used in many application areas that are not covered by this label. Implementations of C++ exist from some of the most modest microcomputers to the largest supercomputers and for almost all operating systems.

…

Murray Hill, New Jersey Bjarne Stroustrup The C++ Programming Language, Third Edition by Bjarne Stroustrup. Copyright ©1997 by AT&T. Published by Addison Wesley Longman, Inc. ISBN 0-201-88954-4. All rights reserved. Preface to the First Edition Language shapes the way we think, and determines what we can think about. – B.L.Whorf C++ is a general purpose programming language designed to make programming more enjoyable for the serious programmer. Except for minor details, C++ is a superset of the C programming language. In addition to the facilities provided by C, C++ provides flexible and efficient facilities for defining new types. A programmer can partition an application into manageable pieces by defining new types that closely match the concepts of the application.

Gnuplot Cookbook
by Lee Phillips
Published 15 Feb 2012

I have compiled the latest version (4.4) of gnuplot on both Linux and Macintosh (OS X) computers and verified that all of its advanced features are fully available on both of these architectures. The recipes in this book that illustrate features newly appearing in version 4.4 are marked with [new]. gnuplot can easily be automated. It has its own scripting language and can be controlled from many general-purpose programming languages. gnuplot can also be incorporated into various publishing and document creation workflows to help create professional books, papers, and online documents. Why this book? Because of gnuplot's many years of deployment and sophisticated community of expert users, help is usually easy to find in some form.

…

There is a basic looping control, a way to iterate over a set of commands, and an if—then—else statement. With these few borrowings from procedural languages, we can do a great deal; and, as we shall see later on in the chapter, if we need more, we can control gnuplot from within almost any general-purpose programming language. In the following figure, the Bessel function is plotted five times, each time with its argument scaled differently, with a different linetype for each curve, and with a curve title for the legend constructed individually for each plot: How to do it… The previous graph could have been made by issuing five individual plot commands, but in fact was produced with a single line highlighted in the following gnuplot script: set term pngcairo mono dashed enhanced set out "file.png" set rmargin at screen .8 set key at screen 1,.7 plot [0 : 3] for [n = 1 : 10 : 2] besj0(n*x) title "J_0(".n."

Numpy Beginner's Guide - Third Edition
by Ivan Idris
Published 23 Jun 2015

The C, C++, and Fortran programming languages have their benefts, but they are not interactve and considered too complex by many. The common commercial alternatves, such as MATLAB, Maple, and Mathematca, provide powerful scriptng languages that are even more limited than any general-purpose programming language. Other open source tools similar to MATLAB exist, such as R, GNU Octave, and Scilab. Obviously, they too lack the power of a language such as Python. Python is a popular general-purpose programming language that is widely used in the scientfc community. You can access legacy C, Fortran, or R code easily from Python. It is object-oriented and considered to be of a higher level than C or Fortran.

Programming Scala
by Unknown
Published 2 Jan 2010

Today, concurrency, heterogeneity, always-on services, and ever-shrinking development schedules are driving interest in functional programming (FP). It appears that the dominance of object-oriented programming may be over. Mixing paradigms is becoming popular, even necessary. We gravitated to Scala from other languages because Scala embodies many of the optimal qualities we want in a general-purpose programming language for the kinds of applications we build today: reliable, high-performance, highly concurrent Internet and enterprise applications. xvii Download at WoweBook.Com Scala is a multi-paradigm language, supporting both object-oriented and functional programming approaches. Scala is scalable, suitable for everything from short scripts up to large-scale, component-based applications.

…

However, when a DSL is appropriate for an application—e.g., when it would be used frequently to implement and change functionality—a well-designed DSL can be a powerful tool for building flexible and robust applications. From the implementation point of view, DSLs are often classified as internal and external. An internal (sometimes called embedded) DSL is an idiomatic way of writing code in a general-purpose programming language, like Scala. No special-purpose parser is necessary for internal DSLs. Instead, they are parsed just like any other code written in the language. In contrast, an external DSL is a custom language with its own custom grammar and parser. Internal DSLs are easier to create because they don’t require a special-purpose parser.

…

A code idiom or design structure that satisfies the 396 | Glossary Download at WoweBook.Com Free Variable needs of a frequently occurring problem, constraint, requirement, etc. Domain-Specific Language A custom programming language that resembles the terms, idioms, and expressions of a particular domain. An internal DSL is an idiomatic form of a general-purpose programming language. That is, no specialpurpose parser is created for the language. Instead, DSL code is written in the generalpurpose language and parsed just like any other code. An external DSL is a language with its own grammar and parser. Duck Typing A term used in languages with dynamic typing for the way method resolution works.

Ansible: Up and Running: Automating Configuration Management and Deployment the Easy Way
by Lorin Hochstein
Published 8 Dec 2014

Dry run See Check mode. DSL Domain-specific language. In systems that use DSLs, the user interacts with the systems by writing text files in the domain-specific language and then runs those files through the system. DSLs are not as powerful as general-purpose programming language, but (if designed well) they are easier to read and write than general-purpose programming language. Ansible exposes a DSL that uses YAML syntax. Dynamic inventory Source that provides Ansible with information about hosts and groups at playbook execution time. EBS Elastic block store. On Amazon EC2, an EBS refers to a persistent disk that can be attached to instances.

Practical OCaml
by Joshua B. Smith
Published 30 Sep 2006

Programming in OCaml will also make you much more aware of types in your code, even if the other languages you program in are not statically typed. A solid understanding of types and their meanings can help nearly all programmers. OCaml will not—at least yet—provide you with shiny resume bullet points. But it will enable you to solve problems faster, with less code and fewer bugs. What Is OCaml Good For? OCaml is a general-purpose programming language, which means that you can program anything in it. However, programming languages are often designed with certain problem domains in mind, and OCaml has areas in which it excels more than others. One of these is in the area of “safe” applications (used here to indicate more than securityrelated safety).

…

Text mining and log file analysis are two areas in which having a lexer/parser combination can result in better code and easier maintenance. A Small Discussion of Small Languages DSLs are programming languages that are focused on one problem domain. That problem domain can be anything: text processing, image manipulation, configuration, page layout, and so on. This focus on a single domain is what separates DSLs from general-purpose programming languages such as OCaml. OCaml is designed to be able to solve problems in a variety of problem domains. DSLs can be a real boon in complicated programs. These languages are often called “extension” languages because they are designed to extend some core functionality. The Emacs text editor, with its extension language Emacs Lisp, is probably one of the best examples of how powerful having an extension language can be.

…

OCaml is not designed to be a web programming language like PHP. Because PHP was designed originally to be a web programming language, it includes many features and functions that provide webcentric functionality (for example, the way PHP allows HTML to be intermingled with PHP code). OCaml was designed to be a general-purpose programming language. As such, it does not focus on one area of deployment, like the web. That doesn’t make it less effective for web programming, but it does mean that the approach to web development taken by the language is 273 620Xch21final.qxd 274 9/22/06 12:27 AM Page 274 CHAPTER 21 ■ PRACTICAL: WEB PROGRAMMING different.

Exploring Python
by Timothy Budd
Published 17 Feb 2009

Together, the intent is that active learning helps you more easily retain and use the information you have learned. Exploring Python – Preface 3 What is Python? For those looking for buzzwords, Python is a high-level, interpreted, reflective, dynamically-typed, open-source, multi-paradigm, general-purpose programming language. I could explain each of those terms in detail, but in the end the result would still not convey what makes Python programming different from other languages. There is no one thing in Python that is not found in other languages, but it is the elegant design and combination of these features into a single package that makes Python such a pleasure to use.

…

Languages do not develop in isolation; they are created for a reason, usually a specific type of problem. Study the type of problems the language is being used to address. Try to understand what features of the language make this type of problem easier, and why those same features might make other types of problems difficult. Python is described as a general purpose programming language. However, the very same features that on the positive side contribute to rapid code development and ease of use are also features that on the negative side can consume a lot of execution time. These features include dynamic typing, infinite precision integers, and high level data structures such as lists and dictionaries.

The Pragmatic Programmer
by Andrew Hunt and Dave Thomas
Published 19 Oct 1999

Domain-Specific Errors If you are writing in the problem domain, you can also perform domain-specific validation, reporting problems in terms your users can understand. Take our switching application on on the facing page. Suppose the user misspelled the format name: From X25LINE1 (Format=AB123) If this happened in a standard, general-purpose programming language, you might receive a standard, general-purpose error message: Syntax error: undeclared identifier But with a mini-language, you would instead be able to issue an error message using the vocabulary of the domain: "AB123" is not a format. Known formats are ABC123, XYZ43B, PDQB, and 42.

…

It forces you to create a more robust, abstract design by deferring details—deferring them all the way out of the program. You can customize the application without recompiling it. You can also use this level of customization to provide easy work-arounds for critical bugs in live production systems. Metadata can be expressed in a manner that's much closer to the problem domain than a general-purpose programming language might be (see Domain Languages, page 57). You may even be able to implement several different projects using the same application engine, but with different metadata. We want to defer definition of most details until the last moment, and leave the details as soft—as easy to change—as we can.

Ruby by example: concepts and code
by Kevin C. Baird
Published 1 Jun 2007

The next chapter focuses on web programming, a venue in which Ruby has become quite popular. 204 C h ap te r 1 0 11 CGI AND THE WEB Ruby has gotten a lot of attention as a language particularly well suited for web programming, especially in the context of the Rails development framework. Some people even go so far as to categorize Ruby as a web language, suggesting that it is not a full-fledged general-purpose programming language. I hope that the previous chapters have played at least a modest role in convincing readers that this assertion is false. That said, Ruby is very useful for web work, and it does have some characteristics that make it better suited for web programming than (for example) video game programming.

…

Other Languages To sum up, Ruby is interpreted, not compiled, making it fast to develop in and slow to run. It is object oriented and functional, not procedural. It has strong, dynamic typing, instead of either weak or static typing, and it only automatically casts type for Boolean tests. It has built-in regular expression support and a clean, readable syntax. It is a general-purpose programming language both in theory and in practice. It has a very large collection of builtin methods, and it allows you to add to, alter, and extend those methods easily. Like its ancestor Lisp, Ruby has a real, usable nil value, and it treats all values except for nil and false as true. Ruby is also very fun to program in, and it stays out of your way. 266 A pp en dix INDEX Symbols & Numbers for instantiating Strings, 23, 108–109, 215–216, 219, 239, 245, 248–250 % w for instantiating Arrays, 47, 113, 115 & (ampersand), for expressing blocks and Procs, 105–106 !

The Art of UNIX Programming
by Eric S. Raymond
Published 22 Sep 2003

Anything larger than this is unlikely to be strictly compact. Among Unix tools, make(1) is compact; autoconf(1) and automake(1) are not. Among markup languages, HTML is semi-compact, but DocBook (a documentation markup language we shall discuss in Chapter 18) is not. The man(7) macros are compact, but troff(1) markup is not. Among general-purpose programming languages, C and Python are semi-compact; Perl, Java, Emacs Lisp, and shell are not (especially since serious shell programming requires you to know half-a-dozen other tools like sed(1) and awk(1)). C++ is anti-compact — the language's designer has admitted that he doesn't expect any one programmer to ever understand it all.

…

One notable example of this convergence was when Intel's 386, with its large flat memory-address space, replaced the 286's awkward segmented-memory addressing after 1985; pure C was actually a better fit for the 386 than it had been for the 286. It is not a coincidence that the experimental era in computer architectures ended in the mid-1980s at the same time that C (and its close descendant C++) were sweeping all before them as general-purpose programming languages. C, designed as a thin but flexible layer over the classical architecture, looks with two decades' additional perspective like almost the best possible design for the structured-assembler niche it was intended to fill. In addition to compactness, orthogonality, and detachment (from the machine architecture on which it was originally designed), it also has the important quality of transparency that we will discuss in Chapter 6.

…

“Script” appears in the V7 manual (1979). I don't recall who coined the name. -- Doug McIlroy In truth, the term ‘scripting language’ is a somewhat awkward one. Many of the the major languages usually so described (Perl, Tcl, Python, etc.) have outgrown the group's scripting origins and are now standalone general-purpose programming languages of considerable power. The term tends to obscure strong similarities in style with other languages that are not usually lumped in with this group, notably Lisp and Java. The only argument for continuing to use it is that nobody has yet invented a better term. Part of the reason all these can be lumped together under the rubric of ‘scripting language’ is that they all have pretty much the same ontogeny.

Dawn of the New Everything: Encounters With Reality and Virtual Reality
by Jaron Lanier
Published 21 Nov 2017

I had read about Scott Kim in Gödel, Escher, Bach, and I knew Warren Robinette from his wonderful video games.5 We’d meet and work into the night, drawing sketches of how people might invent digital worlds to connect with one another. One of my weird little projects was a purely sonic general purpose programming language with no connection to vision at all, operated entirely by singing. An odd development was that by around 1982 I had money. Video game royalty checks! It would have been perverse and bizarre to put this extra money into real estate or stocks. The only imaginable use was to create the dream machines that I was living to try.

…

Skinner box skin sensor cells ski simulator Skype Slater, Mel Smalltalk smartphones Smith, Adam Smith, Alvy Ray Smith, Graham Smith, Jack Smolin, Lee Snapchat Spectacles snark Snow, Michael socialism social media social networking social VR software. See also programming abstractions and obsolescence and two-phase nature of VPL and songlines sonic general purpose programming language Sony PlayStation VR headset Sound of One Hand sounds source code Soviet Union spacetime topological quantum computers Spacewar! videogame spam speakers, audio special purpose simulators speech Speiginer, Gherix Spengler, Marie sphere, dividing spherical videos or spatial video capture Spiegel, Laurie Spielberg, Steven Spinal Tap spying algorithms spy submarine Stallman, Richard Stanford Research Institute (SRI) VALS (Values and Lifestyle Program) Stanford University computer music lab Starship Enterprise Star Trek TNG (TV series) Star Trek (TV series) startups Star Wars (film) State Department Station Q Steam gaming platform Stephenson, Neal stereo 3-D glasses stereo film viewing devices stereo pairing stereo vision Sterling, Bruce Stock Exchange Stone, Linda strategic forgetting string theory subjective experience Sufi Islam suicide, mass Suicide Club suits Sun Microsystems VPL acquired by support calls surgical simulator surveillance Survival Research Lab Sutherland, Ivan Switzerland Swivel 3-D Sword of Damocles symbolic communication symmetrical forms synesthetic sensations synthesizers systems writing tablet Tachi, Susumu tai chi taiko dojos tails Tanguay, Eva Tarahumaras music tarantula taste taxes Taxi Driver (film) teapot avatar tech companies culture of business model of tech culture.

Text Analytics With Python: A Practical Real-World Approach to Gaining Actionable Insights From Your Data
by Dipanjan Sarkar
Published 1 Dec 2016

Getting to Know Python Before we can dive into the Python ecosystem and look at the various components associated with it, we must look back at the origins and philosophy behind Python and see how it has evolved over time to be the choice of language powering many applications, servers, and systems today. Python is a high-level open source general-purpose programming language widely used as a scripting and across different domains. The brainchild of Guido Van Rossum, Python was conceived in the late 1980s as a successor to the ABC language , and both were developed at the Centrum Wiskunde and Informatica (CWI) , Netherlands. Python was originally designed to be a scripting and interpreted language, and to this day it is still one of the most popular scripting languages out there.

…

But with object-oriented programming (OOP) and constructs, you can use it just like any other object-oriented language, such as Java. The name Python, coined by Guido for the language, does not refer to the snake but the hit comedy show Monty Python’s Flying Circus, since he was a big fan. As mentioned, Python is a general-purpose programming language that supports multiple programming paradigms, including the following popular programming paradigms : Object-oriented programming Functional programming Procedural programming Aspect-oriented programming A lot of OOP concepts are present in Python, including classes, objects, data, and methods.

Scala in Action
by Nilanjan Raychaudhuri
Published 27 Mar 2012

In some cases functional programming is obvious; other times it is mixed with object-oriented constructs of Scala. The chapter also touches on monads and practical examples. Chapter 1. Why Scala? This chapter covers What Scala is High-level features of the Scala language Why you should pick Scala as your next language Scala is a general-purpose programming language that runs on Java Virtual Machine (JVM) and .NET platforms. But the recent explosion of programming languages on JVM, .NET, and other platforms raises a question that every developer faces today: which programming language to learn next? Which languages are ready for mainstream development?

…

If you have existing Java applications and are looking for a language that will improve your productivity and at the same time reuse your existing Java codebase, you’ll like Scala’s Java integration and the fact that Scala runs on the JVM platform. Now let’s explore Scala a bit more. 1.1. What’s Scala? Scala is a general-purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional programming languages, enabling programmers to be more productive. Martin Odersky (the creator of Scala) and his team started development on Scala in 2001 in the programming methods laboratory at EPFL (École Polytechnique Fédérale de Lausanne).

Quantitative Trading: How to Build Your Own Algorithmic Trading Business
by Ernie Chan
Published 17 Nov 2008

If you backtested on such a platform, then it is trivial to configure it so that the program will submit real orders to your account. This dispenses with the need to write your own software, whether for backtesting or for automated execution. However, as I mentioned in Chapter 3, the drawback of such proprietary systems is that they are seldom as flexible as a general-purpose programming language like MATLAB or Java for the construction of your strategy. For instance, if you want to pursue a rather mathematically complex strategy based on principal component analysis (such as the one in Example 7.4), it would be quite difficult to backtest in TradeStation. More advanced integrated trading platforms such as Alphacet’s Discovery do P1: JYS c05 JWBK321-Chan 86 September 24, 2008 13:55 Printer: Yet to come QUANTITATIVE TRADING provide a much larger variety of algorithms to be backtested and implemented, but they may not be affordable to the typical independent trader.

97 Things Every Programmer Should Know
by Kevlin Henney
Published 5 Feb 2010

DSLs targeted at software developers or scientists have been around for a long time. The Unix "little languages" found in configuration files and the languages created with the power of LISP macros are some of the older examples. DSLs are commonly classified as either internal or external: Internal DSLs Are written in a general-purpose programming language whose syntax has been bent to look much more like natural language. This is easier for languages that offer more syntactic sugar and formatting possibilities (e.g., Ruby and Scala) than it is for others that do not (e.g., Java). Most internal DSLs wrap existing APIs, libraries, or business code and provide a wrapper for less mind-bending access to the functionality.

The Productive Programmer
by Neal Ford
Published 8 Dec 2008

For an example of this, check out Jaskell* and, in particular, the build DSL written on top of it called Neptune.† Neptune performs the same basic tasks as Ant, but it is written as a domain-specific language atop Jaskell. It shows how readable and concise you can make code in Jaskell, using a familiar problem domain. NOTE Dietzler’s Law: even general-purpose programming languages suffer from the “80-10-10” rule. The Law of Demeter The Law of Demeter was developed at Northwestern University in the late ’80s. It is best summarized by the phrase, “Only talk to your closest friends.” The idea is that any given object shouldn’t know anything about the internal details of the objects with which it interacts.

The Ethical Algorithm: The Science of Socially Aware Algorithm Design
by Michael Kearns and Aaron Roth
Published 3 Oct 2019

But this book, and the emerging research it describes, is about an entirely new dimension in algorithm design: the explicit consideration of social values such as privacy and fairness. Man Versus Machine (Learning) Algorithms such as the sorting algorithm we describe above are typically coded by the scientists and engineers who design them: every step of the procedure is explicitly specified by its human designers, and written down in a general-purpose programming language such as Python or C++. But not all algorithms are like this. More complicated algorithms—the type that we categorize as machine learning algorithms—are automatically derived from data. A human being might hand-code the process (or meta-algorithm) by which the final algorithm—sometimes called a model—is derived from the data, but she doesn’t directly design the model itself.

Programming Clojure
by Stuart Halloway and Aaron Bedra
Published 17 Apr 2012

Of all these languages, Clojure stands out. The individual features listed earlier are powerful and interesting. Their clean synergy in Clojure is compelling. We will cover all these features and more in Chapter 1, ​Getting Started​. Who This Book Is For Clojure is a powerful, general-purpose programming language. As such, this book is for experienced programmers looking for power and elegance. This book will be useful for anyone with experience in a modern programming language such as C#, Java, Python, or Ruby. Clojure is built on top of the Java Virtual Machine, and it is fast. This book will be of particular interest to Java programmers who want the expressiveness of a dynamic language without compromising on performance.

The C Programming Language
by Brian W. Kernighan and Dennis M. Ritchie
Published 15 Feb 1988

We used Bjarne Stroustrup's C++ translator extensively for local testing of our programs, and Dave Kristol provided us with an ANSI C compiler for final testing. Rich Drechsler helped greatly with typesetting. Our sincere thanks to all. Brian W. Kernighan Dennis M. Ritchie 8 Preface to the first edition C is a general-purpose programming language with features economy of expression, modern flow control and data structures, and a rich set of operators. C is not a ``very high level'' language, nor a ``big'' one, and is not specialized to any particular area of application. But its absence of restrictions and its generality make it more convenient and effective for many tasks than supposedly more powerful languages.

Successful Lisp - About
by Unknown

The emergence of compilers for stock hardware As work began in earnest on the Common Lisp standard, vendors -- most of whom had employees on the standardization committee -- were quick to implement the recommendations under discussion. One of the biggest benefits was the definition of the interface to and behavior of the Lisp compiler; this, together with advances in compiler and garbage collector technology, was a first step toward making Lisp competitive in the arena of general-purpose programming languages. The long road to standardization The committee produced the first public edition of the Common LISP specification in 1984. In a shining example of computer mediated cooperative work, hundreds of LISP users and implementers exchanged thousands of email messages to propose, debate, and vote upon each feature of the new language.

Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement
by Eric Redmond , Jim Wilson and Jim R. Wilson
Published 7 May 2012

Population Script We’ll need a bit more data in this section. To achieve that, we’ll switch to an example using a different kind of hotel, one for people and not pets. A quick populator script in Ruby will create data for a gigantic 10,000-room hotel. If you are not familiar with Ruby, it is a popular general-purpose programming language. It’s quite useful for writing quick scripts in a straightforward and readable manner. You can learn more about Ruby in Programming Ruby: The Pragmatic Programmer’s Guide [TH01] by Dave Thomas and Andy Hunt, as well as online.[12] You’ll also need Ruby’s package manager called RubyGems.[13] With Ruby and RubyGems installed, next install the Riak driver.[14] You may also require the json driver and can run both to make sure

Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
by Martin Kleppmann
Published 16 Mar 2017

Pros and cons of stored procedures Stored procedures have existed for some time in relational databases, and they have been part of the SQL standard (SQL/PSM) since 1999. They have gained a somewhat bad reputation, for various reasons: Each database vendor has its own language for stored procedures (Oracle has PL/SQL, SQL Server has T-SQL, PostgreSQL has PL/pgSQL, etc.). These languages haven’t kept up with developments in general-purpose programming languages, so they look quite ugly and archaic from today’s point of view, and they lack the ecosystem of libraries that you find with most programming languages. Code running in a database is difficult to manage: compared to an application server, it’s harder to debug, more awkward to keep in version control and deploy, trickier to test, and difficult to integrate with a metrics collection system for monitoring.

…

A badly written stored procedure (e.g., using a lot of memory or CPU time) in a database can cause much more trouble than equivalent badly written code in an application server. However, those issues can be overcome. Modern implementations of stored procedures have abandoned PL/SQL and use existing general-purpose programming languages instead: VoltDB uses Java or Groovy, Datomic uses Java or Clojure, and Redis uses Lua. With stored procedures and in-memory data, executing all transactions on a single thread becomes feasible. As they don’t need to wait for I/O and they avoid the overhead of other concurrency control mechanisms, they can achieve quite good throughput on a single thread.

Managing Projects With GNU Make
by Robert Mecklenburg and Andrew Oram
Published 19 Nov 2004

Appendixes The final section of this book contains information that is not central to the goals ofthe book, but you might find it useful for unusual situations. Appendix A lists the options that the GNU make command accepts on the command line. Appendix B, which you will find amusing and possibly useful, stretches make to act as a general-purpose programming language with data structures and arithmetic operations. Appendix C contains the free license for the book. Appendix A, Running make Makefile Appendix B, The Outer Limits Appendix C, GNU Free Documentation License—GNU Project—Free Software Foundation (FSF) Appendix A. Running make GNU make has an impressive set of command-line options.

Only Humans Need Apply: Winners and Losers in the Age of Smart Machines
by Thomas H. Davenport and Julia Kirby
Published 23 May 2016

More recently, programming in business rule engines (IBM’s ILOG and Fair Isaac’s Blaze, for example) was a common approach to automated systems development. While such jobs still exist, they are not the preferred tools in which most software development in the automation space is done. Most development is done in general-purpose programming languages (Java is the most popular of these by far) and in scripting languages that automate the processing of tasks with a script (Python and Ruby are popular scripting languages). These types of programmers should also be familiar with the tools to store and process big data, including the open-source tools Hadoop and Map/Reduce, Storm, Cassandra, Hive, and Mahout.

Network Security Through Data Analysis: Building Situational Awareness
by Michael S Collins
Published 23 Feb 2014

. > i<-0 > repeat { + i <- i + 1 + print(i) + if (i > 4) break; + } [1] 1 [1] 2 [1] 3 [1] 4 [1] 5 > # The while loop with identical functionality; this one doesn't require the > # break statement > i <- 1 > while( i < 6) { + print(i) + i <- i + 1 + } [1] 1 [1] 2 [1] 3 [1] 4 [1] 5 > # The for loop is most compact > s<-1:5 > for(i in s) print(i) [1] 1 [1] 2 [1] 3 [1] 4 [1] 5 Although R provides these looping constructs, it’s generally better to avoid loops in favor of functional operations such as sapply. R is not a general purpose programming language; it was explicitly designed to provide statistical analysts with a rich toolkit of operations. R contains an enormous number of optimized functions and other tools available for manipulating data. We cover some later in this chapter, but a good R reference source is invaluable. Using the R Workspace R provides users with a persistent workspace, meaning that when a user exits an R session, they are provided the option to save the data and variables they have in place for future use.

What the Dormouse Said: How the Sixties Counterculture Shaped the Personal Computer Industry
by John Markoff
Published 1 Jan 2005

In many respects, it foreshadowed HTML—the markup language that would come to define the World Wide Web and make Internet publishing possible—in that it was the first language to use a feature known as “embedded tags.” At the time, the typesetting industry was independently developing similar languages, but they were all specific to a particular machine. Tesler’s was the first general-purpose programming language that would do typesetting for any type of device. While PUB was finding a devoted band of users, Tesler decided he had had enough of AI research. The Whole Earth Catalog was having a growing influence on the nascent counterculture, and thousands of people in their twenties were leaving the cities and striking out to create a back-to-the-land communal existence.

The Art of R Programming
by Norman Matloff

• It is comparable, and often superior, in power to commercial products in most of the significant senses—variety of operations available, programmability, graphics, and so on. • It is available for the Windows, Mac, and Linux operating systems. • In addition to providing statistical operations, R is a general-purpose programming language, so you can use it to automate analyses and create new functions that extend the existing language features. • It incorporates features found in object-oriented and functional programming languages. • The system saves data sets between sessions, so you don’t need to reload them each time.

When Computers Can Think: The Artificial Intelligence Singularity
by Anthony Berglas , William Black , Samantha Thalind , Max Scratchmann and Michelle Estes
Published 28 Feb 2015

In particular, it is not possible to assert disjunctions (i.e. or) such as Murderer(Butler) or Murderer(Widow) and so make the interesting deductions that solve the crime. It is also not possible to distinguish things that are known to be false from things that are simply not known to be true. Various attempts have been made to address these shortcomings, but they all have issues and none have become widely used. (Prolog can also be used as a general purpose programming language by making assumptions as to how its very simple theorem prover works — hence the name programming in logic. However, most AI programmers traditionally preferred the dedicated programming language Lisp. Lisp has powerful macro and other features and enabled many different paradigms to be used including but not limited to Prolog’s Horne clause logic.

Concepts, Techniques, and Models of Computer Programming
by Peter Van-Roy and Seif Haridi
Published 15 Feb 2004

The transactional solution satis- 602 Shared-State Concurrency fies one of our criteria for adding a concept to the computation model, namely that programs in the extended model are simpler. But what exactly is the concept to be added? This is still an open research subject. In our view, it is a very important one. Some day, the solution to this question will be an important part of all general-purpose programming languages. In this section we do not solve this problem. We will implement transactions as an abstraction in the concurrent stateful model without changing the model. 8.5.1 Concurrency control Consider a large database accessed by many clients at the same time. What does this imply for transactions?

…

D.6 Layered language design The general computation model has a layered design. Each layer offers its own special trade-off of expressiveness and ease of reasoning. The programmer can choose the layer that is best adapted to each part of the program. From the evidence presented in the book, it is clear that this layered structure is beneficial for a general-purpose programming language. It makes it easier for the programmer to say directly what he or she wants to say, without cumbersome encodings. The layered design of the general computation model can be found to some degree in many languages. Object-oriented languages such as Smalltalk, Eiffel, and Java have two layers: an object-oriented core and a second layer providing shared- D.6 Layered language design 851 state concurrency [68, 140, 11].

Gnuplot in Action: Understanding Data With Graphs
by Philipp Janert
Published 2 Jan 2010

We can bind commands to specific keys and capture certain kinds of mouse input. Gnuplot can be used to serve up dynamically generated images from a web server. If we don’t need to process individual, dynamic user input, it’s sufficient to use an appropriate gnuplot batch file as server-side script. Using a wrapper in a general-purpose programming language, which employs gnuplot as graphing engine, gives us much greater flexibility. Now that we know how to use gnuplot, I want to spend some time discussing what can be done with it. This is what the next (and last) part of this book is about: applications of graphical analysis. Stay tuned. 

The End of Work
by Jeremy Rifkin
Published 28 Dec 1994

Moreover a robot is not subject to the random variations in performance ... and is for all practical purposes working as hard, as conscientiously, and as consistentlyat the end of the shift as it is at the beginning."13 Industrial engineers are currently developing even more advanced machine surrogates "with such capabilities as voice communication, a general purpose programming language, learning from experience, three-dimensional vision with color sensitivity, multiple hand to hand coordination, walking and self-navigating skills, and selfdiagnostic and correction skills." The goal, says sociologist Michael Wallace, "is to approach, as closely as possible, the human capabilities to process environmental data and to solve problems, while avoiding the problems (e.g. absenteeism and turnover) presented by human agents."14 It is estimated that each robot replaces four jobs in the economy, and if in constant use twenty-four hours a day, will pay for itself in just over one year.

Elixir in Action
by Saša Jurić
Published 30 Jan 2019

Because this book deals with upper-intermediate topics, there are some prerequisites you should meet before reading it. I’ve assumed you’re a professional software developer with a couple years of experience. The exact technology you’re proficient in isn’t relevant: it can be Java, C#, Ruby, C++, or another general-purpose programming language. Any experience in development of backend (server-side) systems is welcome. You don’t need to know anything about Erlang, Elixir, or other concurrent platforms. In particular, you don’t need to know anything about functional programming. Elixir is a functional language, and if you come from an OO background, this may scare you a bit.

Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython
by Wes McKinney
Published 25 Sep 2017

Data Cleaning and Preparation During the course of doing data analysis and modeling, a significant amount of time is spent on data preparation: loading, cleaning, transforming, and rearranging. Such tasks are often reported to take up 80% or more of an analyst’s time. Sometimes the way that data is stored in files or databases is not in the right format for a particular task. Many researchers choose to do ad hoc processing of data from one form to another using a general-purpose programming language, like Python, Perl, R, or Java, or Unix text-processing tools like sed or awk. Fortunately, pandas, along with the built-in Python language features, provides you with a high-level, flexible, and fast set of tools to enable you to manipulate data into the right form. If you identify a type of data manipulation that isn’t anywhere in this book or elsewhere in the pandas library, feel free to share your use case on one of the Python mailing lists or on the pandas GitHub site.

Advanced Software Testing—Vol. 3, 2nd Edition
by Jamie L. Mitchell and Rex Black
Published 15 Feb 2015

For example, some test tools can talk directly to the web server at the HTTP and HTTPS interfaces rather than pushing test input through the browser. Tests written to the API level tend to be much more stable than those written to the GUI level because the API tends to evolve much more slowly than the GUI. Scripting languages and their capabilities vary widely. Some scripting languages are like general-purpose programming languages. Others are domain specific, like TTCN-3 (used predominately in the conformance testing of communication systems). Some are not domain specific but have features that have made them popular in certain domains, like TCL in the telephony and embedded systems worlds. Many modern tools support widely understood programming languages (e.g., Java, Ruby, and VBA) rather than the custom, special-purpose languages of the early tools (e.g., TSL, SQA Basic, and 4Test).

ANSI Common LISP
by Paul Graham
Published 12 Nov 1995

Explain what's wrong with each, and give a correct version: (a) (defun summit ( 1 s t ) (remove nil 1st) (apply #' + 1st)) (b) (defun summit (1st) (let ((x (car 1st))) (if (null x) (summit (cdr 1st)) (+ x (summit (cdr 1st)))))) 3 Lists Lists are one of the fundamental data structures in Lisp. In the earliest dialects they were the only data structure: the name "Lisp" originally stood for "LISt Processor." But Lisp has long since outgrown this acronym. Common Lisp is a general-purpose programming language with a wide variety of data structures. The development of Lisp programs often echoes the development of Lisp itself. In the initial version of a Lisp program, you may use a lot of lists. Then in later versions you may switch to faster, specialized data structures. This chapter describes the many things you can do with lists, and uses them to illustrate some general Lisp concepts. 3.1 Conses Section 2.4 introduced cons, car, and cdr, the primitive list-manipulation functions.

Mastering Blockchain, Second Edition
by Imran Bashir
Published 28 Mar 2018

It is also important to understand the concept of domain-specific languages as this type of languages can be developed to program smart contracts. These languages are developed with limited expressiveness for a particular application or area of interest. Domain-specific languages (DSLs) are different from general-purpose programming languages (GPLs). DSLs have a small set of features that are sufficient and optimized for the domain they are intended to be used in and, unlike GPLs, are usually not used to build general purpose large application programs. Based on the design philosophy of DSLs it can be envisaged that such languages will be developed specifically to write smart contracts.

The Cryptopians: Idealism, Greed, Lies, and the Making of the First Big Cryptocurrency Craze
by Laura Shin
Published 22 Feb 2022

Because it was nearly impossible to tamper with a universally agreed-upon ledger of transactions, the Bitcoin blockchain could serve as a golden historical record for other assets or transactions attached to these negligible amounts of bitcoin. Vitalik’s mind was opened to the possibility of “layer 2” functionalities. At Waterloo, he’d studied data structures and programming languages. The people creating layer 2 were building features specific to each application. Why, he wondered, couldn’t they devise a general-purpose programming language that would enable anyone to build any application he or she wanted to build? Vitalik tried to nudge another project, Mastercoin (a “Swiss Army knife” of blockchains, in that it contained multiple features), in this direction. At first, he proposed something called “contracts for difference” on Mastercoin via a BitcoinTalk post.16 Then he wrote up something he named Ultimate Scripting (asking Mastercoin for a $250 fee), a proposal for how to upgrade Mastercoin to make two-party financial contracts possible with whatever rules one wanted.

Beautiful Architecture: Leading Thinkers Reveal the Hidden Beauty in Software Design
by Diomidis Spinellis and Georgios Gousios
Published 30 Dec 2008

To programmers who have not followed the arrival of object-oriented programming to center stage in the 1980s and 1990s, this rule might not seem overly important. But if one recalls that time, one of the defining concepts in object-oriented programming was inheritance. Take, for instance, Bjarne Stroustrup’s description of C++ in The C++ Programming Language (1985). We find there (p. 21) that: C++ is a general purpose programming language with a bias toward systems programming that: Is a better C Supports data abstraction Supports object-oriented programming Supports generic programming If we then turn to see exactly what “supports object-oriented programming” entails (p. 39), we find: The programming paradigm is: Decide which classes you want Provide a full set of operations for each class Make commonality explicit by using inheritance Now consider by contrast yet another classic, Joshua Bloch’s Effective Java (2008).

The Founders: The Story of Paypal and the Entrepreneurs Who Shaped Silicon Valley
by Jimmy Soni
Published 22 Feb 2022

The next few years blurred together as Zip2 raced to compete against Microsoft, Citysearch, AOL, and Yahoo for a slice of the $60 billion local advertising pie. Musk had his first real taste of start-up life during this period, with its requisite highs and lows. Zip2’s innovations—working digital maps, a free email service, even a feature to reserve a seat at a restaurant via fax machine—thrilled Musk. The general-purpose programming language Java launched in January 1996; by September, Musk and his technology team had put Java at Zip2’s core. Dr. Lew Tucker, a senior director at JavaSoft, sang Zip2’s praises. “Zip2’s groundbreaking maps and directions are some of the most powerful real-world applications of Java on the internet today,” said Dr.

Programming Python
by Mark Lutz
Published 5 Jan 2011

We could turn this code into generally useful tools by refactoring it into reusable parts, as we’ll see later in this section. First, though, let’s explore techniques for getting data into our databases. Loading Database Tables from Files One of the nice things about using Python in the database domain is that you can combine the power of the SQL query language with the power of the Python general-purpose programming language. They naturally complement each other. Loading with SQL and Python Suppose, for example, that you want to load a database table from a flat file, where each line in the file represents a database row, with individual field values separated by commas. Examples 17-6 and 17-7 list two such datafiles we’re going to be using here.

…

In the email package example, fixing its problems seems much easier than coding an email parser and generator from scratch—a task far too large to have even attempted in this book. Python’s batteries included approach to development can be amazingly productive—even when some of those batteries require a charge. Custom Language Parsers Although toolkits abound in this domain, Python’s status as a general-purpose programming language also makes it a reasonable vehicle for writing hand-coded parsers for custom language analysis tasks. For instance, recursive descent parsing is a fairly well-known technique for analyzing language-based information. Though not as powerful as some language tools, recursive descent parses are sufficient for a wide variety of language-related goals.

…

Though not as powerful as some language tools, recursive descent parses are sufficient for a wide variety of language-related goals. To illustrate, this section develops a custom parser for a simple grammar—it parses and evaluates arithmetic expression strings. Though language analysis is the main topic here, this example also demonstrates the utility of Python as a general-purpose programming language. Although Python is often used as a frontend or rapid development language in tactical modes, it’s also often useful for the kinds of strategic work you may have formerly done in a systems development language such as C or C++. The Expression Grammar The grammar that our parser will recognize can be described as follows: goal -> <expr> END [number, variable, ( ] goal -> <assign> END [set] assign -> 'set' <variable> <expr> [set] expr -> <factor> <expr-tail> [number, variable, ( ] expr-tail -> ^ [END, ) ] expr-tail -> '+' <factor> <expr-tail> [+] expr-tail -> '-' <factor> <expr-tail> [-] factor -> <term> <factor-tail> [number, variable, ( ] factor-tail -> ^ [+, -, END, ) ] factor-tail -> '*' <term> <factor-tail> [*] factor-tail -> '/' <term> <factor-tail> [/] term -> <number> [number] term -> <variable> [variable] term -> '(' <expr> ')' [(] tokens: (, ), num, var, -, +, /, *, set, end This is a fairly typical grammar for a simple expression language, and it allows for arbitrary expression nesting (some example expressions appear at the end of the testparser module listing in Example 19-15).

Clojure Programming
by Chas Emerick , Brian Carper and Christophe Grand
Published 15 Aug 2011

The evaluation of symbols to the entity they name depends upon their context and the namespaces available within that context. We talk about the semantics of namespaces and symbol evaluation extensively in Namespaces. Numbers Clojure provides a plethora of numeric literals (see Table 1-2). Many of them are pedestrian, but others are rare to find in a general-purpose programming language and can simplify the implementation of certain algorithms—especially in cases where the algorithms are defined in terms of particular numeric representations (octal, binary, rational numbers, and scientific notation). Warning While the Java runtime defines a particular range of numeric primitives, and Clojure supports interoperability with those primitives, Clojure has a bias toward longs and doubles at the expense of other widths, including bytes, shorts, ints, and floats.

Building Secure and Reliable Systems: Best Practices for Designing, Implementing, and Maintaining Systems
by Heather Adkins , Betsy Beyer , Paul Blankinship , Ana Oprea , Piotr Lewandowski and Adam Stubblefield
Published 29 Mar 2020

Creating a template system that can handle all possible combinations of corner cases is complicated, and using that system won’t be straightforward. In other domains, this issue can grow even more complex. For example, business needs might dictate complex rules about who can perform an action and who cannot. Unless your authorization library is as expressive (and as hard to analyze) as a general-purpose programming language, you might not be able to meet all developer needs. Instead, you can start with a simple, small library that covers only common use cases but is easier to use correctly. Simple libraries are easier to explain, document, and use. These qualities reduce developer friction and may help you convince other developers to adopt the secure-by-design library.

Real World Haskell
by Bryan O'Sullivan , John Goerzen , Donald Stewart and Donald Bruce Stewart
Published 2 Dec 2008

As you become a more seasoned Haskell programmer, the way that you write code will change. Indeed, over the course of this book, the way that we present code will evolve, as we move from the basics of the language to increasingly powerful and productive features and techniques. What to Expect from Haskell Haskell is a general-purpose programming language. It was designed without any application niche in mind. Although it takes a strong stand on how programs should be written, it does not favor one problem domain over others. While at its core, the language encourages a pure, lazy style of functional programming, this is the default, not the only option.

Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
by Martin Kleppmann
Published 17 Apr 2017

The difference between an interactive transaction and a stored procedure (using the example transaction of Figure 7-8). 254 | Chapter 7: Transactions Pros and cons of stored procedures Stored procedures have existed for some time in relational databases, and they have been part of the SQL standard (SQL/PSM) since 1999. They have gained a somewhat bad reputation, for various reasons: • Each database vendor has its own language for stored procedures (Oracle has PL/ SQL, SQL Server has T-SQL, PostgreSQL has PL/pgSQL, etc.). These languages haven’t kept up with developments in general-purpose programming languages, so they look quite ugly and archaic from today’s point of view, and they lack the ecosystem of libraries that you find with most programming languages. • Code running in a database is difficult to manage: compared to an application server, it’s harder to debug, more awkward to keep in version control and deploy, trickier to test, and difficult to integrate with a metrics collection system for monitoring. • A database is often much more performance-sensitive than an application server, because a single database instance is often shared by many application servers.

Ajax: The Definitive Guide
by Anthony T. Holdener
Published 25 Jan 2008

As the Web 2.0 movement grows with more Ajax web applications replacing the more classic sites, LAMP will be right there as well. Check out O’Reilly’s LAMP site, ONLamp.com, at http://www.onlamp.com/ for more on LAMP. Python Guido van Rossum created Python in 1990, not as a scripting language but as a general-purpose programming language. Python 2.1 came out in 2002 and is significant not just because it combined Python 1.6.1 and Python 2.0 into a single release, but because Python 2.1 was the first version of Python to fall under a new license owned by the Python Software Foundation. At the time of this writing, Python 2.5.1 is the stable production version of the software. 42 | Chapter 3: Servers, Databases, and the Web Python fills the role of a scripting language often, from the Web to databases and even to games.

Artificial Intelligence: A Modern Approach
by Stuart Russell and Peter Norvig
Published 14 Jul 2019

This chapter and the next concentrate on the task of representing and computing with probabilistic information in general. Chapter 14 deals with methods for the specific tasks of representing and updating the belief state over time and predicting outcomes. Chapter 18 looks at ways of combining probability theory with expressive formal languages such as firstorder logic and general-purpose programming languages. Chapter 15 covers utility theory in more depth, and Chapter 16 develops algorithms for planning sequences of actions in stochastic environments. Chapter 17 covers the extension of these ideas to multiagent environments. 12.2Basic Probability Notation For our agent to represent and use probabilistic information, we need a formal language.