# functional programming

120 results back to index

Scala in Action by Nilanjan Raychaudhuri

Knowing the difference between strict and nonstrict processing will help you decide which type of collection would be useful and when. The next chapter explores functional programming. You’ll learn what functional programming is and how to do functional programming in Scala. Understanding functional programming will help you build functional, immutable, and simple solutions. Chapter 5. Functional programming This chapter covers Why functional programming matters Mixing functional programming with OOP Functions in various forms Monads and their practical examples You’re already doing functional programming using Scala if you’ve been following the examples in the book. In some cases it’s explicitly mentioned or visible and in other cases it’s mixed with object-oriented constructs of the Scala language.

Parallel collection hierarchy 4.11.2. Switching between sequential and parallel collections 4.12. Summary Chapter 5. Functional programming 5.1. What is functional programming? 5.1.1. The benefits of referential transparency 5.1.2. A pure functional program 5.2. Moving from OOP to functional programming 5.2.1. Pure vs. impure programming 5.2.2. Object-oriented patterns in functional programming 5.2.3. Modeling purely functional programs 5.3. Functions in all shapes and forms 5.3.1. Methods vs. functions 5.3.2. Higher-order functions 5.3.3. Function currying 5.3.4.

In some cases it’s explicitly mentioned or visible and in other cases it’s mixed with object-oriented constructs of the Scala language. This chapter focuses on functional programming concepts and how they can be implemented in Scala. The goal of the chapter is to make you comfortable with functional programming and help you to write code in functional programming style. Functional programming is a programming paradigm that models computation as the evaluation of expressions. And expressions are built using functions that don’t have mutable state and side effects. Exploring the roots of functional programming is valuable.[1] Believe it or not, functional programming started around 1930 when Alonzo Church introduced lambda calculus.[2] A lambda calculus (λ calculus) is a formal mathematical system to investigate functions, function application, and function recursion.

pages: 210 words: 42,271

Programming HTML5 Applications by Zachary Kessin

URL query string separator, Debugging Manifest Files A Abelson, Harold, Functional Programming acceptance tests, Testing JavaScript Applications accessibility, Accessibility Through WAI-ARIA Accessible Rich Internet Applications, Accessibility Through WAI-ARIA actions, Selenium, Selenium Commands ActiveX controls, IndexedDB add() method (IndexedDB), Adding and Updating Records airplane mode, Adding Power to Web Applications Ajax, Developing Web Applications, Nonblocking I/O and Callbacks, Nonblocking I/O and Callbacks, Functional Programming, Functional Programming, A Simple Example, Offline Loading with a Data Store, Storing Changes for a Later Server Sync, Uploading Files, Structure of the Manifest File calls, Nonblocking I/O and Callbacks, Functional Programming, A Simple Example, Offline Loading with a Data Store, Storing Changes for a Later Server Sync, Structure of the Manifest File DataStore object, Nonblocking I/O and Callbacks uploading files with, Uploading Files versus XHR terminology, Functional Programming alert() method, Nonblocking I/O and Callbacks alt attribute, Accessibility Through WAI-ARIA Android, Selenium RC and a Test Farm, New Form Types _AndWait commands (Selenium), Selenium Commands anonymous functions, Lambda Functions Are Powerful Apache web server, Introduction to the Manifest File append() method, Uploading Files appending an image example, Working with Files Apple Safari, JavaScript’s Triumph, A Pattern for Reuse of Multithread Processing, Libraries for Web Workers, Web Sockets Aptana, JavaScript Tools You Should Know archive files, Drag-and-Drop array, Functional Programming, Array Iteration Operations, You Can Extend Objects, Too iteration operations, Array Iteration Operations, You Can Extend Objects, Too map function, Functional Programming assertElementPresent command (Selenium), Selenium Commands assertions, Selenium, Selenium Commands <audio> tag, Audio and Video automatic updates, Developing Web Applications B base types, extending, Prototypes and How to Expand Objects beforeload event handler, Offline Loading with a Data Store Benedetti, Ryan, JavaScript’s Triumph binary data, The Web Sockets Interface binding variables, Closures blob data type, Blobs BlobBuilder, Blobs Booleans as objects, Prototypes and How to Expand Objects bottlenecks, Splitting Up Work Through Web Workers, JavaScript Tools You Should Know Breadcrumbs specs, Microdata browsers, The Web As Application Platform, Developing Web Applications, Lambda Functions Are Powerful, Testing JavaScript Applications, Selenium RC and a Test Farm, Local Storage, jStore, Updates to the Manifest File, Updates to the Manifest File, Debugging Manifest Files (see also Chrome, Firefox, Internet Explorer, Safari) cache control header issues, Updates to the Manifest File, Debugging Manifest Files data storage and, Local Storage, jStore differences among, Testing JavaScript Applications function inside an if, Lambda Functions Are Powerful interactivity, The Web As Application Platform, Developing Web Applications testing on multiple, Selenium RC and a Test Farm buildMaster() method, Web Worker Fractal Example built-in objects, Prototypes and How to Expand Objects buttons, Lambda Functions Are Powerful, Closures, A Simple Example, Testing with QUnit, Selenium, Selenium Commands, Selenese Command Programming Interface click callbacks, Lambda Functions Are Powerful, A Simple Example, Testing with QUnit closures, Closures testing, Selenium, Selenese Command Programming Interface with XPath, Selenium Commands C C-type languages, Lambda Functions Are Powerful cache control headers, Updates to the Manifest File, Debugging Manifest Files cache() method, Expanding Functions with Prototypes Cagle, Kurt, Canvas and SVG callbacks, Nonblocking I/O and Callbacks, Lambda Functions Are Powerful, Closures, Array Iteration Operations, Testing JavaScript Applications, A Simple Example, Adding and Updating Records, Retrieving Data, Uploading Files, A Pattern for Reuse of Multithread Processing, Web Socket Example alternatives to for loops, Array Iteration Operations button, A Simple Example closures to construct, Closures cursor, Adding and Updating Records on DOM elements, Testing JavaScript Applications from ports, Web Socket Example and Web Workers, A Pattern for Reuse of Multithread Processing write, Retrieving Data XHMLHttpRequest, Uploading Files Canvas, Graphics, Web Worker Fractal Example <canvas> tag, Graphics changes, storing, Storing Changes for a Later Server Sync chat applications, Web Sockets checksum, manifest, Updates to the Manifest File Chrome, Google, JavaScript’s Triumph, Closures, Closures, The localStorage and sessionStorage Objects, The localStorage and sessionStorage Objects, IndexedDB, Blobs, Filesystem, Events, Events, Testing and Debugging Web Workers, Testing and Debugging Web Workers, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing, Web Sockets, Tags for Applications, JavaScript Tools You Should Know BlobBuilder support, Blobs debugging web workers in, Testing and Debugging Web Workers Dev tools, Closures, The localStorage and sessionStorage Objects, Testing and Debugging Web Workers filesystem access, Filesystem IndexedDB in, IndexedDB list of closed variables, Closures manifest list, Events postMessage() in, A Pattern for Reuse of Multithread Processing <progress> tag support, Tags for Applications Speed Tracer, JavaScript Tools You Should Know storage viewer, The localStorage and sessionStorage Objects, Events web socket support, Web Sockets web worker support in, A Pattern for Reuse of Multithread Processing Church, Alonzo, Lambda Functions Are Powerful click command (Selenium), Selenium Commands client-side data storage, Local Storage Clojure, Web Socket Example ClojureScript, JavaScript Tools You Should Know close() method, The Worker Environment, The Web Sockets Interface closures, Nonblocking I/O and Callbacks, Closures, Closures, Array Iteration Operations, IndexedDB cloud test farms, Automatically Running Tests CoffeeScript, JavaScript Tools You Should Know color form input, New Form Types composite functions, Functional Programming config files, web server, Introduction to the Manifest File confirm() method, Nonblocking I/O and Callbacks content delivery network, Taking It Offline controls attribute, Audio and Video cookies, The localStorage and sessionStorage Objects, Using localStorage in ExtJS, Web Sockets CouchDB, IndexedDB Cranley, Ronan, JavaScript’s Triumph createObjectURL() method, Blobs Crockford, Douglas, JavaScript’s Triumph, The Power of JavaScript, JavaScript Tools You Should Know cross-platform web development, Developing Web Applications CruiseControl, Selenese Command Programming Interface currying, Currying and Object Parameters D data record example, IndexedDB data storage, Adding Power to Web Applications, Local Storage, jStore data trees, You Can Extend Objects, Too databases, Adding Power to Web Applications, Local Storage, IndexedDB, Deleting Data, IndexedDB, Adding and Updating Records, Retrieving Data, Deleting Data adding and updating records, Adding and Updating Records deleting data from, Deleting Data IndexedDB, Adding Power to Web Applications, IndexedDB, Deleting Data retrieving data from, Retrieving Data SQLite, Local Storage DataStore object (Ajax), Nonblocking I/O and Callbacks date form input, New Form Types dblclick command (Selenium), Selenium Commands debugging, JavaScript’s Triumph, Lambda Functions Are Powerful, Debugging Manifest Files, Splitting Up Work Through Web Workers, Testing and Debugging Web Workers, JavaScript Tools You Should Know Firebug, JavaScript’s Triumph, Lambda Functions Are Powerful and JSMin, JavaScript Tools You Should Know manifest files, Debugging Manifest Files and Web Workers, Splitting Up Work Through Web Workers, Testing and Debugging Web Workers \$.decode() method (Hive API), Libraries for Web Workers decoratedFib(), Expanding Functions with Prototypes deepEqual() method, Testing with QUnit defer() method, Offline Loading with a Data Store degradation, handling, Testing JavaScript Applications deleteEach() method, Deleting Data doConditionalLoad() method, Offline Loading with a Data Store DOM (Document Object Model), The Web As Application Platform, Developing Web Applications, Testing JavaScript Applications downloading events, Events Drag and Drop widget, JavaScript Tools You Should Know drag-and-drop, Selenium Commands, Files, Drag-and-Drop Dragonfly, Opera, JavaScript’s Triumph, A Pattern for Reuse of Multithread Processing drop event (DOM), Drag-and-Drop drop handler example, Working with Files drop zone example, Putting It All Together DSt library, DSt E Eclipse, JavaScript Tools You Should Know ECMAScript objects, The Worker Environment Emacs JS2 mode, JavaScript Tools You Should Know email form input, New Form Types enclosing scope, Lambda Functions Are Powerful \$.encode() method (Hive API), Libraries for Web Workers engines available in JQuery, jStore equal() method, A Simple Example, Testing with QUnit Erlang Yaws, Web Socket Example, Erlang Yaws errors, Retrieving Data, Events, Testing and Debugging Web Workers, Geolocation ETags, Offline Loading with a Data Store event loops, Splitting Up Work Through Web Workers, JavaScript Tools You Should Know Event Machine, Ruby, Ruby Event Machine Events specs, Microdata every() method, Array Iteration Operations expanding functions with prototypes, Expanding Functions with Prototypes, Expanding Functions with Prototypes extending base types, Prototypes and How to Expand Objects ExtJS, JavaScript’s Triumph, Lambda Functions Are Powerful, Currying and Object Parameters, Selenium Commands, Using localStorage in ExtJS button with function as handler, Lambda Functions Are Powerful click event problems, Selenium Commands currying parameters in, Currying and Object Parameters library, JavaScript’s Triumph localStorage object in, Using localStorage in ExtJS F FALLBACK section, manifest, Structure of the Manifest File feature detection, A Pattern for Reuse of Multithread Processing Fibonacci sequences, calculating, Expanding Functions with Prototypes FileReader API, Working with Files files, Adding Power to Web Applications, Files, Filesystem, Debugging Manifest Files FileSystem API, Filesystem filter() method, Array Iteration Operations, You Can Extend Objects, Too Firebug, JavaScript’s Triumph, Lambda Functions Are Powerful, Closures, The localStorage and sessionStorage Objects, Working with Files, Splitting Up Work Through Web Workers, Testing and Debugging Web Workers, Testing and Debugging Web Workers, JavaScript Tools You Should Know anonymous functions, Lambda Functions Are Powerful colorizing in script tag, JavaScript Tools You Should Know debugging web workers in, Testing and Debugging Web Workers developer tools, Testing and Debugging Web Workers editing storage object, The localStorage and sessionStorage Objects full path file names, Working with Files scope chain, Closures and Web Workers, Splitting Up Work Through Web Workers Firefox, Mozilla, Prototypes and How to Expand Objects, Array Iteration Operations, Array Iteration Operations, Selenium, Constructing Tests with the Selenium IDE, The localStorage and sessionStorage Objects, IndexedDB, Blobs, Debugging Manifest Files, Debugging Manifest Files, Worker Communication, Testing and Debugging Web Workers, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing, Web Sockets, Tags for Applications developers’ site, Prototypes and How to Expand Objects, Array Iteration Operations IndexedDB in, IndexedDB iteration methods in, Array Iteration Operations manifest file opt-in issue, Debugging Manifest Files MozBlobBuilder, Blobs MozWebSockets, Web Sockets passing complex JavaScript objects, Worker Communication postMessage() in, A Pattern for Reuse of Multithread Processing <progress> tag support, Tags for Applications Selenium IDE for, Selenium, Constructing Tests with the Selenium IDE, Debugging Manifest Files storage objects in, The localStorage and sessionStorage Objects web workers in, Testing and Debugging Web Workers, A Pattern for Reuse of Multithread Processing FireRainbow, JavaScript Tools You Should Know first class citizens, Lambda Functions Are Powerful, Functional Programming :first-child() CSS selector, New CSS Flanagan, David, The Power of JavaScript flow control, Selenium Commands for loops, alternatives to, Array Iteration Operations forks, Adding Power to Web Applications FormData interface, Uploading Files fractal computation examples, Web Worker Fractal Example, Web Worker Fractal Example Fulton, Jeff, Graphics, Canvas and SVG Fulton, Steve, Graphics, Canvas and SVG function expressions, Lambda Functions Are Powerful function generators, Closures function interceptor example, Expanding Functions with Prototypes Function prototype, Expanding Functions with Prototypes function statements, Lambda Functions Are Powerful functional programming, Functional Programming, Functional Programming, JavaScript Tools You Should Know functions, Lambda Functions Are Powerful, Lambda Functions Are Powerful, Closures, Functional Programming, Functional Programming anonymous, Lambda Functions Are Powerful as first class citizens, Lambda Functions Are Powerful, Functional Programming higher order, Functional Programming inner and outer, Closures functions, expanding with prototypes, Expanding Functions with Prototypes, Expanding Functions with Prototypes G Garret, Jesse James, Functional Programming Gears, Google, Developing Web Applications, Local Storage, Introduction to the Manifest File, Splitting Up Work Through Web Workers offline file access, Introduction to the Manifest File SQLite database, Local Storage worker pool, Splitting Up Work Through Web Workers geolocation, Maps, Geolocation \$.get() method (Hive API), Libraries for Web Workers getBlob() method (BlobBuilder), Blobs getCurrentPosition() method, Geolocation getEval() method (Selenese API), Selenese Command Programming Interface getText() method (Selenese API), Selenese Command Programming Interface getXpathCount() method (Selenese API), Selenese Command Programming Interface Gmail, Google’s, Files, Web Sockets Goerzen, John, Functional Programming Google Chrome, Tags for Applications (see Chrome, Google) Google Gears, Developing Web Applications (see Gears, Google) Google search predefined vocabularies, Microdata Google Web Toolkit, JavaScript’s Triumph grid object (ExtJS), Using localStorage in ExtJS H handleButtonClick() function, A Simple Example Haskell, Currying and Object Parameters Head First jQuery (Benedetti & Cranley), JavaScript’s Triumph Hello World testing example, Selenese Command Programming Interface Hickey, Rich, JavaScript Tools You Should Know High Performance JavaScript (Zakas), The Power of JavaScript High Performance Web Sites (Souders), JavaScript Tools You Should Know higher order functions, Functional Programming hoisting, Lambda Functions Are Powerful <hr> tag, Accessibility Through WAI-ARIA, Accessibility Through WAI-ARIA, Accessibility Through WAI-ARIA HTML 5, Putting It All Together, Introduction to the Manifest File, Graphics, Web Worker Fractal Example, New Tags, New CSS, New Form Types, Canvas and SVG, New CSS Canvas, Graphics, Web Worker Fractal Example, Canvas and SVG manifest declaration example, Introduction to the Manifest File new CSS features, New CSS new form types, New Form Types new tags, New Tags, New CSS progress bar, Putting It All Together HTML5 Canvas (Fulton & Fulton), Graphics, Canvas and SVG HTML5 Graphics with SVG & CSS3 (Cagle), Canvas and SVG HTML5 Media (Powers), Audio and Video HTML5 Rocks tutorial, Canvas and SVG HTTP (Hypertext Transfer Protocol), Adding Power to Web Applications, Web Sockets, Erlang Yaws I I/O, Nonblocking I/O and Callbacks IDs, importance of assigning, Selenium if statement, Lambda Functions Are Powerful images, Functional Programming, Blobs, Working with Files, Drag-and-Drop, Filesystem, Filesystem, Debugging Manifest Files, Graphics, Graphics, Graphics, Web Worker Fractal Example, Canvas and SVG appending to documents, Working with Files and Canvas, Graphics editing, Filesystem, Graphics missing, Debugging Manifest Files progressive drawing, Web Worker Fractal Example scaling example, Functional Programming streaming video, Filesystem SVG, Canvas and SVG use of src attribute, Blobs, Graphics user access to, Drag-and-Drop <img> tag, Graphics, Accessibility Through WAI-ARIA importScripts() method, The Worker Environment independent event loops, Splitting Up Work Through Web Workers index() method, Adding Indexes IndexedDB, Adding Power to Web Applications, IndexedDB, Deleting Data indexes, adding/removing, Adding Indexes indexOf() method, Prototypes and How to Expand Objects info() method, Web Worker Fractal Example inner functions, Closures integration testing, Testing JavaScript Applications, Selenium interceptor methods, Expanding Functions with Prototypes Internet Explorer (IE), Microsoft, Array Iteration Operations, IndexedDB, A Pattern for Reuse of Multithread Processing iOS Selenium, testing applications for, Selenium RC and a Test Farm iPad/iPod/iPhone platform, Selenium RC and a Test Farm, A Pattern for Reuse of Multithread Processing isDuplicate() method, Deleting Data isElementPresent() method (Selenese API), Selenese Command Programming Interface isTextPresent() method (Selenese API), Selenese Command Programming Interface itemprop attribute, Microdata itemscope attribute, Microdata itemtype attribute, Microdata J JavaScript, JavaScript’s Triumph, JavaScript’s Triumph, Nonblocking I/O and Callbacks, Lambda Functions Are Powerful, Lambda Functions Are Powerful, Closures, Functional Programming, Functional Programming, Prototypes and How to Expand Objects, Prototypes and How to Expand Objects, Prototypes and How to Expand Objects, Expanding Functions with Prototypes, Prototypes and How to Expand Objects, Expanding Functions with Prototypes, Expanding Functions with Prototypes, Currying and Object Parameters, Array Iteration Operations, You Can Extend Objects, Too, You Can Extend Objects, Too, Testing JavaScript Applications, Splitting Up Work Through Web Workers, Worker Communication, JavaScript Tools You Should Know, JavaScript Tools You Should Know, JavaScript Tools You Should Know array iteration operations, Array Iteration Operations, You Can Extend Objects, Too closures, Closures currying and object parameters, Currying and Object Parameters expanding functions, Expanding Functions with Prototypes, Expanding Functions with Prototypes expanding objects, Prototypes and How to Expand Objects, Prototypes and How to Expand Objects extending objects, You Can Extend Objects, Too function statement and function expression, Lambda Functions Are Powerful functional programming in, Functional Programming, Functional Programming functions act as data in, Lambda Functions Are Powerful helpful tools for, JavaScript Tools You Should Know, JavaScript Tools You Should Know libraries, JavaScript’s Triumph nonblocking I/O and callbacks, Nonblocking I/O and Callbacks passing objects in Firefox, Worker Communication primitives in, Prototypes and How to Expand Objects prototypes, Prototypes and How to Expand Objects, Expanding Functions with Prototypes recent improvements in, JavaScript’s Triumph runtime event loop, Splitting Up Work Through Web Workers runtime model, Testing JavaScript Applications syntax checker, JavaScript Tools You Should Know JavaScript Patterns (Stefanov), The Power of JavaScript JavaScript: The Definitive Guide (Flanagan), The Power of JavaScript JavaScript: The Good Parts (Crockford), JavaScript’s Triumph, The Power of JavaScript, JavaScript Tools You Should Know jQuery, JavaScript’s Triumph, Functional Programming, DSt, jStore, IndexedDB, IndexedDB, Libraries for Web Workers DSt plug-in, DSt Hive extension, Libraries for Web Workers IndexedDB plug-in, IndexedDB, IndexedDB jStore plug-in, jStore library, JavaScript’s Triumph, Functional Programming jQuery Cookbook (Lindley), JavaScript’s Triumph JS2 mode, Emacs, JavaScript Tools You Should Know JSBeautifier, JavaScript Tools You Should Know JSLint, The Power of JavaScript, JavaScript Tools You Should Know JSMin, JavaScript Tools You Should Know JSON manifest file, Introduction to the Manifest File JsonStore object, Offline Loading with a Data Store jStore plug-in, jStore L Lambda Calculus, Lambda Functions Are Powerful lambda functions, Lambda Functions Are Powerful lastIndexOf(), Prototypes and How to Expand Objects libraries, JavaScript’s Triumph, Libraries for Web Workers Lindley, Cody, JavaScript’s Triumph Lisp lambdas, Lambda Functions Are Powerful list recursion, Functional Programming list test examples, Testing JavaScript Applications load() method (JSON), Offline Loading with a Data Store local data storage, Adding Power to Web Applications, Local Storage, jStore local state provider, ExtJS, Using localStorage in ExtJS localStorage object, The localStorage and sessionStorage Objects, Using localStorage in ExtJS, Storing Changes for a Later Server Sync location object, The Worker Environment loops, Array Iteration Operations, Selenium Commands, Splitting Up Work Through Web Workers, Splitting Up Work Through Web Workers, A Pattern for Reuse of Multithread Processing for, Array Iteration Operations independent event, Splitting Up Work Through Web Workers runtime event, Splitting Up Work Through Web Workers and Selenium, Selenium Commands while, A Pattern for Reuse of Multithread Processing M macros, recording web, Selenium Mandelbrot computation examples, Web Worker Fractal Example, Web Worker Fractal Example manifest file, Adding Power to Web Applications, Introduction to the Manifest File, Debugging Manifest Files map() method, Array Iteration Operations, You Can Extend Objects, Too match() method, Prototypes and How to Expand Objects McCarthy, John, Lambda Functions Are Powerful MD5 checksum, Updates to the Manifest File memory leaks, Selenium Commands <meter> tag, Tags for Applications microdata, Microdata Microsoft Internet Explorer, Array Iteration Operations, IndexedDB, A Pattern for Reuse of Multithread Processing minification, JavaScript Tools You Should Know MongoDB, IndexedDB mouseDown command (Selenium), Selenium Commands mouseOver command (Selenium), Selenium Commands mouseUp command (Selenium), Selenium Commands MozBlobBuilder, Blobs Mozilla Firefox, Prototypes and How to Expand Objects (see Firefox, Mozilla) mozSlice() method (Firefox), Blobs MozWebSockets, Web Sockets N name/value pairs, Currying and Object Parameters navigator object, The Worker Environment .NET/CLR, Web Socket Example NETWORK section, manifest, Structure of the Manifest File node trees, You Can Extend Objects, Too Node.js, Web Sockets, Web Socket Example, JavaScript Tools You Should Know nonblocking I/O, Nonblocking I/O and Callbacks :not() CSS selector, New CSS notDeepEqual() method, Testing with QUnit notEqual() method, Testing with QUnit notStrictEqual() method, Testing with QUnit noupdate events, Events :nth-child() CSS selector, New CSS number form input, New Form Types numbers, Lambda Functions Are Powerful, Prototypes and How to Expand Objects, Prototypes and How to Expand Objects, Expanding Functions with Prototypes, Expanding Functions with Prototypes, Expanding Functions with Prototypes, Array Iteration Operations cubing example, Expanding Functions with Prototypes Fibonacci calculation examples, Expanding Functions with Prototypes, Expanding Functions with Prototypes as objects, Prototypes and How to Expand Objects squaring examples, Lambda Functions Are Powerful, Prototypes and How to Expand Objects, Array Iteration Operations O object parameters, Currying and Object Parameters object stores, IndexedDB, IndexedDB, Retrieving Data objects, extending, You Can Extend Objects, Too Offer-Aggregates specs, Microdata Offers specs, Microdata offline use, Local Storage, Offline Loading with a Data Store, Offline Loading with a Data Store, Storing Changes for a Later Server Sync, Introduction to the Manifest File, Debugging Manifest Files data access, Local Storage loading with data store, Offline Loading with a Data Store, Offline Loading with a Data Store manifest file, Introduction to the Manifest File, Debugging Manifest Files storing changes, Storing Changes for a Later Server Sync ok() method, Testing with QUnit onclose() method, The Web Sockets Interface onmessage() method, Using Web Workers, Web Worker Fractal Example, A Pattern for Reuse of Multithread Processing onopen() method, The Web Sockets Interface open command (Selenium), Selenium Commands Opera Dragonfly, JavaScript’s Triumph, A Pattern for Reuse of Multithread Processing Organizations specs, Microdata outer functions, Closures O’Reilly Answers website, The Power of JavaScript O’Sullivan, Bryan, Functional Programming P parameter blocks, Currying and Object Parameters path() method, You Can Extend Objects, Too pattern for reuse of multithread processing, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing Payne, Alex, Functional Programming People specs, Microdata persistent local storage, Local Storage PhoneGap, Developing Web Applications PHP, Lambda Functions Are Powerful phpUnderControl, Selenese Command Programming Interface PHPUnit testing framework, Automatically Running Tests, Selenese Command Programming Interface pixel, drawing a, Web Worker Fractal Example PollenJS library, Libraries for Web Workers populate_form() method (DSt), DSt populating (example), Prototypes and How to Expand Objects port 443 (wss), Setting Up a Web Socket port 80 (ws), Setting Up a Web Socket port 8080, Web Socket Example \$.post() method (Hive API), Libraries for Web Workers postMessage() method, Using Web Workers, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing Powers, Shelley, Audio and Video PreloadStore object (JSON), Offline Loading with a Data Store pretty printer example, JavaScript Tools You Should Know primitives in JavaScript, Prototypes and How to Expand Objects Products specs, Microdata Programming Scala (Wampler & Payne), Functional Programming progress events, Events progress indicator examples, Putting It All Together, Tags for Applications <progress> tag, Tags for Applications prompt() method, Nonblocking I/O and Callbacks prototype object, Prototypes and How to Expand Objects prototypes, expanding functions with, Expanding Functions with Prototypes, Expanding Functions with Prototypes Q query access, IndexedDB QUnit, Testing JavaScript Applications, QUnit, Testing with QUnit, Running QUnit from Selenium R race conditions, IndexedDB, Splitting Up Work Through Web Workers raises() method, Testing with QUnit rar files, Drag-and-Drop RC server, Selenium, Selenium readAsArrayBuffer() method (FileReader), Working with Files readAsBinaryString() method (FileReader), Working with Files readAsText() method (FileReader), Working with Files readDataAsURL() method (FileReader), Working with Files Real World Haskell (Goerzen & Stewart), Functional Programming recall() method (DSt), DSt reduce(), reduceRight() methods, Array Iteration Operations refresh command (Selenium), Selenium Commands remove() method, Deleting Data replace() method, Prototypes and How to Expand Objects required attribute (forms), New Form Types Resig, John, JavaScript’s Triumph reuse of multithread processing, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing Review-Aggregates specs, Microdata Reviews specs, Microdata revokeBlobURL() method, Blobs Rhino, JavaScript Tools You Should Know role attribute, Accessibility Through WAI-ARIA route finder, Maps Ruby, Web Socket Example Ruby Event Machine, Ruby Event Machine run function example, A Pattern for Reuse of Multithread Processing run() method, Web Worker Fractal Example running average example, Array Iteration Operations runtime model, JavaScript, Testing JavaScript Applications S Safari Nightly builds, Blobs Safari, Apple’s, JavaScript’s Triumph, A Pattern for Reuse of Multithread Processing, Libraries for Web Workers, Web Sockets same origin policy, The localStorage and sessionStorage Objects, IndexedDB sandboxed environment, Developing Web Applications, Filesystem save queue examples, Storing Changes for a Later Server Sync Scala, Web Socket Example Scalable Vector Graphics, Canvas and SVG scaling images, Functional Programming scope, Lambda Functions Are Powerful, Closures <script> tag, The Worker Environment search form input, New Form Types Selenese, Selenium Commands, Selenese Command Programming Interface, Selenese Command Programming Interface Selenium, Testing JavaScript Applications, Selenium, Selenium, Selenium, Selenium Commands, Selenium Commands, Selenium Commands, Constructing Tests with the Selenium IDE, Constructing Tests with the Selenium IDE, Automatically Running Tests, Automatically Running Tests, Selenese Command Programming Interface, Selenese Command Programming Interface, Running QUnit from Selenium, Drag-and-Drop automatically running tests, Automatically Running Tests, Automatically Running Tests commands, Selenium Commands, Selenium Commands constructing tests, Constructing Tests with the Selenium IDE example tests, Selenium IDE, Selenium, Constructing Tests with the Selenium IDE location options, Selenium Commands no drag-and-drop, Drag-and-Drop running QUnit from, Running QUnit from Selenium Selenese, Selenese Command Programming Interface, Selenese Command Programming Interface test table, Selenium Selenium Grid, Automatically Running Tests Selenium RC server, Selenium, Selenium RC and a Test Farm self object, The Worker Environment Sencha ExtJS library, JavaScript’s Triumph send(“data”) method, The Web Sockets Interface server delay, Developing Web Applications, Web Sockets server polling, Web Sockets server-side testing, Testing JavaScript Applications, Testing JavaScript Applications, Selenese Command Programming Interface sessionStorage object, The localStorage and sessionStorage Objects, Using localStorage in ExtJS setInterval() method, Expanding Functions with Prototypes, The Worker Environment setTimeout() method, Expanding Functions with Prototypes, Testing with QUnit, The Worker Environment, A Pattern for Reuse of Multithread Processing, A Pattern for Reuse of Multithread Processing setVersion transaction, Adding Indexes side effects, Functional Programming single-step mode, Selenium sleep() method, Selenese Command Programming Interface slice() method, Prototypes and How to Expand Objects, Blobs slider, form, New Form Types smartphones, Developing Web Applications some() method, Array Iteration Operations Souders, Steve, JavaScript Tools You Should Know speech input type, New Form Types Speed Tracer, JavaScript Tools You Should Know speed, data storage and, Local Storage split() method, Prototypes and How to Expand Objects SQL Injection attacks, IndexedDB SQLite versus IndexedDB, IndexedDB squaring numbers example, Prototypes and How to Expand Objects src attribute, Audio and Video StackOverflow website, The Power of JavaScript startWorker() method, Web Worker Fractal Example static data storage, Local Storage Stefanov, Stoyan, The Power of JavaScript step through, Selenium, Testing and Debugging Web Workers Stewart, Donald Bruce, Functional Programming stock price examples, Web Socket Example, Ruby Event Machine stop() method, A Pattern for Reuse of Multithread Processing storage events, The localStorage and sessionStorage Objects storage viewer widget, The localStorage and sessionStorage Objects \$.storage() method (Hive API), Libraries for Web Workers store() method (DSt), DSt store_form() method (DSt), DSt strictEqual() method, Testing with QUnit string token replacement, Prototypes and How to Expand Objects strings, methods for, Prototypes and How to Expand Objects Structure and Interpretation of Computer Programs (Abelson & Sussman), Functional Programming structured data, query access to, IndexedDB subclassing, Currying and Object Parameters Sussman, Gerald Jay, Functional Programming SVG, Canvas and SVG <svg> tag, Graphics Symfony Yaml Library, Updates to the Manifest File T tar files, Drag-and-Drop TCP socket, Web Socket Protocol TCP/IP sockets, Web Sockets tel form input, New Form Types test machines, Automatically Running Tests test suites, Testing JavaScript Applications, QUnit, Testing with QUnit, Selenium, Selenium RC and a Test Farm, Selenium, Selenium, Running QUnit from Selenium programming language based, Selenium QUnit, QUnit, Testing with QUnit, Selenium, Running QUnit from Selenium Selenium, Selenium, Selenium RC and a Test Farm server-side, Testing JavaScript Applications Test-driven development, Testing JavaScript Applications, Testing JavaScript Applications thread safety, Splitting Up Work Through Web Workers threads, Adding Power to Web Applications time form input, New Form Types title attribute, Accessibility Through WAI-ARIA transaction object, database, IndexedDB transaction.abort() method (jQuery), IndexedDB transaction.done() method (jQuery), IndexedDB True Type font files, New CSS type command (Selenium), Selenium Commands U undefined value, Functional Programming unit testing, Testing JavaScript Applications update() method (IndexedDB), Adding and Updating Records updateEach() method (IndexedDB), Adding and Updating Records uploading files, Uploading Files URLs, QUnit, Blobs, Working with Files, Structure of the Manifest File, Events, Events, Debugging Manifest Files, The Web Sockets Interface adding ?

List recursion function iterateAjax(tasks) { function iterator(tasks) { \$.ajax({ url: 'index.php', data: tasks[0], success: function(data, status, XMLHttpRequest) { if (tasks.length > 0) { // Do something with the results here iterator(tasks.slice(1)); } } }); } iterator(tasks); } Although building an entire single-page web application with only functional programming styles would not be practical, functional programming still provides many useful ideas that should not be ignored. Functional programming is very well suited, for instance, for use with Web Workers (see Chapter 8). Not a lot has been written about functional programming in JavaScript, but there is quite a lot in other languages that can be applied to JavaScript. For more on functional programming, see these books: Real World Haskell by Bryan O’Sullivan, John Goerzen, and Donald Bruce Stewart (O’Reilly) Programming Scala by Dean Wampler and Alex Payne (O’Reilly) Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman (MIT Press) Prototypes and How to Expand Objects Everything in JavaScript can have methods attached to it.

In this case, it shows that we have clicked on the “delete” button and lists the reference to the jQuery object for the button itself. Figure 2-1. Closures in Google Chrome’s DevTools Functional Programming Functional programming is a methodology that is more commonly associated with languages like Lisp, Scala, Erlang, F#, or Haskell, but works quite well in JavaScript also. Functional programming rests on a couple basic assumptions: Functions are first-class citizens of the language and can be used where any other value can be used. Complex behavior can be built by composition of simple functions.

pages: 303 words: 57,177

Hands-On Functional Programming in RUST by Andrew Johnson

For more information about Packt, please visit packtpub.com. Functional Programming – a Comparison Functional programming (FP) is the second most popular programming paradigm, behind only object-oriented programming (OOP). For many years, these two paradigms have been separated into different languages, so as not to be mixed. Multi-paradigm languages have attempted to support both approaches. Rust is one such language. As a broad definition, functional programming emphasizes the use of composable and maximally reusable functions to define program behavior. Using these techniques, we will show how functional programming has adapted clever solutions to many common yet difficult problems.

Hands-On Functional Programming in Rust Build modular and reactive applications with functional programming techniques in Rust 2018 Andrew Johnson BIRMINGHAM - MUMBAI Hands-On Functional Programming in Rust Copyright © 2018 Packt Publishing All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews. Every effort has been made in the preparation of this book to ensure the accuracy of the information presented.

Using typesafe interfaces instead of stringly typed interfaces Using the heartbeat pattern for long running processes Validating input and output Finding and fixing bugs Metaprogramming Summary Questions Assessments Functional Programming&#xA0;&#x2013; a Comparison Functional Control Flow Functional Data Structures Generics and Polymorphism Code Organization and Application Architecture Mutability, Ownership, and Pure Functions Design Patterns Implementing Concurrency Performance, Debugging, and Metaprogramming Other Books You May Enjoy Leave a review - let other readers know what you think Preface Thanks for your interest in functional programming in Rust. Rust is a very young programming language and is particularly new to the functional programming community. Despite its age, the language provides a wealth of tools that are both practical and sophisticated.

pages: 448 words: 71,301

Programming Scala by Unknown

Package Objects Sealed Class Hierarchies The Scala Type Hierarchy Linearization of an Object’s Hierarchy Recap and What’s Next 145 148 150 151 155 159 164 8. Functional Programming in Scala . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 What Is Functional Programming? Functions in Mathematics Variables that Aren’t Functional Programming in Scala Function Literals and Closures Purity Inside Versus Outside Recursion Tail Calls and Tail-Call Optimization Trampoline for Tail Calls Functional Data Structures Lists in Functional Programming Maps in Functional Programming Sets in Functional Programming Other Data Structures in Functional Programming Traversing, Mapping, Filtering, Folding, and Reducing Traversal Mapping Filtering Folding and Reducing Functional Options Pattern Matching Partial Functions Currying Implicits Implicit Conversions Implicit Function Parameters Final Thoughts on Implicits Call by Name, Call by Value Lazy Vals Recap: Functional Component Abstractions x | Table of Contents Download at WoweBook.Com 165 166 166 167 169 169 170 171 172 172 173 173 174 174 174 175 175 178 179 181 182 183 184 186 186 188 189 189 190 192 9.

Long the topic of computer science research and even older than object-oriented programming, functional programming offers effective techniques for concurrent programming, which is growing in importance. Because functional programming is less widely understood than object-oriented programming, we won’t assume that you have prior experience with it. We’ll start this chapter with plenty of background information. As you’ll see, functional programming is not only a very effective way to approach concurrent programming, which we’ll explore in depth in Chapter 9, but functional programming can also improve your objects. Of course, we can’t provide an exhaustive introduction to functional programming.

Of course, we can’t provide an exhaustive introduction to functional programming. To learn more about it, [O’Sullivan2009] has a more detailed introduction in the context of the Haskell language. [Abelson1996], [VanRoy2004], and [Turbak2008] offer thorough introductions to general programming approaches, including functional programming. Finally, [Okasaki1998] and [Rabhi1999] discuss functional data structures and algorithms in detail. What Is Functional Programming? Don’t all programming languages have functions of some sort? Whether they are called methods, procedures, or GOTOs, programmers are always dealing in functions. 165 Download at WoweBook.Com Functional programming is based on the behavior of functions in the mathematical sense, with all the implications that starting point implies.

Practical OCaml by Joshua B. Smith

That day might not belong to functional programming languages, but it is likely that functional programming will continue to affect the programming world. It will most certainly affect the programmers of the world, which is more important, anyway. Chapter 20 discusses functional programming in particular. You have seen that OCaml is not purely functional; in the next chapter you will see that OCaml is quite functional. 620Xch20final.qxd 9/22/06 12:18 AM CHAPTER Page 261 20 ■■■ Digression: Functional Programming A t various points in this book, I noted that OCaml is a functional programming language. Chapter 19 told you that OCaml is not a purely functional programming language and what that lack of purity is about.

This is even truer for highly concurrent programs that might be impossible for a human being to adequately understand in any way. Conclusion Although functional programming is not the only style of programming that can solve problems, it does have specific merits. Functional programs can be shorter than OOP programs and easier to understand. They also make writing defect-free programs easier because the code is shorter and the components are modular. Functional programming encourages a bottom-up design that can be flexible and enables you to create programs that can adapt to changing requirements and environments. Functional programming is not the only style of programming available, but because this book is about a functional programming language, it is biased toward functional programming solutions.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 Purely Functional Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 Languages Like OCaml. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 xv 620Xfmfinal.qxd xvi 9/22/06 4:21 PM Page xvi ■CONTENTS Languages Like Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 Benefits of Impurity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254 Hiding the Impure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254 Preventing Information Leaks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 ■CHAPTER 20 Digression: Functional Programming . . . . . . . . . . . . . . . . . . . . . 261 Overview of Programming Styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Structured Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Object-Oriented Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Functional Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 Advantages of Functional Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 Less Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Fewer Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 Programming in the Large . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 Correctness of Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Concurrency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Reasoning About Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 ■CHAPTER 21 Practical: Web Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 What Does Web Programming Mean?

pages: 496 words: 174,084

Masterminds of Programming: Conversations With the Creators of Major Programming Languages by Federico Biancuzzi, Shane Warden

Symbols 169-176 breakthroughs needed in, Waiting for a Breakthrough, Waiting for a Breakthrough by mathematicians, Waiting for a Breakthrough, Experience clean design, Programming by Example compared to library design, Language and Design debugging considerations for, Theory and Practice designer’s preferences influencing, Theory and Practice environment influencing, Language and Design errors reduced by, Theory and Practice for handheld devices, Power or Simplicity for system programming, Power or Simplicity formalisms for mathematical, Language Design usefulness of, Unix and Its Culture implementation affecting, Language Design implementation considerations for, Designing a New Language, Theory and Practice implementation related to, Language and Design improvements to process of, Designing a New Language, Designing a New Language influencing program design, Language Design inspiration for, Creativity, Refinement, and Patterns personal approach for, Elementary Principles prototypes for, Designing a New Language scientific approach for, Designing a New Language, Theory and Practice, Growing a Language starting with small core set of functionality, Growing a Language, Proofreading Languages syntax choices for, Theory and Practice teams for democratic nature of, Feedback Loop user considerations, Language Design utility considerations, Language Design A A Note on Pattern Matching: Where do you find the match to an empty array (Falkoff), Elementary Principles A Programming Language (Iverson), Paper and Pencil abstraction in functional programming, A Functional Team in SQL, Feedback and Evolution agents, Beyond Informatics Aho, AWK Aho-Corasick algorithm, Computer Science automata theory, Computer Science command-line tools, Unix and Its Culture compilers course taught by, The Role of Documentation–The Role of Documentation, The Role of Documentation, The Role of Documentation, The Role of Documentation data size handled by AWK, The Life of Algorithms debugging, Language Design, The Role of Documentation documentation leading to better software design, The Role of Documentation–The Role of Documentation, The Role of Documentation, The Role of Documentation domain, Unix and Its Culture file concept applied to Internet, Unix and Its Culture formalizing semantics of languages, Unix and Its Culture graphical interfaces, Unix and Its Culture hardware availability, The Life of Algorithms hardware efficiency, Unix and Its Culture improving programming skills, Language Design knowledge required to use AWK, Language Design large programs, The Life of Algorithms lex, Language Design portability of Unix, Unix and Its Culture programming, The Role of Documentation programming language design, Language Design programming languages, Unix and Its Culture purposes appropriate for use of AWK, The Life of Algorithms, Unix and Its Culture research in computer science, Computer Science role in AWK development, The Life of Algorithms security and degree of formalism, Unix and Its Culture teaching programming, Language Design theory and practice as motivation, Unix and Its Culture utility of programming language, Language Design yacc, Language Design Aho-Corasick algorithm, Computer Science algebraic language, The Goals Behind BASIC allocated memory, Compiler Design API design, Expedients and Experience, Feedback Loop, C# APL, APL character set for, Paper and Pencil, Elementary Principles collections in, Parallelism design, Elementary Principles design history of, Paper and Pencil, Elementary Principles general arrays in, Elementary Principles implementation on handheld devices, Paper and Pencil learning, Paper and Pencil lessons learned from design of, Legacy namespaces, Parallelism parallelism with, Parallelism–Legacy, Parallelism, Parallelism, Legacy, Legacy regrets about, Legacy resources used efficiently by, Paper and Pencil standardization of, Elementary Principles syntax for based on algebraic notation, Paper and Pencil, Elementary Principles simplicity/complexity of, Paper and Pencil, Elementary Principles, Elementary Principles teaching programming with, Elementary Principles APL\360, Paper and Pencil arbitrary precision integers, The Pythonic Way architects, Be Ready for Change aspect orientation, Learning and Teaching Aspect-Oriented Software Development with Use Cases (Jacobson; Ng), Learning and Teaching asymmetrical coroutines, The Power of Scripting asynchronous operation, Hardware audio applications, Language Design automata theory, Computer Science automatic code checking, Designing a Language AWK, AWK, The Life of Algorithms compared to SQL, Bits That Change the Universe initial design ideas for, Bits That Change the Universe large programs good practices for, The Life of Algorithms improvements for, Theory and Practice longevity of, Theory and Practice programming advice for, Designing a New Language programming by example, Programming by Example–Programming by Example, Programming by Example, Programming by Example, Programming by Example, Programming by Example, Programming by Example regrets about, Bits That Change the Universe AWT, Power or Simplicity B backward compatibility, Formalism and Evolution for potentially redesigned UML, Layers and Languages with Java, Power or Simplicity with JVM, Language and Design with UML, Language Design BASIC, BASIC comments, Language and Programming Practice compiler one pass for, The Goals Behind BASIC, The Goals Behind BASIC two passes for, The Goals Behind BASIC design of considerations for, The Goals Behind BASIC, The Goals Behind BASIC holding up over time, Language Design encapsulation, The Goals Behind BASIC hardware evolution influencing, The Goals Behind BASIC large programs, The Goals Behind BASIC lessons learned from design of, Language Design libraries, Language Design number handling, The Goals Behind BASIC, The Goals Behind BASIC performance of, The Goals Behind BASIC teaching programming using, The Goals Behind BASIC True BASIC, The Goals Behind BASIC variable declarations not required in, Compiler Design bitmap fonts, Designed to Last Booch, UML backward compatibility with UML, Language Design benefits of UML, UML body of literature for programming, Training Developers business rules, Creativity, Refinement, and Patterns complexity and OOP, Creativity, Refinement, and Patterns complexity of UML, UML concurrency, Creativity, Refinement, and Patterns constraints contributing to innovation, Creativity, Refinement, and Patterns creativity and pragmatism, Language Design design of UML, UML implementation code, UML language design, Creativity, Refinement, and Patterns language design compared to programming, Language Design language design influencing programs, Language Design legacy software, Creativity, Refinement, and Patterns OOP influencing correct design, Creativity, Refinement, and Patterns percentage of UML used all the time, UML, Language Design redesigning UML, UML simplicity, Creativity, Refinement, and Patterns standardization of UML, Language Design–Training Developers, Language Design, Language Design, Training Developers training programmers, Training Developers–Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns bottom-up design with Forth, The Forth Language and Language Design with Python, The Good Programmer Boyce, SQL, A Seminal Paper brown field development, Creativity, Refinement, and Patterns bugs in language design, The Theory of Meaning business rules, Creativity, Refinement, and Patterns C C as system programming language, Power or Simplicity longevity of, Legacy Culture Objective-C as extension of, Engineering Objective-C performance of, Power or Simplicity signedness in, Waiting for a Breakthrough size of code, Project Management and Legacy Software C#, C# as replacement for C++, Growing a Language debugging, C# design team for, C# evolution of, C# formal specifications for, C# Java as inspiration for, Designing a Language longevity of, Growing a Language user feedback for, Language and Design, C# C++ backward compatibility with C, Legacy Culture C# as replacement for, C# compared to Objective-C, Engineering Objective-C, Objective-C and Other Languages compatibility requirements of, The Pythonic Way complexity of, Engineering Objective-C concurrency support in, OOP and Concurrency evolution of, Growing a Language future versions of, Future lessons learned from design of, Future multithreading in, Designing a Language pointers in problems with, Designing a Language popularity of, Engineering Objective-C C++ 2.0, Future C++0x, OOP and Concurrency, Future Calculus of Communicating Systems (CCS), The Soundness of Theorems CCS (Calculus of Communicating Systems), The Soundness of Theorems Celes, Lua Chamberlin, SQL complexity of SQL, Feedback and Evolution concurrent data access in SQL, The Language declarative nature of SQL, The Language design history of SQL, A Seminal Paper–A Seminal Paper, A Seminal Paper, A Seminal Paper, A Seminal Paper design principles of SQL, The Language determinism, Feedback and Evolution Excel compared with relational database systems, Feedback and Evolution external visibility of, Feedback and Evolution injection attacks on SQL, Feedback and Evolution knowledge required to use SQL, Feedback and Evolution languages, A Seminal Paper popularity of SQL, Feedback and Evolution scalability of SQL, Feedback and Evolution standardization of SQL and XQuery, XQuery and XML usability tests on SQL, Feedback and Evolution user feedback on SQL, Feedback and Evolution users of SQL, Feedback and Evolution views in SQL, The Language XML, XQuery and XML XQuery, XQuery and XML character set, Paper and Pencil, Elementary Principles class system, The Haskell Language classes, Project Management and Legacy Software closure in Lua, The Power of Scripting in SQL, The Language Codd, SQL, A Seminal Paper code browsing, The Pythonic Way code examples in programming manuals, Breeding Little Languages code reuse, Compiler Design collections design implications of, Parallelism large unstructured, Parallelism operations on each element of, Elementary Principles color, Designed to Last colorForth, The Forth Language and Language Design command line AWK used with, Unix and Its Culture compared to graphical interface, Designing a New Language composing programs on, Unix and Its Culture limitations of, Bits That Change the Universe resurgence of, Legacy Culture tools for, Unix and Its Culture comments, Application Design, The Theory of Meaning in BASIC, Compiler Design in C#, C# role of, Experience communication among interactive agents, Beyond Informatics role in informatics, Beyond Informatics compilers quality of code in, Application Design writing, The Forth Language and Language Design, Compiler Design, The Role of Documentation completeness, The Language complex algorithms, The Life of Algorithms components, Objective-C and Other Languages, Objective-C and Other Languages, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon, Growing a Language computer science current problems in, The Future of Computer Science future of, Interfaces to Longevity problems of, Beyond Informatics, Components, Sand, and Bricks research in, Beyond Informatics role of mathematics in, Elementary Principles, Computer Science, Experience, Beyond Informatics whether it is a science, Experience, Quality As an Economic Phenomenon computer science education approaches for, Bits That Change the Universe, Spreading (Functional) Education beginning programming, The Pythonic Way, Elementary Principles, The Goals Behind BASIC, Compiler Design functional languages, Spreading (Functional) Education multiple languages, Language and Programming Practice, Breeding Little Languages teaching languages, The Goals Behind BASIC, The Goals Behind BASIC, Language and Design teamwork in, Unix and Its Culture–The Role of Documentation, The Role of Documentation, The Role of Documentation, The Role of Documentation topics needed in, Education and Training, Be Ready for Change concurrency, Creativity, Refinement, and Patterns adding to language, Language and Design analyzing concurrent systems, The Soundness of Theorems approaches for, Hardware challenges of, The Future of Computer Science, The Future of Computer Science design affected by, Concurrency framework handling, The Future of Computer Science functional languages and, A Bit of Reusability in C++, OOP and Concurrency in C++0x, OOP and Concurrency in Lua, The Power of Scripting in Python, Multiple Pythons in SQL, The Language language design affected by, The Future of Computer Science network distribution and, OOP and Concurrency OOP and, OOP and Concurrency, Objective-C and Other Languages, A Bit of Reusability pattern matching using, Computer Science requirements for, Concurrency conditionals, Application Design consistency, Feedback and Evolution constraints, Creativity, Refinement, and Patterns cooperative multithreading, Hardware Corasick, Computer Science Cox, Objective-C components, Objective-C and Other Languages, Components, Sand, and Bricks–Quality As an Economic Phenomenon, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon concurrency and OOP, Objective-C and Other Languages configurability, Objective-C and Other Languages educational background of, Education encapsulation, Components, Sand, and Bricks garbage collection, Objective-C and Other Languages lessons learned from design of Objective-C, Objective-C and Other Languages, Components, Sand, and Bricks lightweight threads, Components, Sand, and Bricks multiple inheritance, Objective-C and Other Languages namespaces not supported in Objective-C, Objective-C and Other Languages Objective-C as extension of C and Smalltalk, Objective-C and Other Languages, Objective-C and Other Languages Objective-C compared to C++, Objective-C and Other Languages OOP increasing complexity of applications, Objective-C and Other Languages quality of software, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Education security of software, Components, Sand, and Bricks single inheritance in Objective-C, Objective-C and Other Languages superdistribution, Components, Sand, and Bricks, Education trusting software, Components, Sand, and Bricks CPAN, Community, Community creative arts, Training Developers creativity as role of programmer, Growing a Language importance of, Learning and Teaching in programming, Language Design necessity of, Creativity, Refinement, and Patterns opportunity to use, Knowledge stimulating in programmers, Bits That Change the Universe tension from, Language Design customer vocabulary, The Forth Language and Language Design D Dahl, An Inspired Afternoon data models, A Seminal Paper data sizes, Programming by Example debugging code C#, C# design considerations for, Designing a Language ease of, Language Design, Designing a New Language functional programming and, Trajectory of Functional Programming language design considerations for, Theory and Practice, Growing a Language Lua, Language Design PostScript, Interfaces to Longevity Python, Multiple Pythons debugging languages, The Pythonic Way declarations, Parallelism Design by Contract, An Inspired Afternoon, An Inspired Afternoon design patterns, Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns Design Patterns: Elements of Reusable Object-Oriented Software (Gamma; Helm; Johnson; Vlissides), Layers and Languages determinism, Feedback and Evolution Dijkstra, An Inspired Afternoon documentation of programming language, Breeding Little Languages documentation of programs comments, Application Design, Experience, C# content of, The Theory of Meaning importance of, Programming by Example leading to better software design, The Role of Documentation programmers writing, C# domain-driven design, The Forth Language and Language Design, Language Design, Language Design, Unix and Its Culture, Concurrency domain-specific languages (DSL), Growing a Language disadvantages of, Language and Design, Growing a Language existence of, C# growth of, Breeding Little Languages Lua used as, Language Design moving to general-purpose, Language programs as, Elementary Principles UML redesigned as set of, UML, UML dynamic languages benefits of, The Good Programmer security and, The Good Programmer dynamic typing, The Pythonic Way E ECMA standardization for C#, C# economic model of software, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon Eiffel, Eiffel adding features to, Managing Growth and Evolution backward compatibility for, Managing Growth and Evolution evolution of, Managing Growth and Evolution–Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution extensibility of, Reusability and Genericity forward compatibility for, Managing Growth and Evolution history of, An Inspired Afternoon–An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon information hiding, Reusability and Genericity proofs in, Proofreading Languages reusability of, Reusability and Genericity streaming serialization, Proofreading Languages embedded applications Forth for, The Forth Language and Language Design emergent systems, Layers and Languages encapsulation, Components, Sand, and Bricks advantages of, Language Design in BASIC, The Goals Behind BASIC engineering links to informatics, Beyond Informatics programming as, Learning and Teaching error messages in Lua, Language Design quality of, Theory and Practice errors handling, Trajectory of Functional Programming language design reducing number of, Theory and Practice reduced by language design, Theory and Practice Excel, Feedback and Evolution extensibility, The Language F Falkoff, APL collections, Parallelism, Parallelism, Parallelism computer science, Elementary Principles design of APL longevity of, Paper and Pencil language design, Elementary Principles language design influencing program design, Elementary Principles parallelism, Parallelism–Legacy, Legacy Perl influenced by APL, Legacy pointers not used in APL, Parallelism programmers, Paper and Pencil relational database design influenced by APL, Parallelism resources, Paper and Pencil The Design of APL, Paper and Pencil Figueiredo, Lua comments, Experience design of Lua, Experience dialects of users, Language Design environments changing design of Lua, Language Design error messages in Lua, Language Design hardware availability, Experience limited resources, Language Design local workarounds versus global fixes in code, Language Design mathematics, Experience mistakes in Lua, Experience programming in Lua, The Power of Scripting programming language design, Language Design–Language Design, Language Design, Language Design, Language Design, Language Design, Language Design, Language Design regrets about Lua, Experience security capabilities of Lua, The Power of Scripting success, Experience teaching debugging, Experience testing Lua, Language Design VM for Lua, Language Design file, Unix and Its Culture file handling, Parallelism first-class functions, The Power of Scripting font scaling in PostScript, Designed to Last for loop, Experience formal semantics benefits for language design, A Seminal Paper not used for PostScript, Designed to Last usefulness of, Formalism and Evolution–Formalism and Evolution, Formalism and Evolution, Formalism and Evolution, Formalism and Evolution formal specifications for C#, C# for languages, Language Design necessity of, Designing a Language Forth, Forth, The Forth Language and Language Design application design with, Application Design–Application Design, Application Design, Application Design, Application Design, Application Design, Application Design asynchronous operation, Hardware comparing to PostScript, Designed to Last conditionals in, Application Design design of longevity of, The Forth Language and Language Design error causes and detection, The Forth Language and Language Design, Application Design for embedded applications, The Forth Language and Language Design I/O capabilities of, Hardware indirect-threaded code, The Forth Language and Language Design loops in, Application Design maintainability of, Application Design minimalism in design of, The Forth Language and Language Design porting, Hardware programmers receptive to, The Forth Language and Language Design programming in, Application Design readability of, The Forth Language and Language Design, The Forth Language and Language Design reusable concepts of meaning with, The Soundness of Theorems simplicity of, The Forth Language and Language Design, The Forth Language and Language Design, Application Design syntax of small words, The Forth Language and Language Design, The Forth Language and Language Design word choice in, Application Design fourth-generation computer language, The Forth Language and Language Design frameworks, Knowledge functional closures, The Haskell Language functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language abstraction in, Trajectory of Functional Programming concurrency and, A Bit of Reusability debugging in, Trajectory of Functional Programming error handling in, Trajectory of Functional Programming longevity of, Trajectory of Functional Programming parallelism and, Trajectory of Functional Programming popularity of, Trajectory of Functional Programming Scala for, Concurrency side effects, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming usefulness of, Bits That Change the Universe functions first class, The Power of Scripting higher-order, The Soundness of Theorems G garbage collection, Objective-C and Other Languages in JVM, Designing a Language in Lua, The Power of Scripting in Objective-C, Objective-C and Other Languages in Python, Multiple Pythons general arrays, Elementary Principles general-purpose languages, Growing a Language generic programming as alternative to OOP, OOP and Concurrency generic types, The Haskell Language genericity, Reusability and Genericity generics in Java, The Haskell Language Geschke, PostScript bugs in ROM, Designed to Last computer science, Research and Education concatenative language, Designed to Last design team for PostScript, Designed to Last hardware considerations, Designed to Last, Interfaces to Longevity history of software and hardware evolution, Research and Education Imaging Sciences Laboratory, Research and Education kerning and ligatures in PostScript, Designed to Last longevity of programming languages, Interfaces to Longevity mathematical background, Designed to Last popularity of languages, Interfaces to Longevity PostScript as language instead of data format, Designed to Last programmer skill, Designed to Last two-dimensional constructs, Designed to Last web use of PostScript, Standard Wishes Gosling adding to Java, Feedback Loop array subscript checking in Java, Power or Simplicity AWT, Power or Simplicity backward compatibility with Java, Power or Simplicity C stacks, Designing a Language C# inspired by Java, Designing a Language complexity, Power or Simplicity complexity of Java, Power or Simplicity computer science, Designing a Language concurrency, Concurrency–Designing a Language, Designing a Language debugging, Designing a Language documentation, Designing a Language error prevention and containment in Java, A Matter of Taste, Designing a Language formal specifications, Designing a Language freeing source code to Java, Feedback Loop garbage collection, Designing a Language Java EE, Power or Simplicity JIT, Power or Simplicity JVM satisfaction with, A Matter of Taste language design affected by network issues, Power or Simplicity language design influencing software design, Designing a Language language designed for personal use of, Designing a Language languages designed by, A Matter of Taste Moore’s Law, Concurrency performance, A Matter of Taste pointers in C++, Designing a Language programmers, Designing a Language references in Java, Designing a Language Scala, Concurrency, Designing a Language simplicity and power, Power or Simplicity system programming languages, Power or Simplicity user feedback for Java, Designing a Language virtual machine for Java, A Matter of Taste GOTO statements, The Goals Behind BASIC, The Goals Behind BASIC graphical interface limitations of, Unix and Its Culture H half-toning for color, Designed to Last Halloween problem, The Language handheld devices, Power or Simplicity hardware availability of, The Life of Algorithms, Breeding Little Languages, Programming by Example computational power of, Hardware considerations for, Designed to Last innovation driven by, Interfaces to Longevity predicting future of, Engineering Objective-C, Engineering Objective-C requirements for concurrency, Hardware viewing as a resource or a limit, Hardware Haskell, Haskell class system for, The Haskell Language competing implementations of, Formalism and Evolution evolution of, Formalism and Evolution–Formalism and Evolution, Formalism and Evolution, Formalism and Evolution influencing other languages, The Haskell Language list comprehensions, The Haskell Language team designing, A Functional Team–Trajectory of Functional Programming, Trajectory of Functional Programming type system for, The Haskell Language, The Haskell Language, The Haskell Language, The Haskell Language, The Theory of Meaning Hejlsberg, C# backward compatibility with JVM, Language and Design comments in C#, C# computer science, The Future of Computer Science debugging, Growing a Language domain-specific languages, Growing a Language, The Future of Computer Science dynamic programming languages, The Future of Computer Science higher-order functions, Language and Design, The Future of Computer Science implementing and designing languages, Language and Design language design, Growing a Language leveraging existing components, Growing a Language personal themes in language design, Language and Design programmers, The Future of Computer Science programming language design, Language and Design–Growing a Language, Language and Design, Language and Design, Language and Design, Language and Design, Language and Design, Growing a Language, Growing a Language safety versus creative freedom, Growing a Language simplicity in language design, Growing a Language teaching languages, Language and Design higher-order functions, The Future of Computer Science higher-order functions in ML, The Soundness of Theorems Hoare, An Inspired Afternoon HOPL-III: The development of the Emerald programming language, OOP and Concurrency HTML, Standard Wishes Hudak functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language Haskell’s influence on other languages, The Haskell Language language design influencing software design, The Haskell Language teaching programming and computer science, Spreading (Functional) Education Hughes functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language hybrid typing, The Pythonic Way I I/O, Hardware Ierusalimschy, Lua closures in Lua, The Power of Scripting code sharing with Lua, Language Design comments, Experience computer science, Experience concurrency with Lua, The Power of Scripting debugging Lua, Language Design extensibility of Lua, Language Design feature set complete for Lua, Language Design first-class functions in Lua, The Power of Scripting fragmentation issues with Lua, Language Design implementation of language affecting design of, Language Design limitations of Lua, The Power of Scripting limited resources, Language Design number handling by Lua, The Power of Scripting programmers, Experience simplicity of Lua, Language Design success, Experience upgrading Lua during development, Language Design user feedback on Lua, Language Design VM for Lua, Language Design implementation, An Inspired Afternoon indirect-threaded code, The Forth Language and Language Design informatics definition of, Beyond Informatics inheritance, Compiler Design injection attacks, Feedback and Evolution intelligent agents for programming, Knowledge interface design, Expedients and Experience, Transformative Technologies Internet as representation of agents, Beyond Informatics Iverson, APL J Jacobson, UML benefits of UML, UML, UML complexity of UML, UML, UML computer science, Learning and Teaching designing UML, UML DSLs, UML Ericsson, Learning and Teaching future possible changes to UML, UML implementation code, UML legacy software, The Role of the People Object-Oriented Software Engineering, Learning and Teaching programming, Learning and Teaching, Knowledge programming approaches in different parts of the world, Learning and Teaching programming knowledge linked to languages, UML programming methods and processes, The Role of the People SDL influencing improvements to UML, UML simplicity, Knowledge size of project determining usefulness of UML, UML social engineering, The Role of the People teams for programming, Learning and Teaching use cases, Learning and Teaching Java, Java AWT and, Power or Simplicity Java EE, Power or Simplicity Javadoc tool, Designing a Language JavaScript, Interfaces to Longevity, Standard Wishes JIT, Power or Simplicity Jones formal semantics, Formalism and Evolution functional programming, Trajectory of Functional Programming, Trajectory of Functional Programming teaching computer science, Spreading (Functional) Education JVM new languages built on, Designing a Language popularity of, A Matter of Taste K kanji characters, Designed to Last Kemeny, BASIC Kernighan, AWK backward compatibility versus innovation, Legacy Culture C, Legacy Culture C++, Legacy Culture command line, Legacy Culture domain-specific languages (DSL), Breeding Little Languages hardware availability, Breeding Little Languages implementation considerations for language design, Legacy Culture language design style of, Language Design large systems, Designing a New Language learning programming languages, Computer Science little languages, Legacy Culture OOP, Designing a New Language programmers, Breeding Little Languages programming first interest in, Breeding Little Languages programming language manuals, Breeding Little Languages programming languages, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language rewriting programs, Legacy Culture success, Breeding Little Languages Tcl/Tk, Transformative Technologies teaching debugging, Breeding Little Languages testing, Transformative Technologies upgrading, Transformative Technologies user considerations in programming, Breeding Little Languages Visual Basic, Transformative Technologies writing text, Breeding Little Languages kerning, Designed to Last knowledge transfer, Learning and Teaching, The Role of the People, Knowledge, Be Ready for Change, Be Ready for Change Kurtz, BASIC algebraic language, The Goals Behind BASIC comments in BASIC, Language and Programming Practice compilers, Compiler Design debugging code, Language Design design of BASIC, The Goals Behind BASIC, Compiler Design encapsulation, Language Design language design influencing program design, Language and Programming Practice learning programming, The Goals Behind BASIC libraries, Language Design, Language Design mathematical formalism, Language Design OOP, Language and Programming Practice polymorphism, Compiler Design productivity when programming, Work Goals programming languages, Language and Programming Practice simplicity of languages, The Goals Behind BASIC single-pass compiler for BASIC, Compiler Design success in programming, Work Goals teaching programming, Compiler Design True BASIC, The Goals Behind BASIC users, Work Goals, Work Goals visual and audio applications, Language Design Visual Basic, Language Design Visual Basic as object-oriented language, Language Design words used in languages, Language Design L language toolkit, The Forth Language and Language Design lazy evaluation, Trajectory of Functional Programming, The Haskell Language LCF, The Soundness of Theorems limits of, The Soundness of Theorems legacy software, Bits That Change the Universe, Theory and Practice approaches for, Project Management and Legacy Software, The Role of the People, Training Developers preventing problems of, Project Management and Legacy Software, Components, Sand, and Bricks problems of, Hardware less is more philosophy, Expedients and Experience levels of abstraction, Using UML lex as transformative technologies, Transformative Technologies lexical scoping, Language libraries as method for extending languages, Unix and Its Culture design of, Unix and Its Culture ligatures, Designed to Last lightweight threads, Components, Sand, and Bricks line numbers in BASIC, The Goals Behind BASIC, Language Design Lisp level of success of, Waiting for a Breakthrough list comprehensions, The Haskell Language little languages, Growing a Language loops alternatives to, Elementary Principles in Forth, Application Design Love, Objective-C appropriate uses of Smalltalk, Engineering Objective-C classes, Project Management and Legacy Software distributed teams, Project Management and Legacy Software hardware, Engineering Objective-C, Engineering Objective-C languages new, Growing a Language legacy software, Project Management and Legacy Software maintaining software, Project Management and Legacy Software managers understanding of languages, Project Management and Legacy Software Objective-C as extension of C and Smalltalk, Growing a Language Objective-C compared to C++, Engineering Objective-C programmers advice for, Project Management and Legacy Software programming, Engineering Objective-C real-life experience, Education and Training simplicity in design, Project Management and Legacy Software success of a project, Project Management and Legacy Software teaching complex technical concepts, Education and Training uses of Objective-C, Engineering Objective-C Lua, Lua, The Power of Scripting feedback from users regarding, Language Design platform independence of, Language Design resources used by, Experience testing features of, Language Design VM choice of ANSI C for, Language Design debugging affected by, Language Design register-based, Language Design M M language, Language Design, Creativity, Refinement, and Patterns Make utility, Transformative Technologies mathematical formalism in language design, Language Design pipes used for, Unix and Its Culture mathematicians, Waiting for a Breakthrough, Experience mathematics importance of learning, Theory and Practice role in computer science, Elementary Principles, Computer Science, Bits That Change the Universe, Experience, Beyond Informatics metalanguages for models, The Soundness of Theorems Méthodes de Programmation (Meyer), An Inspired Afternoon Meyer, Eiffel analysis required before implementation, Proofreading Languages concurrency and OOP, An Inspired Afternoon Design by Contract, An Inspired Afternoon, An Inspired Afternoon genericity, Reusability and Genericity information hiding in Eiffel, Reusability and Genericity language design, Proofreading Languages languages influencing programs, An Inspired Afternoon mathematical versus linguistic perspective for programming, Proofreading Languages multilingual background of, Proofreading Languages objects, An Inspired Afternoon philosophies of programming, An Inspired Afternoon program provability, Proofreading Languages reusability, Reusability and Genericity seamless development, Proofreading Languages small versus large programs, Proofreading Languages specification and implementation, An Inspired Afternoon structured versus OO programming, Proofreading Languages microprocessors, Application Design millenium bug, The Theory of Meaning Milner, ML bugs, The Soundness of Theorems communication among agents, Beyond Informatics computer science, Beyond Informatics concurrent systems, The Soundness of Theorems defining as informatic scientist, Beyond Informatics informatics, Beyond Informatics language design, The Theory of Meaning language design influencing program design, The Soundness of Theorems languages specific to each programmer, The Theory of Meaning levels of models, The Soundness of Theorems logic expressed by ML, The Soundness of Theorems mathematics, Beyond Informatics paradigms, The Theory of Meaning programs, The Theory of Meaning purpose of ML, The Theory of Meaning structural problems in programs, The Theory of Meaning teaching theorems and provability, The Soundness of Theorems theory of meaning, Beyond Informatics ubiquitous systems, Beyond Informatics undecidability in lower levels of models, The Soundness of Theorems minimalism, The Forth Language and Language Design ML, ML formal specification of, The Theory of Meaning role of, The Soundness of Theorems type system for, The Theory of Meaning model-driven development, Proofreading Languages models for systems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, Beyond Informatics Moore, Forth concurrency, Hardware elegant solutions, The Forth Language and Language Design indirect-threaded code in Forth, The Forth Language and Language Design language design, Application Design legacy software, Application Design operating systems, The Forth Language and Language Design parallel processing, The Forth Language and Language Design resuming programming after a hiatus, The Forth Language and Language Design stack, Hardware teamwork in programming, Application Design words, The Forth Language and Language Design, The Forth Language and Language Design, Application Design Moore’s Law, Concurrency multicore computers, Application Design multiple paradigms in Python, The Pythonic Way multithreading as precursor to parallel processing, The Forth Language and Language Design cooperative, Hardware Java frameworks for, Concurrency mathematical software and, Concurrency problems in C++ with, Designing a Language synchronization primitives for, Concurrency music, Education and Training, Growing a Language, Training Developers N namespaces in APL, Parallelism Objective-C not supporting, Objective-C and Other Languages National Instruments Lab View, Creativity, Refinement, and Patterns NetBeans, Designing a Language networked small computers, Application Design networks distribution of, OOP and Concurrency influencing software design, Quality As an Economic Phenomenon SOAs and, Components, Sand, and Bricks superdistribution and, Components, Sand, and Bricks Ng, Learning and Teaching number handling in BASIC, The Goals Behind BASIC in Lua, The Power of Scripting in Python, The Pythonic Way O object-oriented programming (OOP) concurrency and, OOP and Concurrency, A Bit of Reusability correct design influenced by, Creativity, Refinement, and Patterns generic programming as alternative to, OOP and Concurrency good design using, OOP and Concurrency limited applications of, Growing a Language objects handled outside of language, An Inspired Afternoon reusability and, A Bit of Reusability scalability of, A Bit of Reusability, Creativity, Refinement, and Patterns success of, A Matter of Taste usefulness of, Language and Programming Practice, Designing a New Language uses of, Proofreading Languages using well, A Matter of Taste with Visual Basic, Language and Programming Practice Objective-C, Objective-C single inheritance, Objective-C and Other Languages objects, Theory and Practice open source model, Quality As an Economic Phenomenon open source projects, Interfaces to Longevity open standards, Interfaces to Longevity operating systems, The Forth Language and Language Design, Hardware Oracle, A Seminal Paper orthogonality, Feedback and Evolution P parallel processing, The Forth Language and Language Design parallelism in APL, Elementary Principles–Legacy, Parallelism, Parallelism, Parallelism, Legacy uses of, Components, Sand, and Bricks parser for Lua, Language Design patch utility, Transformative Technologies pattern matching algorithms for, Computer Science evolution of, The Life of Algorithms pattern movement, Be Ready for Change, Layers and Languages patterns, Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns PEP (Python Enhancement Proposal), The Pythonic Way performance of BASIC, The Goals Behind BASIC practical implications of, A Matter of Taste Perl, Perl APL influencing, Parallelism community participation in, Community–Evolution and Revolution, Community, Community, Community, Evolution and Revolution context in, Language–Language, Language, Language, Language CPAN for, Community dual licensing, Community evolution of, Language, Language, Evolution and Revolution, Evolution and Revolution, Evolution and Revolution, Evolution and Revolution human language principles influencing, The Language of Revolutions, Language multiple ways of doing something, The Language of Revolutions purposes of, The Language of Revolutions scoping in, The Language of Revolutions syncretic design of, Language transition from text tool to complete language, The Language of Revolutions version 6, The Language of Revolutions, Evolution and Revolution, Evolution and Revolution Peters, The Pythonic Way, The Good Programmer physical processes, The Soundness of Theorems pi calculus, The Soundness of Theorems Pike, Breeding Little Languages pointers compiler handling, Compiler Design polyglot virtual machines, Language and Design polymorphism, Compiler Design postfix operators, The Forth Language and Language Design, The Forth Language and Language Design PostScript, PostScript as concatenative language, Designed to Last design decisions for, Designed to Last fonts, Designed to Last for Apple graphics imaging model, Designed to Last for NeXT graphics imaging model, Designed to Last formal semantics not used for, Designed to Last future evolution of, Designed to Last JavaScript interface, Interfaces to Longevity kerning in, Designed to Last print imaging models, Designed to Last purposes of, Designed to Last writing by hand, Designed to Last pragmatism and creativity, Language Design productivity of programmers language affecting, Growing a Language programmer quality affecting, Project Management and Legacy Software programming language affecting, Theory and Practice when working alone, Work Goals productivity of users, The Language, Feedback and Evolution, Feedback and Evolution programmers all levels of, The Pythonic Way good, The Pythonic Way, Application Design, Research and Education hiring, The Good Programmer improving skills of, Bits That Change the Universe knowledge of, Knowledge, Be Ready for Change paradigms influencing, The Theory of Meaning productivity of, Programming by Example recognizing good, Experience, Education and Training teams of Design by Contract helping, An Inspired Afternoon distributed, Project Management and Legacy Software education for, Designing a Language effectiveness of, Creativity, Refinement, and Patterns importance of, Application Design in classroom, Unix and Its Culture, The Role of Documentation, The Role of Documentation skills required for, Education and Training users as, Knowledge, Be Ready for Change programming analysis in preparation for, Compiler Design, Proofreading Languages approaches to, Learning and Teaching as engineering, Learning and Teaching by example, Theory and Practice, Programming by Example, Programming by Example compared to language design, Theory and Practice compared to mathematical theorems work, Bits That Change the Universe, Programming by Example compared to writing text, Breeding Little Languages components in, Objective-C and Other Languages, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks hardware availability affecting, Programming by Example linguistic perspective of, Proofreading Languages mathematical perspective of, Proofreading Languages nature of, Hardware resuming after a hiatus, The Role of Documentation users, Breeding Little Languages programming language design, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Legacy Culture programming languages adding features to, Language and Design evolution of, Future, The Pythonic Way, Language Design, Engineering Objective-C, Growing a Language, Growing a Language, Growing a Language, Growing a Language, Growing a Language experiments of, Language extensibility of, Expedients and Experience, Unix and Its Culture, Waiting for a Breakthrough, Growing a Language families of, The Theory of Meaning general-purpose, Designing a New Language, Waiting for a Breakthrough growth of, Feedback Loop implementation of, Experience interface for, Transformative Technologies linguistics as influence on, Language little making more general, Legacy Culture, Waiting for a Breakthrough, Growing a Language resurgence of, Legacy Culture longevity of, Unix and Its Culture new, Growing a Language number of in use, Growing a Language productivity affected by, Theory and Practice, Growing a Language safety of, Growing a Language size of, Unix and Its Culture strengths of, Designing a New Language teaching languages, Language and Design testing new features of, Designing a New Language theory of meaning for, Beyond Informatics usability of, Using UML validating, Beyond Informatics programs as domain-specific languages, Elementary Principles beauty or elegance of, Language Design complexity of, A Bit of Reusability, Creativity, Refinement, and Patterns computer’s ability to state meaning of, The Theory of Meaning legacy, Project Management and Legacy Software local workarounds versus global fixes, Bits That Change the Universe maintainability of, Bits That Change the Universe, Waiting for a Breakthrough, Education and Training, Project Management and Legacy Software performance of, Programming by Example problems in, Programming by Example revising heavily before shipping, Transformative Technologies rewriting, Waiting for a Breakthrough size of, Designing a New Language written in 1970s, Hardware protocols, Objective-C and Other Languages provability, The Soundness of Theorems, The Soundness of Theorems proving theorems, The Soundness of Theorems, The Theory of Meaning, The Theory of Meaning Python, Python adding features to, The Pythonic Way, The Pythonic Way, The Pythonic Way bottom-up versus top-down design, The Good Programmer concurrency with, Multiple Pythons design process using, The Good Programmer dynamic features of, The Good Programmer elegance philosophy for, The Pythonic Way, The Good Programmer experts using, The Pythonic Way garbage collection, Multiple Pythons lessons learned from design of, Expedients and Experience macros in, Multiple Pythons maintainability of, The Good Programmer multiple implementations of, Multiple Pythons–Multiple Pythons, Multiple Pythons, Multiple Pythons, Multiple Pythons multiple paradigms in, The Pythonic Way new versions of, The Pythonic Way novices using, The Pythonic Way prototyping uses of, The Good Programmer searching large code bases, Expedients and Experience security of, The Good Programmer simple parser used by, Multiple Pythons strict formatting in, Multiple Pythons type of programmers using, The Pythonic Way Python 3000, The Good Programmer Python Enhancement Proposal (PEP), The Pythonic Way Pythonic, The Pythonic Way Q Quill, Feedback and Evolution R RAD (rapid application development), Future readability, The Forth Language and Language Design refactoring, OOP and Concurrency Reisner, Feedback and Evolution relational databases, Parallelism research groups, Research and Education, Research and Education resilience, Feedback and Evolution resources limited, Experience reusability, Reusability and Genericity and OOP, A Bit of Reusability, A Bit of Reusability and SOA, A Bit of Reusability rule-based technology, Knowledge Rumbaugh, UML background of, Be Ready for Change benefits of UML, Using UML change, Symmetric Relationships communication facilitated by UML, Using UML computer science, Be Ready for Change concurrency, A Bit of Reusability implementation code, Using UML lessons learned by design of UML, Be Ready for Change pattern movement, Layers and Languages programming, Be Ready for Change programming knowledge linked to languages, Be Ready for Change purposes of UML, Using UML redesigning UML, Layers and Languages, Layers and Languages reusability and OOP, A Bit of Reusability security, Symmetric Relationships simplicity, Using UML simplifying UML, Using UML size of project determining usefulness of UML, Using UML SOA, A Bit of Reusability standardization of UML, Layers and Languages universal model/language, Using UML S Scala, Concurrency, Designing a Language SCOOP model, An Inspired Afternoon scoping, The Language of Revolutions SDL, UML, UML, UML seamless development, Proofreading Languages security of software formalisms of language affecting, Unix and Its Culture importance of, Symmetric Relationships language choice affecting, Theory and Practice multilevel integration affecting, Components, Sand, and Bricks with dynamic languages, The Good Programmer with Lua, The Power of Scripting with Python, The Good Programmer SEQUEL, A Seminal Paper service-oriented architecture (SOA), Components, Sand, and Bricks shared variables, Parallelism shell scripts, Unix and Its Culture simplicity advice for, Bits That Change the Universe of Forth, Application Design relationship to power, Power or Simplicity sketching tools, Expedients and Experience Smalltalk browser for, The Future of Computer Science incorporated in Objective-C, Growing a Language social engineering, The Role of the People Software and the Future of Programming Languages (Aho), Unix and Its Culture space insensitivity, The Goals Behind BASIC, Language Design specialization in programming, Layers and Languages specialization of labor, Components, Sand, and Bricks, Components, Sand, and Bricks, Education specifications distinct from implementation, An Inspired Afternoon SQL, SQL, A Seminal Paper–A Seminal Paper, A Seminal Paper, A Seminal Paper influencing future language design, The Language updates on indexes, The Language stack management, Application Design stack-based design, Designed to Last stack-based subroutine calls, The Forth Language and Language Design standardization of APL, Paper and Pencil of C#, C# of UML, Layers and Languages problems with, Standard Wishes static typing, The Pythonic Way statically checked interfaces, OOP and Concurrency Stroustrup academic pursuits of, Future C++0x FAQ, Future concurrency, OOP and Concurrency concurrency and network distribution, OOP and Concurrency creating a new language, Future industry connections of, Teaching lessons from design of C++, Future structured programming, Proofreading Languages Structured Programming (Dahl; Dijkstra; Hoare), An Inspired Afternoon superdistribution, Components, Sand, and Bricks, Education symmetric relationships, Symmetric Relationships–Symmetric Relationships, Symmetric Relationships, Symmetric Relationships System R project, A Seminal Paper systems wider not faster, Concurrency T tables, The Power of Scripting Tcl/Tk, Transformative Technologies teams of programming language designers, Bits That Change the Universe, A Functional Team, A Functional Team, A Functional Team, Feedback Loop, C#, UML, Designed to Last templates, OOP and Concurrency test cases, Learning and Teaching testing code, Experience Python, Multiple Pythons writing code to facilitate, Transformative Technologies The Design and Evolution of C++ (Stroustrup), Future The Design of APL (Falkoff; Iverson), Paper and Pencil The Elements of Programming Style (Kernighan), Breeding Little Languages The Formal Description of System 360 (Falkoff; Iverson; Sussenguth), Paper and Pencil The Practice of Programming (Kernighan; Pike), Breeding Little Languages theorems proving as purpose of ML, The Theory of Meaning with LCF and ML, The Soundness of Theorems with type system, The Theory of Meaning working on, Bits That Change the Universe, Programming by Example transformative technologies, Transformative Technologies–Transformative Technologies, Transformative Technologies, Transformative Technologies True BASIC, The Goals Behind BASIC, The Goals Behind BASIC, Language Design type checking, The Forth Language and Language Design type systems decidability of, The Soundness of Theorems in ML, The Theory of Meaning U ubiquitous systems, Beyond Informatics UML (Unified Modeling Language), UML, UML, UML backward compatibility with, Layers and Languages persuading people of benefits of, UML, UML, Using UML, UML purposes of, UML removing elements from, UML semantic definitions in, UML Unix, Unix and Its Culture use cases, Learning and Teaching user-created and built-in language elements, Elementary Principles users considering when programming, Language Design, Work Goals, Breeding Little Languages V van Rossum, Python dynamic typing, The Pythonic Way garbage collection in Python, Multiple Pythons interface or API design, Expedients and Experience learning Python, The Good Programmer macros in Python, Multiple Pythons programmers, The Pythonic Way recognizing good, The Good Programmer Pythonic, The Pythonic Way resuming programming, Expedients and Experience skills of, The Good Programmer static typing, The Pythonic Way testing Python code, Expedients and Experience visual applications, Language Design Visual Basic limitations of, Language Design usefulness of, Transformative Technologies visual programming languages, Creativity, Refinement, and Patterns W Wadler class system in Haskell, The Haskell Language language design influencing software design, The Haskell Language Wall, Perl complexity of languages, Language CPAN, Community languages compared to tools, Language languages moving from specialized to general-purpose, Language transition of Perl from text tool to complete language, The Language of Revolutions Warnock, PostScript font building for PostScript, Designed to Last web, Standard Wishes website resources C++ Standards Committee, Future Weinberger, AWK AWK compared to SQL, Bits That Change the Universe C, Waiting for a Breakthrough creativity in programmers, Bits That Change the Universe error messages, Theory and Practice extensible languages, Waiting for a Breakthrough functional programming, Bits That Change the Universe general-purpose languages, Waiting for a Breakthrough implementation affecting language design, Theory and Practice language design, Theory and Practice, Waiting for a Breakthrough, Waiting for a Breakthrough, Waiting for a Breakthrough, Waiting for a Breakthrough, Programming by Example large programs in AWK, Waiting for a Breakthrough learning new things on Internet, Bits That Change the Universe Lisp, Waiting for a Breakthrough little programs, Bits That Change the Universe mathematics, Bits That Change the Universe mistakes made by, Bits That Change the Universe objects compared to system components, Theory and Practice problems in software, Programming by Example programming, Bits That Change the Universe programming by example, Theory and Practice programming language design, Theory and Practice, Theory and Practice programs rewriting, Waiting for a Breakthrough security, Theory and Practice simplicity, Bits That Change the Universe success, Waiting for a Breakthrough teaching debugging, Bits That Change the Universe teaching programming, Theory and Practice whitespace insensitivity, Language Design WYSIWYG editors, Language Design X X Window system, Legacy Culture XML, XQuery and XML XQuery, XQuery and XML Y yacc as transformative technology, Legacy Culture Yahoo!

Symbols 169-176 breakthroughs needed in, Waiting for a Breakthrough, Waiting for a Breakthrough by mathematicians, Waiting for a Breakthrough, Experience clean design, Programming by Example compared to library design, Language and Design debugging considerations for, Theory and Practice designer’s preferences influencing, Theory and Practice environment influencing, Language and Design errors reduced by, Theory and Practice for handheld devices, Power or Simplicity for system programming, Power or Simplicity formalisms for mathematical, Language Design usefulness of, Unix and Its Culture implementation affecting, Language Design implementation considerations for, Designing a New Language, Theory and Practice implementation related to, Language and Design improvements to process of, Designing a New Language, Designing a New Language influencing program design, Language Design inspiration for, Creativity, Refinement, and Patterns personal approach for, Elementary Principles prototypes for, Designing a New Language scientific approach for, Designing a New Language, Theory and Practice, Growing a Language starting with small core set of functionality, Growing a Language, Proofreading Languages syntax choices for, Theory and Practice teams for democratic nature of, Feedback Loop user considerations, Language Design utility considerations, Language Design A A Note on Pattern Matching: Where do you find the match to an empty array (Falkoff), Elementary Principles A Programming Language (Iverson), Paper and Pencil abstraction in functional programming, A Functional Team in SQL, Feedback and Evolution agents, Beyond Informatics Aho, AWK Aho-Corasick algorithm, Computer Science automata theory, Computer Science command-line tools, Unix and Its Culture compilers course taught by, The Role of Documentation–The Role of Documentation, The Role of Documentation, The Role of Documentation, The Role of Documentation data size handled by AWK, The Life of Algorithms debugging, Language Design, The Role of Documentation documentation leading to better software design, The Role of Documentation–The Role of Documentation, The Role of Documentation, The Role of Documentation domain, Unix and Its Culture file concept applied to Internet, Unix and Its Culture formalizing semantics of languages, Unix and Its Culture graphical interfaces, Unix and Its Culture hardware availability, The Life of Algorithms hardware efficiency, Unix and Its Culture improving programming skills, Language Design knowledge required to use AWK, Language Design large programs, The Life of Algorithms lex, Language Design portability of Unix, Unix and Its Culture programming, The Role of Documentation programming language design, Language Design programming languages, Unix and Its Culture purposes appropriate for use of AWK, The Life of Algorithms, Unix and Its Culture research in computer science, Computer Science role in AWK development, The Life of Algorithms security and degree of formalism, Unix and Its Culture teaching programming, Language Design theory and practice as motivation, Unix and Its Culture utility of programming language, Language Design yacc, Language Design Aho-Corasick algorithm, Computer Science algebraic language, The Goals Behind BASIC allocated memory, Compiler Design API design, Expedients and Experience, Feedback Loop, C# APL, APL character set for, Paper and Pencil, Elementary Principles collections in, Parallelism design, Elementary Principles design history of, Paper and Pencil, Elementary Principles general arrays in, Elementary Principles implementation on handheld devices, Paper and Pencil learning, Paper and Pencil lessons learned from design of, Legacy namespaces, Parallelism parallelism with, Parallelism–Legacy, Parallelism, Parallelism, Legacy, Legacy regrets about, Legacy resources used efficiently by, Paper and Pencil standardization of, Elementary Principles syntax for based on algebraic notation, Paper and Pencil, Elementary Principles simplicity/complexity of, Paper and Pencil, Elementary Principles, Elementary Principles teaching programming with, Elementary Principles APL\360, Paper and Pencil arbitrary precision integers, The Pythonic Way architects, Be Ready for Change aspect orientation, Learning and Teaching Aspect-Oriented Software Development with Use Cases (Jacobson; Ng), Learning and Teaching asymmetrical coroutines, The Power of Scripting asynchronous operation, Hardware audio applications, Language Design automata theory, Computer Science automatic code checking, Designing a Language AWK, AWK, The Life of Algorithms compared to SQL, Bits That Change the Universe initial design ideas for, Bits That Change the Universe large programs good practices for, The Life of Algorithms improvements for, Theory and Practice longevity of, Theory and Practice programming advice for, Designing a New Language programming by example, Programming by Example–Programming by Example, Programming by Example, Programming by Example, Programming by Example, Programming by Example, Programming by Example regrets about, Bits That Change the Universe AWT, Power or Simplicity B backward compatibility, Formalism and Evolution for potentially redesigned UML, Layers and Languages with Java, Power or Simplicity with JVM, Language and Design with UML, Language Design BASIC, BASIC comments, Language and Programming Practice compiler one pass for, The Goals Behind BASIC, The Goals Behind BASIC two passes for, The Goals Behind BASIC design of considerations for, The Goals Behind BASIC, The Goals Behind BASIC holding up over time, Language Design encapsulation, The Goals Behind BASIC hardware evolution influencing, The Goals Behind BASIC large programs, The Goals Behind BASIC lessons learned from design of, Language Design libraries, Language Design number handling, The Goals Behind BASIC, The Goals Behind BASIC performance of, The Goals Behind BASIC teaching programming using, The Goals Behind BASIC True BASIC, The Goals Behind BASIC variable declarations not required in, Compiler Design bitmap fonts, Designed to Last Booch, UML backward compatibility with UML, Language Design benefits of UML, UML body of literature for programming, Training Developers business rules, Creativity, Refinement, and Patterns complexity and OOP, Creativity, Refinement, and Patterns complexity of UML, UML concurrency, Creativity, Refinement, and Patterns constraints contributing to innovation, Creativity, Refinement, and Patterns creativity and pragmatism, Language Design design of UML, UML implementation code, UML language design, Creativity, Refinement, and Patterns language design compared to programming, Language Design language design influencing programs, Language Design legacy software, Creativity, Refinement, and Patterns OOP influencing correct design, Creativity, Refinement, and Patterns percentage of UML used all the time, UML, Language Design redesigning UML, UML simplicity, Creativity, Refinement, and Patterns standardization of UML, Language Design–Training Developers, Language Design, Language Design, Training Developers training programmers, Training Developers–Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns bottom-up design with Forth, The Forth Language and Language Design with Python, The Good Programmer Boyce, SQL, A Seminal Paper brown field development, Creativity, Refinement, and Patterns bugs in language design, The Theory of Meaning business rules, Creativity, Refinement, and Patterns C C as system programming language, Power or Simplicity longevity of, Legacy Culture Objective-C as extension of, Engineering Objective-C performance of, Power or Simplicity signedness in, Waiting for a Breakthrough size of code, Project Management and Legacy Software C#, C# as replacement for C++, Growing a Language debugging, C# design team for, C# evolution of, C# formal specifications for, C# Java as inspiration for, Designing a Language longevity of, Growing a Language user feedback for, Language and Design, C# C++ backward compatibility with C, Legacy Culture C# as replacement for, C# compared to Objective-C, Engineering Objective-C, Objective-C and Other Languages compatibility requirements of, The Pythonic Way complexity of, Engineering Objective-C concurrency support in, OOP and Concurrency evolution of, Growing a Language future versions of, Future lessons learned from design of, Future multithreading in, Designing a Language pointers in problems with, Designing a Language popularity of, Engineering Objective-C C++ 2.0, Future C++0x, OOP and Concurrency, Future Calculus of Communicating Systems (CCS), The Soundness of Theorems CCS (Calculus of Communicating Systems), The Soundness of Theorems Celes, Lua Chamberlin, SQL complexity of SQL, Feedback and Evolution concurrent data access in SQL, The Language declarative nature of SQL, The Language design history of SQL, A Seminal Paper–A Seminal Paper, A Seminal Paper, A Seminal Paper, A Seminal Paper design principles of SQL, The Language determinism, Feedback and Evolution Excel compared with relational database systems, Feedback and Evolution external visibility of, Feedback and Evolution injection attacks on SQL, Feedback and Evolution knowledge required to use SQL, Feedback and Evolution languages, A Seminal Paper popularity of SQL, Feedback and Evolution scalability of SQL, Feedback and Evolution standardization of SQL and XQuery, XQuery and XML usability tests on SQL, Feedback and Evolution user feedback on SQL, Feedback and Evolution users of SQL, Feedback and Evolution views in SQL, The Language XML, XQuery and XML XQuery, XQuery and XML character set, Paper and Pencil, Elementary Principles class system, The Haskell Language classes, Project Management and Legacy Software closure in Lua, The Power of Scripting in SQL, The Language Codd, SQL, A Seminal Paper code browsing, The Pythonic Way code examples in programming manuals, Breeding Little Languages code reuse, Compiler Design collections design implications of, Parallelism large unstructured, Parallelism operations on each element of, Elementary Principles color, Designed to Last colorForth, The Forth Language and Language Design command line AWK used with, Unix and Its Culture compared to graphical interface, Designing a New Language composing programs on, Unix and Its Culture limitations of, Bits That Change the Universe resurgence of, Legacy Culture tools for, Unix and Its Culture comments, Application Design, The Theory of Meaning in BASIC, Compiler Design in C#, C# role of, Experience communication among interactive agents, Beyond Informatics role in informatics, Beyond Informatics compilers quality of code in, Application Design writing, The Forth Language and Language Design, Compiler Design, The Role of Documentation completeness, The Language complex algorithms, The Life of Algorithms components, Objective-C and Other Languages, Objective-C and Other Languages, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon, Growing a Language computer science current problems in, The Future of Computer Science future of, Interfaces to Longevity problems of, Beyond Informatics, Components, Sand, and Bricks research in, Beyond Informatics role of mathematics in, Elementary Principles, Computer Science, Experience, Beyond Informatics whether it is a science, Experience, Quality As an Economic Phenomenon computer science education approaches for, Bits That Change the Universe, Spreading (Functional) Education beginning programming, The Pythonic Way, Elementary Principles, The Goals Behind BASIC, Compiler Design functional languages, Spreading (Functional) Education multiple languages, Language and Programming Practice, Breeding Little Languages teaching languages, The Goals Behind BASIC, The Goals Behind BASIC, Language and Design teamwork in, Unix and Its Culture–The Role of Documentation, The Role of Documentation, The Role of Documentation, The Role of Documentation topics needed in, Education and Training, Be Ready for Change concurrency, Creativity, Refinement, and Patterns adding to language, Language and Design analyzing concurrent systems, The Soundness of Theorems approaches for, Hardware challenges of, The Future of Computer Science, The Future of Computer Science design affected by, Concurrency framework handling, The Future of Computer Science functional languages and, A Bit of Reusability in C++, OOP and Concurrency in C++0x, OOP and Concurrency in Lua, The Power of Scripting in Python, Multiple Pythons in SQL, The Language language design affected by, The Future of Computer Science network distribution and, OOP and Concurrency OOP and, OOP and Concurrency, Objective-C and Other Languages, A Bit of Reusability pattern matching using, Computer Science requirements for, Concurrency conditionals, Application Design consistency, Feedback and Evolution constraints, Creativity, Refinement, and Patterns cooperative multithreading, Hardware Corasick, Computer Science Cox, Objective-C components, Objective-C and Other Languages, Components, Sand, and Bricks–Quality As an Economic Phenomenon, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon concurrency and OOP, Objective-C and Other Languages configurability, Objective-C and Other Languages educational background of, Education encapsulation, Components, Sand, and Bricks garbage collection, Objective-C and Other Languages lessons learned from design of Objective-C, Objective-C and Other Languages, Components, Sand, and Bricks lightweight threads, Components, Sand, and Bricks multiple inheritance, Objective-C and Other Languages namespaces not supported in Objective-C, Objective-C and Other Languages Objective-C as extension of C and Smalltalk, Objective-C and Other Languages, Objective-C and Other Languages Objective-C compared to C++, Objective-C and Other Languages OOP increasing complexity of applications, Objective-C and Other Languages quality of software, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Education security of software, Components, Sand, and Bricks single inheritance in Objective-C, Objective-C and Other Languages superdistribution, Components, Sand, and Bricks, Education trusting software, Components, Sand, and Bricks CPAN, Community, Community creative arts, Training Developers creativity as role of programmer, Growing a Language importance of, Learning and Teaching in programming, Language Design necessity of, Creativity, Refinement, and Patterns opportunity to use, Knowledge stimulating in programmers, Bits That Change the Universe tension from, Language Design customer vocabulary, The Forth Language and Language Design D Dahl, An Inspired Afternoon data models, A Seminal Paper data sizes, Programming by Example debugging code C#, C# design considerations for, Designing a Language ease of, Language Design, Designing a New Language functional programming and, Trajectory of Functional Programming language design considerations for, Theory and Practice, Growing a Language Lua, Language Design PostScript, Interfaces to Longevity Python, Multiple Pythons debugging languages, The Pythonic Way declarations, Parallelism Design by Contract, An Inspired Afternoon, An Inspired Afternoon design patterns, Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns Design Patterns: Elements of Reusable Object-Oriented Software (Gamma; Helm; Johnson; Vlissides), Layers and Languages determinism, Feedback and Evolution Dijkstra, An Inspired Afternoon documentation of programming language, Breeding Little Languages documentation of programs comments, Application Design, Experience, C# content of, The Theory of Meaning importance of, Programming by Example leading to better software design, The Role of Documentation programmers writing, C# domain-driven design, The Forth Language and Language Design, Language Design, Language Design, Unix and Its Culture, Concurrency domain-specific languages (DSL), Growing a Language disadvantages of, Language and Design, Growing a Language existence of, C# growth of, Breeding Little Languages Lua used as, Language Design moving to general-purpose, Language programs as, Elementary Principles UML redesigned as set of, UML, UML dynamic languages benefits of, The Good Programmer security and, The Good Programmer dynamic typing, The Pythonic Way E ECMA standardization for C#, C# economic model of software, Components, Sand, and Bricks, Components, Sand, and Bricks, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon, Quality As an Economic Phenomenon Eiffel, Eiffel adding features to, Managing Growth and Evolution backward compatibility for, Managing Growth and Evolution evolution of, Managing Growth and Evolution–Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution, Managing Growth and Evolution extensibility of, Reusability and Genericity forward compatibility for, Managing Growth and Evolution history of, An Inspired Afternoon–An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon, An Inspired Afternoon information hiding, Reusability and Genericity proofs in, Proofreading Languages reusability of, Reusability and Genericity streaming serialization, Proofreading Languages embedded applications Forth for, The Forth Language and Language Design emergent systems, Layers and Languages encapsulation, Components, Sand, and Bricks advantages of, Language Design in BASIC, The Goals Behind BASIC engineering links to informatics, Beyond Informatics programming as, Learning and Teaching error messages in Lua, Language Design quality of, Theory and Practice errors handling, Trajectory of Functional Programming language design reducing number of, Theory and Practice reduced by language design, Theory and Practice Excel, Feedback and Evolution extensibility, The Language F Falkoff, APL collections, Parallelism, Parallelism, Parallelism computer science, Elementary Principles design of APL longevity of, Paper and Pencil language design, Elementary Principles language design influencing program design, Elementary Principles parallelism, Parallelism–Legacy, Legacy Perl influenced by APL, Legacy pointers not used in APL, Parallelism programmers, Paper and Pencil relational database design influenced by APL, Parallelism resources, Paper and Pencil The Design of APL, Paper and Pencil Figueiredo, Lua comments, Experience design of Lua, Experience dialects of users, Language Design environments changing design of Lua, Language Design error messages in Lua, Language Design hardware availability, Experience limited resources, Language Design local workarounds versus global fixes in code, Language Design mathematics, Experience mistakes in Lua, Experience programming in Lua, The Power of Scripting programming language design, Language Design–Language Design, Language Design, Language Design, Language Design, Language Design, Language Design, Language Design regrets about Lua, Experience security capabilities of Lua, The Power of Scripting success, Experience teaching debugging, Experience testing Lua, Language Design VM for Lua, Language Design file, Unix and Its Culture file handling, Parallelism first-class functions, The Power of Scripting font scaling in PostScript, Designed to Last for loop, Experience formal semantics benefits for language design, A Seminal Paper not used for PostScript, Designed to Last usefulness of, Formalism and Evolution–Formalism and Evolution, Formalism and Evolution, Formalism and Evolution, Formalism and Evolution formal specifications for C#, C# for languages, Language Design necessity of, Designing a Language Forth, Forth, The Forth Language and Language Design application design with, Application Design–Application Design, Application Design, Application Design, Application Design, Application Design, Application Design asynchronous operation, Hardware comparing to PostScript, Designed to Last conditionals in, Application Design design of longevity of, The Forth Language and Language Design error causes and detection, The Forth Language and Language Design, Application Design for embedded applications, The Forth Language and Language Design I/O capabilities of, Hardware indirect-threaded code, The Forth Language and Language Design loops in, Application Design maintainability of, Application Design minimalism in design of, The Forth Language and Language Design porting, Hardware programmers receptive to, The Forth Language and Language Design programming in, Application Design readability of, The Forth Language and Language Design, The Forth Language and Language Design reusable concepts of meaning with, The Soundness of Theorems simplicity of, The Forth Language and Language Design, The Forth Language and Language Design, Application Design syntax of small words, The Forth Language and Language Design, The Forth Language and Language Design word choice in, Application Design fourth-generation computer language, The Forth Language and Language Design frameworks, Knowledge functional closures, The Haskell Language functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language abstraction in, Trajectory of Functional Programming concurrency and, A Bit of Reusability debugging in, Trajectory of Functional Programming error handling in, Trajectory of Functional Programming longevity of, Trajectory of Functional Programming parallelism and, Trajectory of Functional Programming popularity of, Trajectory of Functional Programming Scala for, Concurrency side effects, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming usefulness of, Bits That Change the Universe functions first class, The Power of Scripting higher-order, The Soundness of Theorems G garbage collection, Objective-C and Other Languages in JVM, Designing a Language in Lua, The Power of Scripting in Objective-C, Objective-C and Other Languages in Python, Multiple Pythons general arrays, Elementary Principles general-purpose languages, Growing a Language generic programming as alternative to OOP, OOP and Concurrency generic types, The Haskell Language genericity, Reusability and Genericity generics in Java, The Haskell Language Geschke, PostScript bugs in ROM, Designed to Last computer science, Research and Education concatenative language, Designed to Last design team for PostScript, Designed to Last hardware considerations, Designed to Last, Interfaces to Longevity history of software and hardware evolution, Research and Education Imaging Sciences Laboratory, Research and Education kerning and ligatures in PostScript, Designed to Last longevity of programming languages, Interfaces to Longevity mathematical background, Designed to Last popularity of languages, Interfaces to Longevity PostScript as language instead of data format, Designed to Last programmer skill, Designed to Last two-dimensional constructs, Designed to Last web use of PostScript, Standard Wishes Gosling adding to Java, Feedback Loop array subscript checking in Java, Power or Simplicity AWT, Power or Simplicity backward compatibility with Java, Power or Simplicity C stacks, Designing a Language C# inspired by Java, Designing a Language complexity, Power or Simplicity complexity of Java, Power or Simplicity computer science, Designing a Language concurrency, Concurrency–Designing a Language, Designing a Language debugging, Designing a Language documentation, Designing a Language error prevention and containment in Java, A Matter of Taste, Designing a Language formal specifications, Designing a Language freeing source code to Java, Feedback Loop garbage collection, Designing a Language Java EE, Power or Simplicity JIT, Power or Simplicity JVM satisfaction with, A Matter of Taste language design affected by network issues, Power or Simplicity language design influencing software design, Designing a Language language designed for personal use of, Designing a Language languages designed by, A Matter of Taste Moore’s Law, Concurrency performance, A Matter of Taste pointers in C++, Designing a Language programmers, Designing a Language references in Java, Designing a Language Scala, Concurrency, Designing a Language simplicity and power, Power or Simplicity system programming languages, Power or Simplicity user feedback for Java, Designing a Language virtual machine for Java, A Matter of Taste GOTO statements, The Goals Behind BASIC, The Goals Behind BASIC graphical interface limitations of, Unix and Its Culture H half-toning for color, Designed to Last Halloween problem, The Language handheld devices, Power or Simplicity hardware availability of, The Life of Algorithms, Breeding Little Languages, Programming by Example computational power of, Hardware considerations for, Designed to Last innovation driven by, Interfaces to Longevity predicting future of, Engineering Objective-C, Engineering Objective-C requirements for concurrency, Hardware viewing as a resource or a limit, Hardware Haskell, Haskell class system for, The Haskell Language competing implementations of, Formalism and Evolution evolution of, Formalism and Evolution–Formalism and Evolution, Formalism and Evolution, Formalism and Evolution influencing other languages, The Haskell Language list comprehensions, The Haskell Language team designing, A Functional Team–Trajectory of Functional Programming, Trajectory of Functional Programming type system for, The Haskell Language, The Haskell Language, The Haskell Language, The Haskell Language, The Theory of Meaning Hejlsberg, C# backward compatibility with JVM, Language and Design comments in C#, C# computer science, The Future of Computer Science debugging, Growing a Language domain-specific languages, Growing a Language, The Future of Computer Science dynamic programming languages, The Future of Computer Science higher-order functions, Language and Design, The Future of Computer Science implementing and designing languages, Language and Design language design, Growing a Language leveraging existing components, Growing a Language personal themes in language design, Language and Design programmers, The Future of Computer Science programming language design, Language and Design–Growing a Language, Language and Design, Language and Design, Language and Design, Language and Design, Language and Design, Growing a Language, Growing a Language safety versus creative freedom, Growing a Language simplicity in language design, Growing a Language teaching languages, Language and Design higher-order functions, The Future of Computer Science higher-order functions in ML, The Soundness of Theorems Hoare, An Inspired Afternoon HOPL-III: The development of the Emerald programming language, OOP and Concurrency HTML, Standard Wishes Hudak functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language Haskell’s influence on other languages, The Haskell Language language design influencing software design, The Haskell Language teaching programming and computer science, Spreading (Functional) Education Hughes functional programming, Trajectory of Functional Programming–The Haskell Language, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, Trajectory of Functional Programming, The Haskell Language hybrid typing, The Pythonic Way I I/O, Hardware Ierusalimschy, Lua closures in Lua, The Power of Scripting code sharing with Lua, Language Design comments, Experience computer science, Experience concurrency with Lua, The Power of Scripting debugging Lua, Language Design extensibility of Lua, Language Design feature set complete for Lua, Language Design first-class functions in Lua, The Power of Scripting fragmentation issues with Lua, Language Design implementation of language affecting design of, Language Design limitations of Lua, The Power of Scripting limited resources, Language Design number handling by Lua, The Power of Scripting programmers, Experience simplicity of Lua, Language Design success, Experience upgrading Lua during development, Language Design user feedback on Lua, Language Design VM for Lua, Language Design implementation, An Inspired Afternoon indirect-threaded code, The Forth Language and Language Design informatics definition of, Beyond Informatics inheritance, Compiler Design injection attacks, Feedback and Evolution intelligent agents for programming, Knowledge interface design, Expedients and Experience, Transformative Technologies Internet as representation of agents, Beyond Informatics Iverson, APL J Jacobson, UML benefits of UML, UML, UML complexity of UML, UML, UML computer science, Learning and Teaching designing UML, UML DSLs, UML Ericsson, Learning and Teaching future possible changes to UML, UML implementation code, UML legacy software, The Role of the People Object-Oriented Software Engineering, Learning and Teaching programming, Learning and Teaching, Knowledge programming approaches in different parts of the world, Learning and Teaching programming knowledge linked to languages, UML programming methods and processes, The Role of the People SDL influencing improvements to UML, UML simplicity, Knowledge size of project determining usefulness of UML, UML social engineering, The Role of the People teams for programming, Learning and Teaching use cases, Learning and Teaching Java, Java AWT and, Power or Simplicity Java EE, Power or Simplicity Javadoc tool, Designing a Language JavaScript, Interfaces to Longevity, Standard Wishes JIT, Power or Simplicity Jones formal semantics, Formalism and Evolution functional programming, Trajectory of Functional Programming, Trajectory of Functional Programming teaching computer science, Spreading (Functional) Education JVM new languages built on, Designing a Language popularity of, A Matter of Taste K kanji characters, Designed to Last Kemeny, BASIC Kernighan, AWK backward compatibility versus innovation, Legacy Culture C, Legacy Culture C++, Legacy Culture command line, Legacy Culture domain-specific languages (DSL), Breeding Little Languages hardware availability, Breeding Little Languages implementation considerations for language design, Legacy Culture language design style of, Language Design large systems, Designing a New Language learning programming languages, Computer Science little languages, Legacy Culture OOP, Designing a New Language programmers, Breeding Little Languages programming first interest in, Breeding Little Languages programming language manuals, Breeding Little Languages programming languages, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language rewriting programs, Legacy Culture success, Breeding Little Languages Tcl/Tk, Transformative Technologies teaching debugging, Breeding Little Languages testing, Transformative Technologies upgrading, Transformative Technologies user considerations in programming, Breeding Little Languages Visual Basic, Transformative Technologies writing text, Breeding Little Languages kerning, Designed to Last knowledge transfer, Learning and Teaching, The Role of the People, Knowledge, Be Ready for Change, Be Ready for Change Kurtz, BASIC algebraic language, The Goals Behind BASIC comments in BASIC, Language and Programming Practice compilers, Compiler Design debugging code, Language Design design of BASIC, The Goals Behind BASIC, Compiler Design encapsulation, Language Design language design influencing program design, Language and Programming Practice learning programming, The Goals Behind BASIC libraries, Language Design, Language Design mathematical formalism, Language Design OOP, Language and Programming Practice polymorphism, Compiler Design productivity when programming, Work Goals programming languages, Language and Programming Practice simplicity of languages, The Goals Behind BASIC single-pass compiler for BASIC, Compiler Design success in programming, Work Goals teaching programming, Compiler Design True BASIC, The Goals Behind BASIC users, Work Goals, Work Goals visual and audio applications, Language Design Visual Basic, Language Design Visual Basic as object-oriented language, Language Design words used in languages, Language Design L language toolkit, The Forth Language and Language Design lazy evaluation, Trajectory of Functional Programming, The Haskell Language LCF, The Soundness of Theorems limits of, The Soundness of Theorems legacy software, Bits That Change the Universe, Theory and Practice approaches for, Project Management and Legacy Software, The Role of the People, Training Developers preventing problems of, Project Management and Legacy Software, Components, Sand, and Bricks problems of, Hardware less is more philosophy, Expedients and Experience levels of abstraction, Using UML lex as transformative technologies, Transformative Technologies lexical scoping, Language libraries as method for extending languages, Unix and Its Culture design of, Unix and Its Culture ligatures, Designed to Last lightweight threads, Components, Sand, and Bricks line numbers in BASIC, The Goals Behind BASIC, Language Design Lisp level of success of, Waiting for a Breakthrough list comprehensions, The Haskell Language little languages, Growing a Language loops alternatives to, Elementary Principles in Forth, Application Design Love, Objective-C appropriate uses of Smalltalk, Engineering Objective-C classes, Project Management and Legacy Software distributed teams, Project Management and Legacy Software hardware, Engineering Objective-C, Engineering Objective-C languages new, Growing a Language legacy software, Project Management and Legacy Software maintaining software, Project Management and Legacy Software managers understanding of languages, Project Management and Legacy Software Objective-C as extension of C and Smalltalk, Growing a Language Objective-C compared to C++, Engineering Objective-C programmers advice for, Project Management and Legacy Software programming, Engineering Objective-C real-life experience, Education and Training simplicity in design, Project Management and Legacy Software success of a project, Project Management and Legacy Software teaching complex technical concepts, Education and Training uses of Objective-C, Engineering Objective-C Lua, Lua, The Power of Scripting feedback from users regarding, Language Design platform independence of, Language Design resources used by, Experience testing features of, Language Design VM choice of ANSI C for, Language Design debugging affected by, Language Design register-based, Language Design M M language, Language Design, Creativity, Refinement, and Patterns Make utility, Transformative Technologies mathematical formalism in language design, Language Design pipes used for, Unix and Its Culture mathematicians, Waiting for a Breakthrough, Experience mathematics importance of learning, Theory and Practice role in computer science, Elementary Principles, Computer Science, Bits That Change the Universe, Experience, Beyond Informatics metalanguages for models, The Soundness of Theorems Méthodes de Programmation (Meyer), An Inspired Afternoon Meyer, Eiffel analysis required before implementation, Proofreading Languages concurrency and OOP, An Inspired Afternoon Design by Contract, An Inspired Afternoon, An Inspired Afternoon genericity, Reusability and Genericity information hiding in Eiffel, Reusability and Genericity language design, Proofreading Languages languages influencing programs, An Inspired Afternoon mathematical versus linguistic perspective for programming, Proofreading Languages multilingual background of, Proofreading Languages objects, An Inspired Afternoon philosophies of programming, An Inspired Afternoon program provability, Proofreading Languages reusability, Reusability and Genericity seamless development, Proofreading Languages small versus large programs, Proofreading Languages specification and implementation, An Inspired Afternoon structured versus OO programming, Proofreading Languages microprocessors, Application Design millenium bug, The Theory of Meaning Milner, ML bugs, The Soundness of Theorems communication among agents, Beyond Informatics computer science, Beyond Informatics concurrent systems, The Soundness of Theorems defining as informatic scientist, Beyond Informatics informatics, Beyond Informatics language design, The Theory of Meaning language design influencing program design, The Soundness of Theorems languages specific to each programmer, The Theory of Meaning levels of models, The Soundness of Theorems logic expressed by ML, The Soundness of Theorems mathematics, Beyond Informatics paradigms, The Theory of Meaning programs, The Theory of Meaning purpose of ML, The Theory of Meaning structural problems in programs, The Theory of Meaning teaching theorems and provability, The Soundness of Theorems theory of meaning, Beyond Informatics ubiquitous systems, Beyond Informatics undecidability in lower levels of models, The Soundness of Theorems minimalism, The Forth Language and Language Design ML, ML formal specification of, The Theory of Meaning role of, The Soundness of Theorems type system for, The Theory of Meaning model-driven development, Proofreading Languages models for systems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, The Soundness of Theorems, Beyond Informatics Moore, Forth concurrency, Hardware elegant solutions, The Forth Language and Language Design indirect-threaded code in Forth, The Forth Language and Language Design language design, Application Design legacy software, Application Design operating systems, The Forth Language and Language Design parallel processing, The Forth Language and Language Design resuming programming after a hiatus, The Forth Language and Language Design stack, Hardware teamwork in programming, Application Design words, The Forth Language and Language Design, The Forth Language and Language Design, Application Design Moore’s Law, Concurrency multicore computers, Application Design multiple paradigms in Python, The Pythonic Way multithreading as precursor to parallel processing, The Forth Language and Language Design cooperative, Hardware Java frameworks for, Concurrency mathematical software and, Concurrency problems in C++ with, Designing a Language synchronization primitives for, Concurrency music, Education and Training, Growing a Language, Training Developers N namespaces in APL, Parallelism Objective-C not supporting, Objective-C and Other Languages National Instruments Lab View, Creativity, Refinement, and Patterns NetBeans, Designing a Language networked small computers, Application Design networks distribution of, OOP and Concurrency influencing software design, Quality As an Economic Phenomenon SOAs and, Components, Sand, and Bricks superdistribution and, Components, Sand, and Bricks Ng, Learning and Teaching number handling in BASIC, The Goals Behind BASIC in Lua, The Power of Scripting in Python, The Pythonic Way O object-oriented programming (OOP) concurrency and, OOP and Concurrency, A Bit of Reusability correct design influenced by, Creativity, Refinement, and Patterns generic programming as alternative to, OOP and Concurrency good design using, OOP and Concurrency limited applications of, Growing a Language objects handled outside of language, An Inspired Afternoon reusability and, A Bit of Reusability scalability of, A Bit of Reusability, Creativity, Refinement, and Patterns success of, A Matter of Taste usefulness of, Language and Programming Practice, Designing a New Language uses of, Proofreading Languages using well, A Matter of Taste with Visual Basic, Language and Programming Practice Objective-C, Objective-C single inheritance, Objective-C and Other Languages objects, Theory and Practice open source model, Quality As an Economic Phenomenon open source projects, Interfaces to Longevity open standards, Interfaces to Longevity operating systems, The Forth Language and Language Design, Hardware Oracle, A Seminal Paper orthogonality, Feedback and Evolution P parallel processing, The Forth Language and Language Design parallelism in APL, Elementary Principles–Legacy, Parallelism, Parallelism, Parallelism, Legacy uses of, Components, Sand, and Bricks parser for Lua, Language Design patch utility, Transformative Technologies pattern matching algorithms for, Computer Science evolution of, The Life of Algorithms pattern movement, Be Ready for Change, Layers and Languages patterns, Creativity, Refinement, and Patterns, Creativity, Refinement, and Patterns PEP (Python Enhancement Proposal), The Pythonic Way performance of BASIC, The Goals Behind BASIC practical implications of, A Matter of Taste Perl, Perl APL influencing, Parallelism community participation in, Community–Evolution and Revolution, Community, Community, Community, Evolution and Revolution context in, Language–Language, Language, Language, Language CPAN for, Community dual licensing, Community evolution of, Language, Language, Evolution and Revolution, Evolution and Revolution, Evolution and Revolution, Evolution and Revolution human language principles influencing, The Language of Revolutions, Language multiple ways of doing something, The Language of Revolutions purposes of, The Language of Revolutions scoping in, The Language of Revolutions syncretic design of, Language transition from text tool to complete language, The Language of Revolutions version 6, The Language of Revolutions, Evolution and Revolution, Evolution and Revolution Peters, The Pythonic Way, The Good Programmer physical processes, The Soundness of Theorems pi calculus, The Soundness of Theorems Pike, Breeding Little Languages pointers compiler handling, Compiler Design polyglot virtual machines, Language and Design polymorphism, Compiler Design postfix operators, The Forth Language and Language Design, The Forth Language and Language Design PostScript, PostScript as concatenative language, Designed to Last design decisions for, Designed to Last fonts, Designed to Last for Apple graphics imaging model, Designed to Last for NeXT graphics imaging model, Designed to Last formal semantics not used for, Designed to Last future evolution of, Designed to Last JavaScript interface, Interfaces to Longevity kerning in, Designed to Last print imaging models, Designed to Last purposes of, Designed to Last writing by hand, Designed to Last pragmatism and creativity, Language Design productivity of programmers language affecting, Growing a Language programmer quality affecting, Project Management and Legacy Software programming language affecting, Theory and Practice when working alone, Work Goals productivity of users, The Language, Feedback and Evolution, Feedback and Evolution programmers all levels of, The Pythonic Way good, The Pythonic Way, Application Design, Research and Education hiring, The Good Programmer improving skills of, Bits That Change the Universe knowledge of, Knowledge, Be Ready for Change paradigms influencing, The Theory of Meaning productivity of, Programming by Example recognizing good, Experience, Education and Training teams of Design by Contract helping, An Inspired Afternoon distributed, Project Management and Legacy Software education for, Designing a Language effectiveness of, Creativity, Refinement, and Patterns importance of, Application Design in classroom, Unix and Its Culture, The Role of Documentation, The Role of Documentation skills required for, Education and Training users as, Knowledge, Be Ready for Change programming analysis in preparation for, Compiler Design, Proofreading Languages approaches to, Learning and Teaching as engineering, Learning and Teaching by example, Theory and Practice, Programming by Example, Programming by Example compared to language design, Theory and Practice compared to mathematical theorems work, Bits That Change the Universe, Programming by Example compared to writing text, Breeding Little Languages components in, Objective-C and Other Languages, Components, Sand, and Bricks, Components, Sand, and Bricks, Components, Sand, and Bricks hardware availability affecting, Programming by Example linguistic perspective of, Proofreading Languages mathematical perspective of, Proofreading Languages nature of, Hardware resuming after a hiatus, The Role of Documentation users, Breeding Little Languages programming language design, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Designing a New Language, Legacy Culture programming languages adding features to, Language and Design evolution of, Future, The Pythonic Way, Language Design, Engineering Objective-C, Growing a Language, Growing a Language, Growing a Language, Growing a Language, Growing a Language experiments of, Language extensibility of, Expedients and Experience, Unix and Its Culture, Waiting for a Breakthrough, Growing a Language families of, The Theory of Meaning general-purpose, Designing a New Language, Waiting for a Breakthrough growth of, Feedback Loop implementation of, Experience interface for, Transformative Technologies linguistics as influence on, Language little making more general, Legacy Culture, Waiting for a Breakthrough, Growing a Language resurgence of, Legacy Culture longevity of, Unix and Its Culture new, Growing a Language number of in use, Growing a Language productivity affected by, Theory and Practice, Growing a Language safety of, Growing a Language size of, Unix and Its Culture strengths of, Designing a New Language teaching languages, Language and Design testing new features of, Designing a New Language theory of meaning for, Beyond Informatics usability of, Using UML validating, Beyond Informatics programs as domain-specific languages, Elementary Principles beauty or elegance of, Language Design complexity of, A Bit of Reusability, Creativity, Refinement, and Patterns computer’s ability to state meaning of, The Theory of Meaning legacy, Project Management and Legacy Software local workarounds versus global fixes, Bits That Change the Universe maintainability of, Bits That Change the Universe, Waiting for a Breakthrough, Education and Training, Project Management and Legacy Software performance of, Programming by Example problems in, Programming by Example revising heavily before shipping, Transformative Technologies rewriting, Waiting for a Breakthrough size of, Designing a New Language written in 1970s, Hardware protocols, Objective-C and Other Languages provability, The Soundness of Theorems, The Soundness of Theorems proving theorems, The Soundness of Theorems, The Theory of Meaning, The Theory of Meaning Python, Python adding features to, The Pythonic Way, The Pythonic Way, The Pythonic Way bottom-up versus top-down design, The Good Programmer concurrency with, Multiple Pythons design process using, The Good Programmer dynamic features of, The Good Programmer elegance philosophy for, The Pythonic Way, The Good Programmer experts using, The Pythonic Way garbage collection, Multiple Pythons lessons learned from design of, Expedients and Experience macros in, Multiple Pythons maintainability of, The Good Programmer multiple implementations of, Multiple Pythons–Multiple Pythons, Multiple Pythons, Multiple Pythons, Multiple Pythons multiple paradigms in, The Pythonic Way new versions of, The Pythonic Way novices using, The Pythonic Way prototyping uses of, The Good Programmer searching large code bases, Expedients and Experience security of, The Good Programmer simple parser used by, Multiple Pythons strict formatting in, Multiple Pythons type of programmers using, The Pythonic Way Python 3000, The Good Programmer Python Enhancement Proposal (PEP), The Pythonic Way Pythonic, The Pythonic Way Q Quill, Feedback and Evolution R RAD (rapid application development), Future readability, The Forth Language and Language Design refactoring, OOP and Concurrency Reisner, Feedback and Evolution relational databases, Parallelism research groups, Research and Education, Research and Education resilience, Feedback and Evolution resources limited, Experience reusability, Reusability and Genericity and OOP, A Bit of Reusability, A Bit of Reusability and SOA, A Bit of Reusability rule-based technology, Knowledge Rumbaugh, UML background of, Be Ready for Change benefits of UML, Using UML change, Symmetric Relationships communication facilitated by UML, Using UML computer science, Be Ready for Change concurrency, A Bit of Reusability implementation code, Using UML lessons learned by design of UML, Be Ready for Change pattern movement, Layers and Languages programming, Be Ready for Change programming knowledge linked to languages, Be Ready for Change purposes of UML, Using UML redesigning UML, Layers and Languages, Layers and Languages reusability and OOP, A Bit of Reusability security, Symmetric Relationships simplicity, Using UML simplifying UML, Using UML size of project determining usefulness of UML, Using UML SOA, A Bit of Reusability standardization of UML, Layers and Languages universal model/language, Using UML S Scala, Concurrency, Designing a Language SCOOP model, An Inspired Afternoon scoping, The Language of Revolutions SDL, UML, UML, UML seamless development, Proofreading Languages security of software formalisms of language affecting, Unix and Its Culture importance of, Symmetric Relationships language choice affecting, Theory and Practice multilevel integration affecting, Components, Sand, and Bricks with dynamic languages, The Good Programmer with Lua, The Power of Scripting with Python, The Good Programmer SEQUEL, A Seminal Paper service-oriented architecture (SOA), Components, Sand, and Bricks shared variables, Parallelism shell scripts, Unix and Its Culture simplicity advice for, Bits That Change the Universe of Forth, Application Design relationship to power, Power or Simplicity sketching tools, Expedients and Experience Smalltalk browser for, The Future of Computer Science incorporated in Objective-C, Growing a Language social engineering, The Role of the People Software and the Future of Programming Languages (Aho), Unix and Its Culture space insensitivity, The Goals Behind BASIC, Language Design specialization in programming, Layers and Languages specialization of labor, Components, Sand, and Bricks, Components, Sand, and Bricks, Education specifications distinct from implementation, An Inspired Afternoon SQL, SQL, A Seminal Paper–A Seminal Paper, A Seminal Paper, A Seminal Paper influencing future language design, The Language updates on indexes, The Language stack management, Application Design stack-based design, Designed to Last stack-based subroutine calls, The Forth Language and Language Design standardization of APL, Paper and Pencil of C#, C# of UML, Layers and Languages problems with, Standard Wishes static typing, The Pythonic Way statically checked interfaces, OOP and Concurrency Stroustrup academic pursuits of, Future C++0x FAQ, Future concurrency, OOP and Concurrency concurrency and network distribution, OOP and Concurrency creating a new language, Future industry connections of, Teaching lessons from design of C++, Future structured programming, Proofreading Languages Structured Programming (Dahl; Dijkstra; Hoare), An Inspired Afternoon superdistribution, Components, Sand, and Bricks, Education symmetric relationships, Symmetric Relationships–Symmetric Relationships, Symmetric Relationships, Symmetric Relationships System R project, A Seminal Paper systems wider not faster, Concurrency T tables, The Power of Scripting Tcl/Tk, Transformative Technologies teams of programming language designers, Bits That Change the Universe, A Functional Team, A Functional Team, A Functional Team, Feedback Loop, C#, UML, Designed to Last templates, OOP and Concurrency test cases, Learning and Teaching testing code, Experience Python, Multiple Pythons writing code to facilitate, Transformative Technologies The Design and Evolution of C++ (Stroustrup), Future The Design of APL (Falkoff; Iverson), Paper and Pencil The Elements of Programming Style (Kernighan), Breeding Little Languages The Formal Description of System 360 (Falkoff; Iverson; Sussenguth), Paper and Pencil The Practice of Programming (Kernighan; Pike), Breeding Little Languages theorems proving as purpose of ML, The Theory of Meaning with LCF and ML, The Soundness of Theorems with type system, The Theory of Meaning working on, Bits That Change the Universe, Programming by Example transformative technologies, Transformative Technologies–Transformative Technologies, Transformative Technologies, Transformative Technologies True BASIC, The Goals Behind BASIC, The Goals Behind BASIC, Language Design type checking, The Forth Language and Language Design type systems decidability of, The Soundness of Theorems in ML, The Theory of Meaning U ubiquitous systems, Beyond Informatics UML (Unified Modeling Language), UML, UML, UML backward compatibility with, Layers and Languages persuading people of benefits of, UML, UML, Using UML, UML purposes of, UML removing elements from, UML semantic definitions in, UML Unix, Unix and Its Culture use cases, Learning and Teaching user-created and built-in language elements, Elementary Principles users considering when programming, Language Design, Work Goals, Breeding Little Languages V van Rossum, Python dynamic typing, The Pythonic Way garbage collection in Python, Multiple Pythons interface or API design, Expedients and Experience learning Python, The Good Programmer macros in Python, Multiple Pythons programmers, The Pythonic Way recognizing good, The Good Programmer Pythonic, The Pythonic Way resuming programming, Expedients and Experience skills of, The Good Programmer static typing, The Pythonic Way testing Python code, Expedients and Experience visual applications, Language Design Visual Basic limitations of, Language Design usefulness of, Transformative Technologies visual programming languages, Creativity, Refinement, and Patterns W Wadler class system in Haskell, The Haskell Language language design influencing software design, The Haskell Language Wall, Perl complexity of languages, Language CPAN, Community languages compared to tools, Language languages moving from specialized to general-purpose, Language transition of Perl from text tool to complete language, The Language of Revolutions Warnock, PostScript font building for PostScript, Designed to Last web, Standard Wishes website resources C++ Standards Committee, Future Weinberger, AWK AWK compared to SQL, Bits That Change the Universe C, Waiting for a Breakthrough creativity in programmers, Bits That Change the Universe error messages, Theory and Practice extensible languages, Waiting for a Breakthrough functional programming, Bits That Change the Universe general-purpose languages, Waiting for a Breakthrough implementation affecting language design, Theory and Practice language design, Theory and Practice, Waiting for a Breakthrough, Waiting for a Breakthrough, Waiting for a Breakthrough, Waiting for a Breakthrough, Programming by Example large programs in AWK, Waiting for a Breakthrough learning new things on Internet, Bits That Change the Universe Lisp, Waiting for a Breakthrough little programs, Bits That Change the Universe mathematics, Bits That Change the Universe mistakes made by, Bits That Change the Universe objects compared to system components, Theory and Practice problems in software, Programming by Example programming, Bits That Change the Universe programming by example, Theory and Practice programming language design, Theory and Practice, Theory and Practice programs rewriting, Waiting for a Breakthrough security, Theory and Practice simplicity, Bits That Change the Universe success, Waiting for a Breakthrough teaching debugging, Bits That Change the Universe teaching programming, Theory and Practice whitespace insensitivity, Language Design WYSIWYG editors, Language Design X X Window system, Legacy Culture XML, XQuery and XML XQuery, XQuery and XML Y yacc as transformative technology, Legacy Culture Yahoo!

In that sense object-oriented programming is a problem, but you could do object-oriented programming with immutable objects. Then you wouldn’t have these same problems. That’s kind of what functional programming languages are doing, for example. Regarding your interest in functional programming, should computer science students study more math and experiment more with functional programming? Anders: Well, I certainly think that it is important to include functional programming in any computer science curricula. Whether you start with it that depends. I’m not sure that your very first introduction to programming should be functional programming, but I definitely think that it ought to be part of a curriculum. What lessons should people learn from your experience?

pages: 184 words: 13,957

Programming in Haskell by Graham Hutton

The Computer Journal, 43(4), 2000. 11. Paul Hudak. Conception, Evolution and Application of Functional Programming Languages. Communications of the ACM, 21(3): 359–411, 1989. 12. Gerard Huet. The Zipper. Journal of Functional Programming, 7(5): 549–554, September 1997. 13. John Hughes. Why Functional Programming Matters. The Computer Journal, 32(2): 98–107, 1989. 14. Graham Hutton. A Tutorial on the Universality and Expressiveness of Fold. Journal of Functional Programming, 9(4): 355–372, 1999. 15. Graham Hutton. The Countdown Problem. Journal of Functional Programming, 12(6): 609–616, 2002. 16. Graham Hutton and Erik Meijer. Monadic Parser Combinators.

r Written by a leading Haskell researcher and instructor, well known for his teaching skills r Can be used with courses, or as a stand-alone text for self-learning Graham Hutton has worked in four of the leading centres for research and teaching on functional programming. He has more than 15 years of experience in functional programming research, during which time he has published more than 30 research articles, chaired the Haskell Workshop, and edited a special issue on Haskell of the Journal of Functional Programming. He also has more than 10 years’ experience in teaching Haskell, and in promoting the use of functional programming in the curriculum. Programming in Haskell Graham Hutton University of Nottingham CAMBRIDGE UNIVERSITY PRESS Cambridge, New York, Melbourne, Madrid, Cape Town, Singapore, São Paulo Cambridge University Press The Edinburgh Building, Cambridge CB2 8RU, UK Published in the United States of America by Cambridge University Press, New York www.cambridge.org Information on this title: www.cambridge.org/9780521871723 © G.

In general, the order in which functions are applied in a calculation does not affect the value of the ﬁnal result, but it may affect the number of steps required, and may affect whether the calculation process terminates. These issues are explored in more detail in chapter 12. 1.2 Functional programming What is functional programming? Opinions differ, and it is difﬁcult to give a precise deﬁnition. Generally speaking, however, functional programming can be viewed as a style of programming in which the basic method of computation is the application of functions to arguments. In turn, a functional programming language is one that supports and encourages the functional style. To illustrate these ideas, let us consider the task of computing the sum of the integers (whole numbers) between one and some larger number n .

pages: 706 words: 120,784

The Joy of Clojure by Michael Fogus, Chris Houser

Chapter 7 will tackle Clojure’s approach to functional programming full-on. For those of you coming from a functional programming background, much of the chapter will be familiar, although Clojure will present its own unique blend. But like every programming language dubbed “functional,” Clojure’s implementation will provide a different lens by which to view your previous experience. For those of you wholly unfamiliar with functional programming techniques, chapter 7 will likely be mind-bending. In coming from a language that centers on object hierarchies and imperative programming techniques, the notion of functional programming seems alien.

The Clojure way 1.1.1. Simplicity 1.1.2. Freedom to focus 1.1.3. Empowerment 1.1.4. Clarity 1.1.5. Consistency 1.2. Why a(nother) Lisp? 1.2.1. Beauty 1.2.2. Extreme flexibility 1.2.3. Code is data 1.3. Functional programming 1.3.1. A workable definition of functional programming 1.3.2. The implications of functional programming 1.4. Why Clojure isn’t especially object-oriented 1.4.1. Defining terms 1.4.2. Imperative “baked in” 1.4.3. Most of what OOP gives you, Clojure provides 1.5. Summary Chapter 2. Drinking from the Clojure firehose 2.1.

Lisp’s homoiconicity takes a great conceptual leap in order to fully grasp, but we’ll lead you toward that understanding throughout this book in hopes that you too will come to realize the inherent power. There’s a joy in learning Lisp for the first time, and if that’s your experience coming into this book then we welcome you—and envy you. 1.3. Functional programming Quick, what does functional programming mean? Wrong answer. Don’t be too discouraged, however—we don’t really know the answer either. Functional programming is one of those computing terms[5] that has a nebulous definition. If you ask 100 programmers for their definition, you’ll likely receive 100 different answers. Sure, some definitions will be similar, but like snowflakes, no two will be exactly the same.

pages: 554 words: 108,035

Scala in Depth by Tom Kleenex, Joshua Suereth

It’s an area of software design and architecture that has been neglected in mainstream books and classes since the emergence of object-oriented programming. Functional programming offers a lot to the object-oriented developer and can nicely complement standard object-oriented practices. Functional programming is a relatively large topic to try to compress into a single chapter. Instead, this chapter introduces a few key abstractions used in functional programming and demonstrates their usage in two different situations. The goal is to show one of the many styles of functional programming, rather than turn you into an expert functional programmer. First, a discussion on some fundamental concepts behind the patterns in functional programming. 11.1.

This means that developers can make direct use of existing Java libraries and integrate Scala into their Java applications while also gaining the additional power of Scala. This integration makes Scala a practical choice for any JVM-based project. Let’s take a deeper look at the blending of paradigms in Scala. 1.1. Functional programming meets object orientation Functional programming and object-oriented programming are two different ways of looking at a problem. Functional programming puts special emphasis on the “verbs” of a program and ways to combine and manipulate them. Object-oriented programming puts special emphasis on “nouns” and attaches verbs to them. The two approaches are almost inverses of each other, with one being “top down” and the other “bottom up.”

The code focuses on the nouns and their actions: Cat.eat(), Cat.catch(...). In functional programming, the focus is on the verbs. Functional programming approaches software as the combination and application of functions. It tends to decompose software into behaviors, or actions that need to be performed, usually in a bottom-up fashion. Functions are viewed in a mathematical sense, purely operations on their input. All variables are considered immutable. This immutability aids concurrent programming. Functional programming attempts to defer all side effects in a program as long as possible. Removing side effects makes reasoning through a program simpler, in a formal sense.

Functional Programming in Scala by Paul Chiusano, Rúnar Bjarnason

www.it-ebooks.info MEAP Edition Manning Early Access Program Functional Programming in Scala version 10 Copyright 2013 Manning Publications For more information on this and other Manning titles go to www.manning.com www.it-ebooks.info brief contents PART 1: INTRODUCTION TO FUNCTIONAL PROGRAMMING 1. What is functional programming? 2. Getting Started 3. Functional data structures 4. Handling errors without exceptions 5. Strictness and laziness 6. Purely functional state PART 2: FUNCTIONAL DESIGN AND COMBINATOR LIBRARIES 7. Purely functional parallelism 8. Property-based testing 9. Parser combinators PART 3: FUNCTIONAL DESIGN PATTERNS 10.

There are chapter notes (which includes references to external resources) and www.it-ebooks.info 4 several appendix chapters after Part 4. Throughout the book we provide references to this supplementary material, which you can explore on your own if that interests you. Have fun and good luck. www.it-ebooks.info 5 1 What is Functional Programming? 1.1 The fundamental premise of functional programming Functional programming (FP) is based on a simple premise with far-reaching implications: We construct our programs using only pure functions. In other words, functions that have no side effects. What does this mean exactly? Performing any of the following actions directly would involve a side effect: Reassigning a variable Modifying a data structure in place Setting a field on an object Throwing an exception or halting with an error Printing to the console or reading user input Reading from or writing to a file Drawing on the screen Consider what programming would be like without the ability to do these things.

www.it-ebooks.info 32 Index Terms annonymous function block curried form currying function literals higher-order function import lambda lambda expression lambda notation left-hand side method definition method signature module monomorphic monomorphism namespace object package partial application proper tail-calls REPL right-hand side self-recursion singleton type string interpolation tail-call optimization tail position type parameters uncurry uncurry underscore syntax val keyword www.it-ebooks.info 33 3 Functional data structures 3.1 Introduction We said in the introduction that functional programs do not update variables or modify data structures. This raises pressing questions—what sort of data structures can we use in functional programming, how do we define them in Scala, and how do we operate over these data structures? In this chapter we will learn the concept of a functional data structure and how to define and work with such structures. We'll use this as an opportunity to introduce how data types are defined in functional programming, learn about the related technique of pattern matching, and get practice writing and generalizing pure functions.

pages: 536 words: 73,482

Programming Clojure by Stuart Halloway, Aaron Bedra

And yet, pure functional languages like Haskell have not taken over the world, because developers find that not everything fits easily into the pure functional view. There are four reasons that Clojure can attract more interest now than functional languages have in the past: Functional programming is more urgent today than ever before. Massively multicore hardware is right around the corner, and functional languages provide a clear approach for taking advantage of it. Functional programming is covered in Chapter 4, ​Functional Programming​. Purely functional languages can make it awkward to model state that really needs to change. Clojure provides a structured mechanism for working with changeable state via software transactional memory and refs (), agents (), atoms (), and dynamic binding ().

Clojure’s dynamic typing makes it more accessible for programmers learning functional programming. Clojure’s Java invocation approach is not functional. When you call Java, you enter the familiar, mutable world. This offers a comfortable haven for beginners learning functional programming and a pragmatic alternative to functional style when you need it. Java invocation is covered in Chapter 9, ​Java Down and Dirty​. Clojure’s approach to changing state enables concurrency without explicit locking and complements Clojure’s functional core. Clojure Simplifies Concurrent Programming Clojure’s support for functional programming makes it easy to write thread-safe code.

[32] http://clojure.org/data_structures Copyright © 2012, The Pragmatic Bookshelf. Chapter 4 Functional Programming Functional programming (FP) is a big topic, not to be learned in twenty-one days[33] or in a single chapter of a book. Nevertheless, you can reach a first level of effectiveness using lazy and recursive techniques in Clojure fairly quickly, and that is what we’ll accomplish this chapter. Here’s how we’ll do that: In Section 4.1, ​Functional Programming Concepts​, you’ll get a quick overview of FP terms and concepts. This section also introduces the “Six Rules of Clojure FP” that we will refer to throughout the chapter.

Programming in Haskell by Graham Hutton

Hutton, “A Tutorial on the Universality and Expressiveness of Fold,” Journal of Functional Programming, vol. 9, no. 4, 1999. [11]G. Hutton and J. Wright, “Calculating an Exceptional Machine,” in Trends in Functional Programming Volume 5. Intellect, 2006. [12]G. Huet, “The Zipper,” Journal of Functional Programming, vol. 7, no. 5, 1997. [13]G. Hutton, “The Countdown Problem,” Journal of Functional Programming, vol. 12, no. 6, 2002. [14]R. Bird and S.-C. Mu, “Countdown: A Case Study in Origami Programming,” Journal of Functional Programming, vol. 15, no. 5, 2005. [15]S. Peyton Jones, “Tackling the Awkward Squad: Monadic Input/Output, Concurrency, Exceptions, and Foreign-Language Calls in Haskell,” in Engineering Theories of Software Construction.

In the 1950s, John McCarthy developed Lisp (“LISt Processor”), generally regarded as being the first functional programming language. Lisp had some influences from the lambda calculus, but still retained the concept of variable assignment as a central feature of the language. In the 1960s, Peter Landin developed ISWIM (“If you See What I Mean”), the first pure functional programming language, based strongly on the lambda calculus and having no variable assignments. In the 1970s, John Backus developed FP (“Functional Programming”), a functional programming language that particularly emphasised the idea of higher-order functions and reasoning about programs.

Similarly, using one effect such as concurrency or input/output we can simulate other effects such as mutability. John Hughes famously stated in his classic paper Why Functional Programming Matters that we cannot make a language more powerful by eliminating features. To that, we add that often we cannot even make a language less powerful by removing features. In this book, Graham demonstrates convincingly that the true value of functional programming lies in leveraging first-class functions to achieve compositionality and equational reasoning. Or in Graham’s own words, “functional programming can be viewed as a style of programming in which the basic method of computation is the application of functions to arguments”.

pages: 230

Purely Functional Data Structures by Chris Okasaki

Journal of the ACM, 39(3):617-648, July 1992. (p. 2) [BC93] F. Warren Burton and Robert D. Cameron. Pattern matching with abstract data types. Journal of Functional Programming, 3(2): 171-190, April 1993. (p. 180) [Bel57] Richard Bellman. Dynamic Programming. Princeton University Press, 1957. (p. 37) [BH89] Bror Bjerner and Soren Holmstrom. A compositional approach to time analysis of first order lazy functional programs. In Conference on Functional Programming Languages and Computer Architecture, pages 157-165, September 1989. (p. 82) 207 208 [BO96] [Bro78] [Bro95] [Bro96] [BST95] [BT95] [Buc93] [Bur82] [But83] [BW88] [CG93] [CLR90] [CM95] Bibliography Gerth St0lting Brodal and Chris Okasaki.

Butler. Computer response time and user performance. In Conference on Human Factors in Computing Systems, pages 5862, December 1983. (p. 83) Richard S. Bird and Philip Wadler. Introduction to Functional Programming. Prentice Hall International, 1988. (p. 29) Tyng-Ruey Chuang and Benjamin Goldberg. Real-time deques, multihead Turing machines, and purely functional programming. In Conference on Functional Programming Languages and Computer Architecture, pages 289-298, June 1993. (pp. 109,113) Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest. Introduction to algorithms. MIT Press, 1990. (p. 27) Richard H.

Journal of Functional Programming, 2(4):505-513, October 1992. (pp.44,109,113) John E. Hopcroft and Jeffrey D. Ullman. Set merging algorithms. SI AM Journal on Computing, 2(4): 294-303, December 1973. (p. 37) John Hughes. Lazy memo functions. In Conference on Functional Programming Languages and Computer Architecture, volume 201 of LNCS, pages 129-146. Springer-Verlag, September 1985. (p. 37) John Hughes. A novel representation of lists and its application to the function "reverse". Information Processing Letters, 22(3): 141-144, March 1986. (p. 169) John Hughes. Why functional programming matters.

pages: 263 words: 20,730

Exploring Python by Timothy Budd

Each differs from the imperative paradigm not in the way the computer operates, but in the way that the programmer thinks about the task of programming. The Functional Programming Paradigm The term functional programming does not simply imply programming with functions, but is used to describe an alternative to the imperative programming paradigm. As the name suggests, the creation of functions is an important part of functional programming. But simply defining a few functions does not mean that you are programming in a functional style. There were many functions defined in earlier chapters, and yet we did not call those functional programs. The key characteristic of a program developed in the functional programming style is that it creates new values by a process of transformation.

By emphasizing transformation, rather than modification, functional programs work on a larger scale. Transformations are often more uniform, and much simpler to write and debug. Errors, when they do occur, tend to be larger and thus easier to find and eliminate. The difference between a functional and an imperative style is best illustrated by examples, as we will shortly present. Mapping, Filtering and Reduction The process of transformation can be subdivided into several common forms. The three most common varieties of transformation are mapping, filtering, and reduction. Exploring Python – Chapter 8: Functional Programming 1 A mapping is a one to one transformation.

The following illustrates the application of each of these functions: >>> >>> [3, >>> [2, a = [1, 2, 3, 4, 5] print map(lambda x : x * 2 + 1, a) 5, 7, 9, 11] print filter(lambda x: x % 2 == 0, a) 4] Exploring Python – Chapter 8: Functional Programming 2 >>> print reduce(lambda x, y: x + y, a) 15 Notice that the original list, held in the variable named a, remains unchanged. The functions map, filter and reduce produce new lists that are transformations of the argument. The function filter requires an argument that is itself a function that takes only one argument, and returns a Boolean value. A one-argument function that returns a Boolean result is termed a predicate. List Comprehensions An even simpler form of functional programming is provided by a list comprehension. Instead of defining a list by a sequence of elements, lists can be characterized by a process.

pages: 647 words: 43,757

Types and Programming Languages by Benjamin C. Pierce

It also includes a description of System F from its creator, and an appendix introducing linear logic. Connections between types and logic are further explored in Pfenning's Computation and Deduction (2001). Thompson's Type Theory and Functional Programming (1991) and Turner's Constructive Foundations for Functional Languages (1991) focus on connections between functional programming (in the "pure functional programming" sense of Haskell or Miranda) and constructive type theory, viewed from a logical perspective. A number of relevant topics from proof theory are developed in Goubault-Larrecq and Mackie's Proof Theory and Automated Deduction (1997).

Girard, Jean-Yves, Yves Lafont, and Paul Taylor. Proofs and Types, volume 7 of Cambridge Tracts in Theoretical Computer Science. Cambridge University Press, 1989. Glew, Neal. Type dispatch for named hierarchical types. In International Conference on Functional Programming (ICFP), Paris, France,pages 172–182, 1999. Gordon, Andrew. A tutorial on co-induction and functional programming. In Functional Programming, Glasgow 1994, pages 78–95. Springer Workshops in Computing, 1995. Gordon, Michael J. Adding eval to ML. Manuscript, circa 1980. Gordon, Michael J., Robin Milner, and Christopher P. Wadsworth. Edinburgh LCF. Springer-Verlag LNCS 78, 1979.

Unlike the object encodings that we have already encountered in Chapter 18, all the examples in this section are purely functional programs. This is purely an expository choice: mechanisms for modularity and abstraction are almost completely orthogonal to the statefulness or statelessness of the abstractions being defined. (Exercises 24.2.2 and 24.2.4 illustrate this point by developing stateful versions of some of the purely functional examples in the text.) The reasons for preferring purely functional examples here are that (1) this choice implies that our examples live in a simpler and more economical formal framework, and (2) working with purely functional programs sometimes makes the typing problems more interesting (and their solutions correspondingly more revealing).

pages: 999 words: 194,942

Clojure Programming by Chas Emerick, Brian Carper, Christophe Grand

channels=#clojure if you aren’t on IRC regularly enough to maintain a desktop client. Part I. Functional Programming and Concurrency Chapter 2. Functional Programming Functional programming (FP) is one of those amorphous concepts in software development that means different things to different people. Despite the many shades of gray that exist in the FP spectrum, it’s easy to assert that Clojure is a functional programming language, and that that character is the root of many of its most attractive facilities and advantages. In this chapter, we will: Give you a reasonable introduction to what functional programming is Explain why you should care about it Discuss the details of Clojure’s implementation that make it a desirable functional programming language Along the way, we hope to make the case that FP—and Clojure’s flavor of FP in particular—far from being an academic exercise, can improve your practice of software design and development just as structural- and object-oriented programming concepts have over the years.

fixtures, Fixtures flow, The Persistent, Evolving Environment fn, Creating Functions: fn, Function literals, Preconditions and Postconditions for, Collection form-level comments, Comments forms, Comments, Comments, Special Forms, Dynamic Scope, Macroexpansion, Choosing Clojure Type Definition Forms Wisely (see also special forms) comment forms, Comments concurrency forms, Dynamic Scope expanding nested forms, Macroexpansion println forms, Comments type definition forms, Choosing Clojure Type Definition Forms Wisely forward declarations, Forward Declarations FP (functional programming), Functional Programming, Functional Programming in the Real World, What Does Functional Programming Mean?, On the Importance of Values, A Critical Choice, About Values, Comparing Values to Mutable Objects, Comparing Values to Mutable Objects, A Critical Choice, First-Class and Higher-Order Functions, Applying Ourselves Partially, Composition of Function(ality), Building a Primitive Logging System with Composable Higher-Order Functions, Writing Higher-Order Functions, Building a Primitive Logging System with Composable Higher-Order Functions, Building a Primitive Logging System with Composable Higher-Order Functions, Pure Functions about, What Does Functional Programming Mean?

If you are completely new to FP or initially skeptical of it, we’d urge you in particular to hang on for the ride, it’ll be worth your time and effort.[35] Recall again from Chapter 1 the adage Clojure demands that you raise your game, and pays you back for doing so; just as you may have had to grow to learn object-oriented programming, or Java generics, or Ruby, you’ll have to reach a little to be able to understand and make the most of FP—and therefore Clojure. But in return, you’ll have not just a “new way of thinking,” but a set of tools and practices highly applicable to day-to-day programming challenges.[36] What Does Functional Programming Mean? Functional programming is an umbrella term that encompasses a number of language-level primitives and capabilities of which different languages provide different treatments. In Clojure, functional programming means: A preference for working with immutable values; this includes: The use of immutable data structures that satisfy simple abstractions, rather than mutable bags of state The treatment of functions as values themselves, enabling higher-order functions A preference for declarative processing of data over imperative control structures and iteration The natural incremental composition of functions, higher-order functions, and immutable data structures in order to solve complex problems by working with higher-level (or, right-level) abstractions These are all part of the foundation for many of the more advanced features of Clojure that you may have heard of—in particular, Clojure’s fantastic support for concurrency, parallelism, and more generally, providing defined semantics for the management of identities and changing state, which we’ll cover separately in Chapter 4

pages: 680 words: 157,865

Beautiful Architecture: Leading Thinkers Reveal the Hidden Beauty in Software Design by Diomidis Spinellis, Georgios Gousios

The success of object technology has largely followed from the marked improvements it brings—if applied properly as a method, not just through the use of an object-oriented programming language—to the reliability, extendibility, and reusability of the resulting programs. The functional programming approach predates object-oriented thinking, going back to the Lisp language available for almost 50 years. To those fortunate enough to have learned it early, functional programming will always remain like the memory of a first kiss: sweet, and the foretaste of even better experiences. Functional programming has made a comeback in recent years, with the introduction of new languages such as Scheme, Haskell, OCaml and F#, sophisticated type systems, and advanced language mechanisms such as monads. Functional programming even seems at times to be presented as an improvement over object-oriented techniques.

Using types as the basic modularization mechanism, as in object-oriented design, will elevate the level of abstraction. Levels of Modularity Assessing functional programming against criteria of modularity is legitimate since better modularization is one of the main arguments for the approach. We have seen the presentation’s comments on this issue, but here is a more general statement from one of the foundational papers of functional programming, by Hughes (1989), stating that with this approach: [Programs] can be modularized in new ways, and thereby greatly simplified. This is the key to functional programming’s power—it allows greatly improved modularization. It is also the goal for which functional programmers must strive—smaller and simpler and more general modules, glued together with the new glues we shall describe.

Modern functional languages showed the benefit of accepting higher-order functionals as regular program objects, and developed the associated type systems. This is the part of functional programming that has had the most direct effect on the development of mainstream approaches to programming; as will be seen below, the notion of agent, directly derived from these functional programming concepts, is a welcome addition to the original object-oriented framework. The fourth significant attraction of functional programming is lazy evaluation: the ability, in some functional languages such as Haskell, to describe a computation that is potentially infinite, with the understanding that any concrete execution of that computation will be finite.

pages: 226 words: 17,533

Programming Scala: tackle multicore complexity on the JVM by Venkat Subramaniam

You can quickly put to use the powerful capabilities of Scala, including sensible static typing, closures, immutable collections, and elegant pattern matching. Scala’s support for functional programming helps you to write concise and expressive code. Thanks to the higher level of abstraction, you can get more things done with fewer lines of code. The functional style will benefit both your single-threaded applications and your multithreaded applications. A number of functional programming languages exist. Erlang, for one, is a nice functional programming language. In fact, Scala’s concurrency model is very similar to that of Erlang. However, Scala has two significant advantages over Erlang.

This distinction has a far-reaching consequence. Because the language does not do more, you are able to do a lot more with it. It is truly extensible, and its library serves as a case study for that. 1.3 Functional Programming I’ve mentioned that Scala can be used as a functional programming language a couple of times already. I want to take a few pages to give you a little of the flavor of functional programming. Let’s start by contrasting it with the imperative style of Java programming. If we want to find the maximum temperature for a given day, we could write Java code like this: //Java code public static int findMax(List<Integer> temperatures) { int highTemperature = Integer.MIN_VALUE; for(int temperature : temperatures) { highTemperature = Math.max(highTemperature, temperature); } return highTemperature; } We created the mutable variable highTemperature and continually modified it in the loop.

When you have mutable variables, you have to ensure Download at Boykma.Com Report erratum Prepared exclusively for sam kaplan this copy is (P1.0 printing, June 2009) 19 F UNCTIONAL P ROGRAMMING you initialize them properly and are changing them in the right place to the right values. Functional programming is a declarative style in which you say what to do instead of how something should be done. You’ve used functional style if you’ve used XSLT, a rules engine, or ANTLR. We can rewrite the previous code in functional style with no mutable variables as follows: Download Introduction/FindMaxFunctional.scala def findMax(temperatures : List[Int]) = { temperatures.foldLeft(Integer.MIN_VALUE) { Math.max } } You are seeing an interplay of Scala conciseness and functional programming style in the previous code. That’s some dense code.

Pearls of Functional Algorithm Design by Richard Bird

Countdown was ﬁrst studied in an earlier pearl (Hutton, 2002) as an illustration of how to prove that functional programs meet their speciﬁcation. Hutton’s aim was not to derive the best possible algorithm, but to present one whose correctness proof required only simple induction. Essentially, Hutton’s proof dealt with the correctness of countdown2. References Bird, R. S. and Mu, S.-C. (2005). Countdown: a case study in origami programming. Journal of Functional Programming 15 (6), 679–702. Hutton, G. (2002). The Countdown problem. Journal of Functional Programming 12 (6), 609–16. 21 Hylomorphisms and nexuses Introduction It was Erik Meijer who coined the name hylomorphism to describe a computation that consists of a fold after an unfold.

These problems, some of which are completely new, are drawn from sources as diverse as games and puzzles, intriguing combinatorial tasks and more familiar algorithms in areas such as data compression and string matching. Each pearl starts with the statement of the problem expressed using the functional programming language Haskell, a powerful yet succinct language for capturing algorithmic ideas clearly and simply. The novel aspect of the book is that each solution is calculated from the problem statement by appealing to the laws of functional programming. Pearls of Functional Algorithm Design will appeal to the aspiring functional programmer, students and teachers interested in the principles of algorithm design, and anyone seeking to master the techniques of reasoning about programs in an equational style.

In LNCS 5133: Proceedings of the Ninth International Conference on the Mathematics of Program Construction, ed. P. Audebaud and C. Paulin-Mohring. pp. 92–109. Meijer, E. (1992). Calculating compilers. PhD thesis, Nijmegen University, The Netherlands. Meijer, E., Fokkinga, M. and Paterson, R. (1991). Functional programming with bananas, lenses, envelopes and barbed wire. Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture. New York, NY: Springer-Verlag, pp. 124–44. 22 Three ways of computing determinants Introduction The determinant, det(A), or |A|, of an n ×n matrix A = (aij ) can be deﬁned by the Leibniz formula |A| = sign (π) aj π(j ) π 1≤j ≤n The sum is taken over all permutations π of [1 .. n] and sign (π) = 1 for even permutations (those that have an even number of inversions), and −1 for odd ones.

pages: 214 words: 14,382

Monadic Design Patterns for the Web by L.G. Meredith

Note that all of those languages are either functional languages or object-functional languages, and that most proposals are either functional, object-functional, or heavily influenced by functional language design concepts. Advances in FP: monads, and the awkward squad Perhaps a chief reason for the popularity of functional programming language design is that the core of the functional model is inherently simple. The rules governing the execution of functional programs (the basis of an abstract evaluator) can be stated in half a page. In some sense, functional language design is a “path of least resistance” approach. A deeper reason for adopting functional language design is that the core model is compositional; that is, enriching the execution semantics amounts to the enrichment of the semantics’ components.

eBook <www.wowebook.com> 2.3 Core design patterns First, a little history: Haskell was the first programming language to popularize the notion of monad as a structuring technique for functional programming. It packaged this notion with several key ideas. One was to treat the core elements that make up a monad more or less directly without appeal to category theory – the branch of mathematics in which the notion originated. This is considerably easier to do in a functional programming language because you can think of the ambient language as a category; thus, the average programmer doesn’t need to refer to categories, in general, but only to the universe of programs that can be written in the language at hand.

This approach provides a much more elegant solution, allowing us to expand our notion of stateless to “just stateful enough” in a way that faithfully aligns with the semantics of functional programming languages, themselves. Offering just a single doubloon of the treasures that lie behind this basic enrichment, allow me to say something about the correspondence of this idea to games semantics. In the world of programming language semantics, one of the most successful paradigms for reasoning about the semantics of functional programming languages is games semantics, which carves up the world of computations into a few basic components: Player (which we know as client), Opponent (which we know as server), Question (which we have been calling request), and Answer (response).

pages: 423 words: 21,637

On Lisp: Advanced Techniques for Common Lisp by Paul Graham

The body is evaluated with the variables bound to the respective return values from the call: > (multiple-value-bind (int frac) (truncate 26.21875) (list int frac)) (26 0.21875) Finally, to return multiple values, we use the values operator: > (defun powers (x) (values x (sqrt x) (expt x 2))) POWERS > (multiple-value-bind (base root square) (powers 4) (list base root square)) (4 2.0 16) Functional programming is a good idea in general. It is a particularly good idea in Lisp, because Lisp has evolved to support it. Built-in operators like reverse and nreverse are meant to be used in this way. Other operators, like values and multiple-value-bind, have been provided specifically to make functional programming easier. 3.2 Imperative Outside-In The aims of functional programming may show more clearly when contrasted with those of the more common approach, imperative programming. A functional program tells you what it wants; an imperative program tells you what to do.

The second node, mods/n, can either look for more nouns, or return a parsing. Section 3.4 explained how writing programs in a functional style makes them easier to test: In a functional program, components can be tested individually. In Lisp, functions can be tested interactively, in the toplevel loop. Together these two principles allow interactive development: when we write functional programs in Lisp, we can test each piece as we write it. ATNs are so like functional programs--in this implementation, they macroexpand into functional programs--that the possibility of interactive development applies to them as well. We can test an ATN starting from any node, simply by giving its name as the first argument to with-parses: > (with-parses mods '(time arrow) (format t "Parsing: ~A~%" parse)) Parsing: (N-GROUP (ARROW TIME)) The next two networks have to be discussed together,because they are mutually recursive.

The character of Lisp functions has a similar influence on the structure of Lisp programs. Functional programming means writing programs which work by returning values instead of by performing side-effects. Side-effects include destructive changes to objects (e.g. by rplaca) and assignments to variables (e.g. by setq). If side-effects are few and localized, programs become easier to read, test, and debug. Lisp programs have not always been written in this style, but over time Lisp and functional programming have gradually become inseparable. An example will show how functional programming differs from what you might do in another language.

The Haskell Road to Logic, Maths and Programming by Kees Doets, Jan van Eijck, Jan Eijck

It is convenient to choose a programming language for this that permits implementations to remain as close as possible to the formal definitions. Such a language is the functional programming language Haskell [HT]. Haskell was named after the logician Haskell B. Curry. Curry, together with Alonzo Church, laid the foundations of functional computation in the era Before the Computer, around 1940. As a functional programming language, Haskell is a member of the Lisp family. Others family members are Scheme, ML, Occam, Clean. Haskell98 is intended as a standard for lazy functional programming. Lazy functional programming is a programming style where arguments are evaluated only when the value is actually needed.

Haskell emerged in the last decade as a standard for lazy functional programming, a programming style where arguments are evaluated only when the value is actually needed. Functional programming is a form of descriptive programming, very different from the style of programming that you find in prescriptive languages like C or Java. Haskell is based on a logical theory of computable functions called the lambda calculus. Lambda calculus is a formal language capable of expressing arbitrary computable functions. In combination with types it forms a compact way to denote on the one hand functional programs and on the other hand mathematical proofs.

In fact, sorts are just like the basic types in a functional programming language. Just as good naming conventions can make a program easier to understand, naming conventions can be helpful in mathematical writing. For instance: the letters n, m, k, . . . are often used for natural numbers, f, g, h, . . . usually indicate that functions are meant, etc. The interpretation of quantifiers in such a case requires that not one, but several domains are specified: one for every sort or type. Again, this is similar to providing explicit typing information in a functional program for easier human digestion. Exercise 2.50 That the sequence a0 , a1 , a2 , . . . ∈ R converges to a, i.e., that limn→∞ an = a, means that ∀δ > 0∃n∀m > n(|a − am | < δ).

pages: 1,201 words: 233,519

Coders at Work by Peter Seibel

I think in the States you can be more collaborative for a while until you zero in on your own research program. Seibel: Speaking of research and academics, functional programming is quite popular within the research community but I think a lot of people outside that community see functional programming as being driven by ideas that, while neat, can be very mathematical and divorced from day-to-day programming. Is that a fair characterization? Peyton Jones: I think it's about half fair. I characterize functional programming—that is, purely functional programming, where side effects are somehow really relegated to a world of their own—as a radical and elegant attack on the whole enterprise of writing programs.

He learned to program on a machine with no permanent storage and only 100 memory locations, and in college he worked on both writing high-level compilers for the school's big iron and building his own primitive computers out of parts he could afford on a student's budget. But he was drawn to functional programming by a professor's demonstration of how to build doubly linked lists without using mutation and the beauty of the idea of lazy evaluation. Peyton Jones saw the ideas of functional programming “as a radical and elegant attack on the whole enterprise of writing programs”: a way, rather than “just putting one more brick in the wall,” to “build a whole new wall.” In 2004 the Association for Computing Machinery elected him a Fellow, citing his “contributions to functional programming languages.” Among the topics we covered in this interview are why he thinks functional programming shows increasing promise of changing the way software is written, why Software Transactional Memory is a much better way of writing concurrent software than locks and condition variables, and why it is so difficult, even at a place like Microsoft Research, to do real studies of whether different programming languages make programmers more or less productive.

So my big-picture justification for why it's worth some people, like me, spending a lot of time on purely functional programming, is that it shows promise. I don't want to claim that it's exactly the way that everyone will be writing programs in the future, but it shows promise. And actually I'll make the case that it shows increasing promise. I see it as, when the limestone of imperative programming is worn away, the granite of functional programming will be observed. That said, I think purely functional programming started quite geeky and academic and mathematical. The story of the last, really, 20 years—all the time I've been working on it—has been a story of becoming increasingly practical, focusing not just on abstract ideas but trying to overcome, one by one, the obstacles that prevent real-life programmers using functional programming languages for real applications.

pages: 496 words: 70,263

Erlang Programming by Francesco Cesarini

The tracing and logging facilities also give you a clear picture of how the integration is working, enabling you to debug and tune systems much more effectively. Erlang and Functional Programming The recent success of Erlang is a success for functional programming, too, because it uses functional programming principles without making a big fuss about it: they are simply the right foundation on which to build a language with concurrency designed in from the start. One of the prevalent myths in the community in the mid-1980s was that functional programming languages would be the only languages capable of working on the general-purpose parallel machines that were “just around the corner.”

The Erlang language—and in particular, its many libraries—offer more to help the programmer be as effective as possible. The various language features covered in this chapter, many of them derived from functional programming languages, are tools that will improve the productivity of a working Erlang programmer. Functional Programming for Real Erlang is a functional programming language—among other things—but what does that really mean? Prominent in Erlang are function definitions, but that’s also the case in Pascal, C, and many other languages. What makes a true functional programming language is the fact that functions can be handled just like any other sort of data. Functional data types in Erlang are called funs.

Test-driven development (TDD) has been associated with agile programming, but it would be wrong to identify the two. An informal test-driven approach has characterized functional programming since the early LISP systems: most functional programming systems have at their top level a read-evaluate-print loop, which encourages a test- or example-based approach. Erlang comes out of that tradition, with its roots in functional programming and Prolog, and the examples of interactions in the Erlang shell show this informal test-driven approach in practice. Test-driven development is not confined to the single-person project.

pages: 292 words: 62,575

97 Things Every Programmer Should Know by Kevlin Henney

(You Are Not the User) Feathers, The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design Fit (Framework for Integrated Test), When Programmers and Testers Collaborate floating-point numbers, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real formatting errors, Prevent Errors Fortran, Don't Just Learn the Language, Understand Its Culture, Floating-Point Numbers Aren't Real, Know Well More Than Two Programming Languages Fowler, Interprocess Communication Affects Application Response Time frameworks, Choose Your Tools with Care, Continuous Learning getting to know, Continuous Learning free software, Put Everything Under Version Control Freeman, Code Layout Matters, Code Layout Matters, Code Layout Matters, One Binary, One Binary, One Binary Code Layout Matters, Code Layout Matters, Code Layout Matters, Code Layout Matters One Binary, One Binary, One Binary, One Binary functional programming, Apply Functional Programming Principles, Don't Just Learn the Language, Understand Its Culture, Know Well More Than Two Programming Languages G Gagnat, Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow Garson, Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles Git, Put Everything Under Version Control Goodliffe, Don't Ignore That Error!

* * * [1] http://martinfowler.com/bliki/TechnicalDebtQuadrant.html Chapter 2. Apply Functional Programming Principles Edward Garson FUNCTIONAL PROGRAMMING has recently enjoyed renewed interest from the mainstream programming community. Part of the reason is because emergent properties of the functional paradigm are well positioned to address the challenges posed by our industry's shift toward multicore. However, while that is certainly an important application, it is not the reason this piece admonishes you to know thy functional programming. Mastery of the functional programming paradigm can greatly improve the quality of the code you write in other contexts.

(You Are Not the User) Feathers, The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design, The Golden Rule of API Design Fit (Framework for Integrated Test), When Programmers and Testers Collaborate floating-point numbers, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real formatting errors, Prevent Errors Fortran, Don't Just Learn the Language, Understand Its Culture, Floating-Point Numbers Aren't Real, Know Well More Than Two Programming Languages Fowler, Interprocess Communication Affects Application Response Time frameworks, Choose Your Tools with Care, Continuous Learning getting to know, Continuous Learning free software, Put Everything Under Version Control Freeman, Code Layout Matters, Code Layout Matters, Code Layout Matters, One Binary, One Binary, One Binary Code Layout Matters, Code Layout Matters, Code Layout Matters, Code Layout Matters One Binary, One Binary, One Binary, One Binary functional programming, Apply Functional Programming Principles, Don't Just Learn the Language, Understand Its Culture, Know Well More Than Two Programming Languages G Gagnat, Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow, Pair Program and Feel the Flow Garson, Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles, Apply Functional Programming Principles Git, Put Everything Under Version Control Goodliffe, Don't Ignore That Error!, Don't Ignore That Error!, Don't Ignore That Error!, Improve Code by Removing It, Improve Code by Removing It, Improve Code by Removing It, You Gotta Care About the Code, You Gotta Care About the Code, You Gotta Care About the Code Don't Ignore That Error!, Don't Ignore That Error!, Don't Ignore That Error!, Don't Ignore That Error! Improve Code by Removing It, Improve Code by Removing It, Improve Code by Removing It, Improve Code by Removing It You Gotta Care About the Code, You Gotta Care About the Code, You Gotta Care About the Code, You Gotta Care About the Code Google, Fulfill Your Ambitions with Open Source, Make the Invisible More Visible Gregory, When Programmers and Testers Collaborate, When Programmers and Testers Collaborate, When Programmers and Testers Collaborate When Programmers and Testers Collaborate, When Programmers and Testers Collaborate, When Programmers and Testers Collaborate, When Programmers and Testers Collaborate Guest, Learn to Say, "Hello, World" Learn to Say, Learn to Say, "Hello, World" guru myth, The Guru Myth, The Guru Myth, The Guru Myth H hard work, Hard Work Does Not Pay Off, Hard Work Does Not Pay Off, Hard Work Does Not Pay Off Henney, Comment Only What the Code Cannot Say, Comment Only What the Code Cannot Say, Comment Only What the Code Cannot Say, Test for Required Behavior, Not Incidental Behavior, Test Precisely and Concretely, Test Precisely and Concretely, Test Precisely and Concretely Comment Only What the Code Cannot Say, Comment Only What the Code Cannot Say, Comment Only What the Code Cannot Say, Comment Only What the Code Cannot Say Test for Required Behavior, Test for Required Behavior, Not Incidental Behavior Test Precisely and Concretely, Test Precisely and Concretely, Test Precisely and Concretely, Test Precisely and Concretely Hohpe, Convenience Is Not an -ility, Convenience Is Not an -ility, Convenience Is Not an -ility Convenience Is Not an -ility, Convenience Is Not an -ility, Convenience Is Not an -ility, Convenience Is Not an -ility Holmes, You Gotta Care About the Code Hopper, Don't Rely on "Magic Happens Here" Horstmann, Step Back and Automate, Automate, Automate Step Back and Automate, Step Back and Automate, Automate, Automate Hufnagel, News of the Weird: Testers Are Your Friends, News of the Weird: Testers Are Your Friends, News of the Weird: Testers Are Your Friends, Put the Mouse Down and Step Away from the Keyboard, Put the Mouse Down and Step Away from the Keyboard, Put the Mouse Down and Step Away from the Keyboard News of the Weird: Testers Are Your Friends, News of the Weird: Testers Are Your Friends, News of the Weird: Testers Are Your Friends, News of the Weird: Testers Are Your Friends Put the Mouse Down and Step Away from the Keyboard, Put the Mouse Down and Step Away from the Keyboard, Put the Mouse Down and Step Away from the Keyboard, Put the Mouse Down and Step Away from the Keyboard Hunt, Don't Just Learn the Language, Understand Its Culture, Don't Repeat Yourself I IDEs, Step Back and Automate, Automate, Automate, The Unix Tools Are Your Friends automation, Step Back and Automate, Automate, Automate Unix tools, The Unix Tools Are Your Friends IDEs (Integrated Development Environments), Know How to Use Command-Line Tools, Know Your IDE IEEE floating-point numbers, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real, Floating-Point Numbers Aren't Real incremental changes, Before You Refactor installation process, Deploy Early and Often, Deploy Early and Often, Deploy Early and Often installing software, Install Me, Install Me, Install Me interfaces, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly interim solutions, The Longevity of Interim Solutions, The Longevity of Interim Solutions, The Longevity of Interim Solutions internal DSLs, Domain-Specific Languages interprocess communication, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time invisibility, Make the Invisible More Visible, Make the Invisible More Visible, Make the Invisible More Visible J Jackson, Your Customers Do Not Mean What They Say, Your Customers Do Not Mean What They Say, Your Customers Do Not Mean What They Say Your Customers Do Not Mean What They Say, Your Customers Do Not Mean What They Say, Your Customers Do Not Mean What They Say, Your Customers Do Not Mean What They Say Jagger, Do Lots of Deliberate Practice, Do Lots of Deliberate Practice, Do Lots of Deliberate Practice, Make the Invisible More Visible, Make the Invisible More Visible, Make the Invisible More Visible Do Lots of Deliberate Practice, Do Lots of Deliberate Practice, Do Lots of Deliberate Practice, Do Lots of Deliberate Practice Make the Invisible More Visible, Make the Invisible More Visible, Make the Invisible More Visible, Make the Invisible More Visible Java, Distinguish Business Exceptions from Technical, Encapsulate Behavior, Not Just State, The Golden Rule of API Design, Know Your IDE, Test for Required Behavior, Not Incidental Behavior, Write Small Functions Using Examples K Karlsson, Code Reviews, Code Reviews, Code Reviews Code Reviews, Code Reviews, Code Reviews, Code Reviews keeping a sustainable pace, Hard Work Does Not Pay Off, Hard Work Does Not Pay Off, Hard Work Does Not Pay Off Kelly, Check Your Code First Before Looking to Blame Others, Check Your Code First Before Looking to Blame Others, Check Your Code First Before Looking to Blame Others, Two Wrongs Can Make a Right (and Are Difficult to Fix), Two Wrongs Can Make a Right (and Are Difficult to Fix), Two Wrongs Can Make a Right (and Are Difficult to Fix) Check Your Code First Before Looking to Blame Others, Check Your Code First Before Looking to Blame Others, Check Your Code First Before Looking to Blame Others, Check Your Code First Before Looking to Blame Others Two Wrongs Can Make a Right (and Are Difficult to Fix), Two Wrongs Can Make a Right (and Are Difficult to Fix), Two Wrongs Can Make a Right (and Are Difficult to Fix), Two Wrongs Can Make a Right (and Are Difficult to Fix) Klumpp, Two Wrongs Can Make a Right (and Are Difficult to Fix) L Landre, Encapsulate Behavior, Not Just State Encapsulate Behavior, Encapsulate Behavior, Not Just State languages, Don't Just Learn the Language, Understand Its Culture, Don't Just Learn the Language, Understand Its Culture, Don't Just Learn the Language, Understand Its Culture layout of code, Code Layout Matters, Code Layout Matters, Code Layout Matters learning, Continuous Learning Lee, Learn to Say, "Hello, World" Lewis, Don't Be Afraid to Break Things, Don't Be Afraid to Break Things, Don't Be Afraid to Break Things Don't Be Afraid to Break Things, Don't Be Afraid to Break Things, Don't Be Afraid to Break Things, Don't Be Afraid to Break Things libraries, Choose Your Tools with Care Lindner, Let Your Project Speak for Itself, Let Your Project Speak for Itself, Let Your Project Speak for Itself Let Your Project Speak for Itself, Let Your Project Speak for Itself, Let Your Project Speak for Itself, Let Your Project Speak for Itself LISP, Distinguish Business Exceptions from Technical logging, Verbose Logging Will Disturb Your Sleep M Marquardt, Learn Foreign Languages, Learn Foreign Languages, Learn Foreign Languages, The Longevity of Interim Solutions, The Longevity of Interim Solutions, The Longevity of Interim Solutions Learn Foreign Languages, Learn Foreign Languages, Learn Foreign Languages, Learn Foreign Languages The Longevity of Interim Solutions, The Longevity of Interim Solutions, The Longevity of Interim Solutions, The Longevity of Interim Solutions Martin, The Boy Scout Rule, The Boy Scout Rule, The Boy Scout Rule, The Boy Scout Rule, The Professional Programmer, The Professional Programmer, The Professional Programmer, The Single Responsibility Principle, The Single Responsibility Principle, The Single Responsibility Principle The Boy Scout Rule, The Boy Scout Rule, The Boy Scout Rule, The Boy Scout Rule, The Boy Scout Rule The Professional Programmer, The Professional Programmer, The Professional Programmer, The Professional Programmer The Single Responsibility Principle, The Single Responsibility Principle, The Single Responsibility Principle, The Single Responsibility Principle mentors, Continuous Learning Mercurial, Put Everything Under Version Control Meszaros, Write Tests for People, Write Tests for People, Write Tests for People Write Tests for People, Write Tests for People, Write Tests for People, Write Tests for People Metaphors We Live By, Read the Humanities Meyers, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly, Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly Miller, Start from Yes, Start from Yes, Start from Yes Start from Yes, Start from Yes, Start from Yes, Start from Yes monitoring, Verbose Logging Will Disturb Your Sleep, Verbose Logging Will Disturb Your Sleep, Verbose Logging Will Disturb Your Sleep Monson-Haefel, Fulfill Your Ambitions with Open Source, Fulfill Your Ambitions with Open Source, Fulfill Your Ambitions with Open Source Fulfill Your Ambitions with Open Source, Fulfill Your Ambitions with Open Source, Fulfill Your Ambitions with Open Source, Fulfill Your Ambitions with Open Source multithreaded problems, Resist the Temptation of the Singleton Pattern, Resist the Temptation of the Singleton Pattern, Resist the Temptation of the Singleton Pattern singletons and, Resist the Temptation of the Singleton Pattern, Resist the Temptation of the Singleton Pattern, Resist the Temptation of the Singleton Pattern MySQL, Large, Interconnected Data Belongs to a Database N Nilsson, Thinking in States, Thinking in States, Thinking in States Thinking in States, Thinking in States, Thinking in States, Thinking in States Norås, Don't Just Learn the Language, Understand Its Culture Don't Just Learn the Language, Don't Just Learn the Language, Understand Its Culture North, Code in the Language of the Domain, Code in the Language of the Domain, Code in the Language of the Domain Code in the Language of the Domain, Code in the Language of the Domain, Code in the Language of the Domain, Code in the Language of the Domain Norvig, Do Lots of Deliberate Practice O Ølmheim, Beauty Is in Simplicity, Beauty Is in Simplicity, Beauty Is in Simplicity Beauty Is in Simplicity, Beauty Is in Simplicity, Beauty Is in Simplicity, Beauty Is in Simplicity open source, Fulfill Your Ambitions with Open Source, Large, Interconnected Data Belongs to a Database, Read Code P pair programming, Pair Program and Feel the Flow, Two Heads Are Often Better Than One parallelism, Message Passing Leads to Better Scalability in Parallel Systems, Message Passing Leads to Better Scalability in Parallel Systems, Message Passing Leads to Better Scalability in Parallel Systems Pascal, Floating-Point Numbers Aren't Real, Know Well More Than Two Programming Languages Patterns of Enterprise Application Architecture, Interprocess Communication Affects Application Response Time Pepperdine, The Road to Performance Is Littered with Dirty Code Bombs, The Road to Performance Is Littered with Dirty Code Bombs, The Road to Performance Is Littered with Dirty Code Bombs, WET Dilutes Performance Bottlenecks, WET Dilutes Performance Bottlenecks, WET Dilutes Performance Bottlenecks The Road to Performance Is Littered with Dirty Code Bombs, The Road to Performance Is Littered with Dirty Code Bombs, The Road to Performance Is Littered with Dirty Code Bombs, The Road to Performance Is Littered with Dirty Code Bombs WET Dilutes Performance Bottlenecks, WET Dilutes Performance Bottlenecks, WET Dilutes Performance Bottlenecks, WET Dilutes Performance Bottlenecks performance, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time management, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time Philosophical Investigations, Read the Humanities Plato, Beauty Is in Simplicity polymorphism, Missing Opportunities for Polymorphism, Missing Opportunities for Polymorphism, Missing Opportunities for Polymorphism Poppendieck, Do Lots of Deliberate Practice PostgreSQL, Large, Interconnected Data Belongs to a Database process bottlenecks, Code Reviews professional programmers, The Professional Programmer, The Professional Programmer, The Professional Programmer profiling tool, Use the Right Algorithm and Data Structure project management, Learn to Estimate Prolog, Know Well More Than Two Programming Languages R RDBMS systems, Large, Interconnected Data Belongs to a Database, Large, Interconnected Data Belongs to a Database, Large, Interconnected Data Belongs to a Database readability of code, Beauty Is in Simplicity, Convenience Is Not an -ility, Domain-Specific Languages, Prefer Domain-Specific Types to Primitive Types Reeves, Testing Is the Engineering Rigor of Software Development refactoring code, Before You Refactor reinventing the wheel, Reinvent the Wheel Often removing code, Improve Code by Removing It, Simplicity Comes from Reduction repetition, Do Lots of Deliberate Practice, Don't Repeat Yourself practice, Do Lots of Deliberate Practice process, Don't Repeat Yourself repetitive tasks, Step Back and Automate, Automate, Automate response time, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time, Interprocess Communication Affects Application Response Time return code, Don't Ignore That Error!

pages: 931 words: 79,142

Concepts, Techniques, and Models of Computer Programming by Peter Van-Roy, Seif Haridi

For example: fun {One} 1 end fun {Two} 2 end try {One}={Two} catch failure(...) then {Browse caughtFailure} end The pattern failure(...) catches any record whose label is failure. 2.8 Advanced topics This section gives additional information for deeper understanding of the declarative model, its trade-oﬀs, and possible variations. 2.8.1 Functional programming languages Functional programming consists in deﬁning functions on complete values, where the functions are true functions in the mathematical sense. A language in which this is the only possible way to calculate is called a pure functional language. Let us examine how the declarative model relates to pure functional programming. For further reading on the history, formal foundations, and motivations for functional programming, we recommend the survey article by Hudak [96]. 2.8 Advanced topics 97 The λ calculus Pure functional languages are based on a formalism called the λ calculus.

Adding a concept to a computation model introduces new forms of expression, making some programs simpler, but it also makes reasoning about programs harder. For example, by adding explicit state (mutable variables) to a functional programming model we can express the full range of object-oriented programming techniques. However, reasoning about object-oriented programs is harder than reasoning about functional programs. Functional programming is about calculating values with mathematical functions. Neither the values nor the functions change over time. Explicit state is one way to model things that change over time: it provides a container whose content can be updated.

With these restrictions, the model no longer needs unbound variables. The declarative model with these restrictions is called the (strict) functional model. This model is close to well-known functional programming languages such as Scheme and Standard ML. The full range of higher-order programming techniques is pos- 98 Declarative Computation Model sible. Pattern matching is possible using the case statement. Varieties of functional programming Let us explore some variations on the theme of functional programming: The functional model of this chapter is dynamically typed like Scheme. Many functional languages are statically typed. Section 2.8.3 explains the diﬀerences between the two approaches.

Think OCaml by Nicholas Monje, Allen Downey

By this standard, OCaml does 7 about as well as possible. 1.7 Functional, as opposed to...? Functional Programming is a programming paradigm where the function is a first-class citizen. Now, this is of course a silly definition, but it’s the best we can really do for now. Another popular programming paradigm is Object-Oriented. Languages that are object-oriented, such as C++ and Python, focus rather on having “objects” and changing them. “Object” is really kind of a blanket term for all kinds of different, often custom, ways of storing data. OCaml is mostly a functional programming language. However, OCaml has support for some level of object-oriented programming, unlike it’s predecessor Caml.

But references aren’t really any more useful than variables unless you have a more meaningful way to modify them. The most accessible method of modifying references is using loops. 10.2 Looping In functional programming, we don’t really like loops. We’d much rather use recursion, and you can usually use recursion instead. However, looping can occasionally be very useful, even in otherwise mostly-functional programs. There are two primary forms of loops: the for loop and the while loop. Technically speaking, a for loop is just a particular case of a very useful while loop, but it’s also a little easier to use and a little harder to mess up, so we’ll start with that. 10.2.1 For loop Let’s look at the problem of adding itegers from 1 to n again.

3. If I leave my house at 6:52 am and run 1 mile at an easy pace (8:15 per mile), then 3 miles at tempo (7:12 per mile) and 1 mile at easy pace again, what time do I get home for breakfast? 20 Chapter 2. Variables and Expressions Chapter 3 Functions 3.1 Function calls In the context of functional programming, a function is a named expression that performs a computation. When you define a function, you specify the name and the expression. Later, you can “call” the function by name. We have already seen one example of a function call: # float_of_int 32;; - : float = 32. The name of the function is float_of_int.

pages: 893 words: 199,542

Structure and interpretation of computer programs by Harold Abelson, Gerald Jay Sussman, Julie Sussman

Moreover, no simple model with “nice” mathematical properties can be an adequate framework for dealing with objects and assignment in programming languages. So long as we do not use assignments, two evaluations of the same procedure with the same arguments will produce the same result, so that procedures can be viewed as computing mathematical functions. Programming without any use of assignments, as we did throughout the first two chapters of this book, is accordingly known as functional programming. To understand how assignment complicates matters, consider a simplified version of the make-withdraw procedure of section 3.1.1 that does not bother to check for an insufficient amount: (define (make-simplified-withdraw balance) (lambda (amount) (set!

We do not, for example, ordinarily regard a rational number as a changeable object with identity, such that we could change the numerator and still have “the same” rational number. Pitfalls of imperative programming In contrast to functional programming, programming that makes extensive use of assignment is known as imperative programming. In addition to raising complications about computational models, programs written in imperative style are susceptible to bugs that cannot occur in functional programs. For example, recall the iterative factorial program from section 1.2.1: (define (factorial n) (define (iter product counter) (if (> counter n) product (iter (* counter product) (+ counter 1)))) (iter 1 1)) Instead of passing arguments in the internal iterative loop, we could adopt a more imperative style by using explicit assignment to update the values of the variables product and counter: (define (factorial n) (let ((product 1) (counter 1)) (define (iter) (if (> counter n) product (begin (set!

Instead, ML includes a type-inferencing mechanism that uses information in the environment to deduce the data types for newly defined procedures. 73 Similarly in physics, when we observe a moving particle, we say that the position (state) of the particle is changing. However, from the perspective of the particle's world line in space-time there is no change involved. 74 John Backus, the inventor of Fortran, gave high visibility to functional programming when he was awarded the ACM Turing award in 1978. His acceptance speech (Backus 1978) strongly advocated the functional approach. A good overview of functional programming is given in Henderson 1980 and in Darlington, Henderson, and Turner 1982. 75 Observe that, for any two streams, there is in general more than one acceptable order of interleaving. Thus, technically, “merge” is a relation rather than a function – the answer is not a deterministic function of the inputs.

pages: 309 words: 65,118

Ruby by example: concepts and code by Kevin C. Baird

Exponentiation in Ruby Returning nil when a method’s operation is not possible More recursion and exit conditions Modules and Inheritance Hash.merge Class Variables Array.detect (“find first”) Subtracting Hashes Exiting the entire script with fail begin—rescue—end Downloading with open-uri Parsing XML files with regular expressions Writing to YAML files with YAML.dump Reading from YAML files with YAML.load It’s almost as if this chapter weren’t really about numbers—we covered a large amount of generically useful information, especially Modules, Class Variables, and external data storage and retrieval using either XML or YAML (or both). We’ve done a bit of functional programming already in the last two chapters, but we’ll get into the deep lambda magic in Chapter 6. 98 C ha pt er 5 6 FUNCTIONALISM WITH BLOCKS AND PROCS Ruby has two main ancestors: Smalltalk and Lisp.1 From Smalltalk, Ruby gets its heavy object orientation, which we’ve explored in some depth up to this point. From Lisp it derives several ideas from functional programming, which is a very mathematically inclined approach to programming with a few notable characteristics. First, variables tend to be defined once, without having their values changed later on.

Creating Procs with lambda Using Procs as arguments to methods Using blocks as arguments to methods, including your own new methods Using Procs as first-class functions The inspect method Nesting lambdas within other lambdas Proc.new The yield method I have a confession to make. I love object orientation for many programming tasks, but this chapter about Ruby’s functional heritage was the most fun to write so far. Functional programming has been respected in academia for decades, and it is starting to get some well-deserved attention from folks in the computer programming industry and others who are just curious about what it can do. Now that we know some functional programming techniques, let’s put them to use and even try to optimize them, which is the subject of our next chapter. Fun c ti on al is m wit h B loc ks an d Pr ocs 119 7 USING, OPTIMIZING, AND TESTING FUNCTIONAL TECHNIQUES This chapter shows some recursive and other functional solutions to simple problems, as well as some ways we can test and improve these solutions.

Chapter 3: Programmer Utilities This chapter contains tools that are useful for developers in the form of library files intended to be used by other programs. Chapter 4: Text Manipulation This chapter focuses on processing text. Chapter 5: Number Utilities This chapter focuses on primarily numeric data, including pure math and moving into recursion. Chapter 6: Functionalism with Blocks and Procs This chapter puts a heavy emphasis on functional programming, hinted at in earlier chapters. Chapter 7: Using, Optimizing, and Testing Functional Techniques This chapter details testing, profiling, and optimizing your programs. Chapter 8: HTML and XML Tools This chapter has a subset of text processing specifically meant for markup, like HTML and XML.

pages: 404 words: 43,442

The Art of R Programming by Norman Matloff

This is nice, since it means that you, as a user, have fewer commands to remember! Functional Programming As is typical in functional programming languages, a common theme in R programming is avoidance of explicit iteration. Instead of coding loops, you exploit R’s functional features, which let you express iterative behavior implicitly. This can lead to code that executes much more efﬁciently, and it can make a huge timing difference when running R on large data sets. Introduction xxi As you will see, the functional programming nature of the R language offers many advantages: • Clearer, more compact code • Potentially much faster execution speed • Less debugging, because the code is simpler • Easier transition to parallel programming Whom Is This Book For?

BRIEF CONTENTS Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix Chapter 1: Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Chapter 2: Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Chapter 3: Matrices and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Chapter 4: Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Chapter 5: Data Frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101 Chapter 6: Factors and Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121 Chapter 7: R Programming Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .139 Chapter 8: Doing Math and Simulations in R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .189 Chapter 9: Object-Oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207 Chapter 10: Input/Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231 Chapter 11: String Manipulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251 Chapter 12: Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .261 Chapter 13: Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285 Chapter 14: Performance Enhancement: Speed and Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .305 Chapter 15: Interfacing R to Other Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .323 Chapter 16: Parallel R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .333 Appendix A: Installing R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353 Appendix B: Installing and Using Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355 CONTENTS IN DETAIL ACKNOWLEDGMENTS xvii INTRODUCTION xix Why Use R for Your Statistical Work? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Object-Oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Functional Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Whom Is This Book For? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . My Own Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 GETTING STARTED 1.1 1.2 1.3 1.4 1.5 1.6 1.7 How to Run R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.1 Interactive Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.2 Batch Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3 Using R Debugging Facilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.1 Single-Stepping with the debug() and browser() Functions . . . . . . . . . . . 13.3.2 Using Browser Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.3 Setting Breakpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.4 Tracking with the trace() Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.5 Performing Checks After a Crash with the traceback() and debugger() Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.6 Extended Example: Two Full Debugging Sessions . . . . . . . . . . . . . . . . . . 13.4 Moving Up in the World: More Convenient Debugging Tools . . . . . . . . . . . . . . . . . . . 285 285 286 286 287 287 288 288 289 289 291 291 292 300 Contents in Detail xiii 13.5 Ensuring Consistency in Debugging Simulation Code . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 13.6 Syntax and Runtime Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 13.7 Running GDB on R Itself . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 14 PERFORMANCE ENHANCEMENT: SPEED AND MEMORY 305 14.1 Writing Fast R Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2 The Dreaded for Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.1 Vectorization for Speedup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.2 Extended Example: Achieving Better Speed in a Monte Carlo Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.3 Extended Example: Generating a Powers Matrix . . . . . . . . . . . . . . . . . . . 14.3 Functional Programming and Memory Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.1 Vector Assignment Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.2 Copy-on-Change Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.3 Extended Example: Avoiding Memory Copy . . . . . . . . . . . . . . . . . . . . . . 14.4 Using Rprof() to Find Slow Spots in Your Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.1 Monitoring with Rprof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.2 How Rprof() Works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5 Byte Code Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Oh No, the Data Doesn’t Fit into Memory!

pages: 1,387 words: 202,295

Structure and Interpretation of Computer Programs, Second Edition by Harold Abelson, Gerald Jay Sussman, Julie Sussman

Moreover, no simple model with “nice” mathematical properties can be an adequate framework for dealing with objects and assignment in programming languages. So long as we do not use assignments, two evaluations of the same procedure with the same arguments will produce the same result, so that procedures can be viewed as computing mathematical functions. Programming without any use of assignments, as we did throughout the first two chapters of this book, is accordingly known as functional programming. To understand how assignment complicates matters, consider a simplified version of the make-withdraw procedure of 3.1.1 that does not bother to check for an insufficient amount: (define (make-simplified-withdraw balance) (lambda (amount) (set!

We do not, for example, ordinarily regard a rational number as a changeable object with identity, such that we could change the numerator and still have “the same” rational number. Pitfalls of imperative programming In contrast to functional programming, programming that makes extensive use of assignment is known as imperative programming. In addition to raising complications about computational models, programs written in imperative style are susceptible to bugs that cannot occur in functional programs. For example, recall the iterative factorial program from 1.2.1: (define (factorial n) (define (iter product counter) (if (> counter n) product (iter (* counter product) (+ counter 1)))) (iter 1 1)) Instead of passing arguments in the internal iterative loop, we could adopt a more imperative style by using explicit assignment to update the values of the variables product and counter: (define (factorial n) (let ((product 1) (counter 1)) (define (iter) (if (> counter n) product (begin (set!

Instead, ML includes a type-inferencing mechanism that uses information in the environment to deduce the data types for newly defined procedures. 201 Similarly in physics, when we observe a moving particle, we say that the position (state) of the particle is changing. However, from the perspective of the particle’s world line in space-time there is no change involved. 202 John Backus, the inventor of Fortran, gave high visibility to functional programming when he was awarded the ACM Turing award in 1978. His acceptance speech (Backus 1978) strongly advocated the functional approach. A good overview of functional programming is given in Henderson 1980 and in Darlington et al. 1982. 203 Observe that, for any two streams, there is in general more than one acceptable order of interleaving. Thus, technically, “merge” is a relation rather than a function—the answer is not a deterministic function of the inputs.

pages: 754 words: 48,930

Programming in Scala by Martin Odersky, Lex Spoon, Bill Venners

But it can apply its strengths even more when used for building large systems and frameworks of reusable components. Technically, Scala is a blend of object-oriented and functional programming concepts in a statically typed language. The fusion of object-oriented and functional programming shows up in many different aspects of Scala; it is probably more pervasive than in any other widely used language. The two programming styles have complementary strengths when it comes to scalability. Scala’s functional programming constructs make it easy to build interesting things quickly from simple parts. Its object-oriented constructs make it easy to structure larger systems and to adapt them to new demands.

Scala is functional In addition to being a pure object-oriented language, Scala is also a fullblown functional language. The ideas of functional programming are older than (electronic) computers. Their foundation was laid in Alonzo Church’s lambda calculus, which he developed in the 1930s. The first functional programming language was Lisp, which dates from the late 50s. Other popular 7 Kay, “The Early History of Smalltalk.” [Kay96] Cover · Overview · Contents · Discuss · Suggest · Glossary · Index 46 Section 1.2 Chapter 1 · A Scalable Language functional languages are Scheme, SML, Erlang, Haskell, OCaml, and F#. For a long time, functional programming has been a bit on the sidelines, popular in academia, but not that widely used in industry.

Scalability is influenced by many factors, ranging from syntax details to component abstraction constructs. If we were forced to name just one aspect of Scala that helps scalability, though, we’d pick its combination of object-oriented and functional programming (well, we cheated, that’s really two aspects, but they are intertwined). Scala goes further than all other well-known languages in fusing objectoriented and functional programming into a uniform language design. For instance, where other languages might have objects and functions as two different concepts, in Scala a function value is an object. Function types are classes that can be inherited by subclasses.

pages: 1,076 words: 67,364

Haskell Programming: From First Principles by Christopher Allen, Julie Moronuki

Lambda calculus is your foundation, because Haskell is a pure functional programming language. 1.2 What is functional programming? Functional programming is a computer programming paradigm that relies on functions modeled on mathematical functions. The essence of functional programming is that programs are a combination of expressions. Expressions include concrete values, variables, and also functions. Functions have a more speciﬁc deﬁnition: they are expressions that are applied to an argument or input, and once applied, can be reduced or evaluated. In Haskell, and in functional programming more generally, functions are ﬁrst-class: they can be used as values or passed as arguments, or inputs, to yet more functions.

Why Haskell If you are new to programming entirely, Haskell is a great ﬁrst language. You may have noticed the trend of “Functional Programming in [Imperative Language]” books and tutorials and learning Haskell gets right to the heart of what functional programming is. Languages such as Java are gradually adopting functional concepts, but most such languages were not designed to be functional languages. We would not encourage you to learn Haskell as an only language, but because Haskell is a pure functional language, it is a fertile environment for mastering functional programming. That way of thinking and problem solving is useful, no matter what other languages you might know or learn.

In Haskell, and in functional programming more generally, functions are ﬁrst-class: they can be used as values or passed as arguments, or inputs, to yet more functions. We’ll deﬁne these terms more carefully as we progress through the chapter. Functional programming languages are all based on the lambda calculus. Some languages in this general category incorporate features into the language that aren’t translatable into lambda expressions. Haskell is a pure functional language, because it does not. We’ll address this notion of purity more later in the book, but it isn’t a judgment of the moral worth of other languages. The word purity in functional programming is sometimes also used to mean what is more properly called referential transparency. Referential CHAPTER 1.

pages: 519 words: 102,669

Programming Collective Intelligence by Toby Segaran

To activate frequency scoring in your results, change the weights line in getscoredlist to read: weights=[(1.0,self.frequencyscore(rows))] Now you can try another search and see how well this works as a scoring metric: >>reload(searchengine) >> e=searchengine.searcher('searchindex.db') >> e.query('functional programming') 1.000000 http://kiwitobes.com/wiki/Functional_programming.html 0.262476 http://kiwitobes.com/wiki/Categorical_list_of_programming_languages.html 0.062310 http://kiwitobes.com/wiki/Programming_language.html 0.043976 http://kiwitobes.com/wiki/Lisp_programming_language.html 0.036394 http://kiwitobes.com/wiki/Programming_paradigm.html ... This returns the page on "Functional programming" in first place, followed by several other relevant pages. Notice that "Functional programming" scored four times better than the result directly below it.

To see what the results look like using only the location score, change the weights line to this: weights=[(1.0,self.locationscore(rows))] Now try the query again in your interpreter: >>reload(searchengine) >> e=searchengine.searcher('searchindex.db') >> e.query('functional programming') You'll notice that "Functional programming" is still the winner, but the other top results are now examples of functional programming languages. The previous search returned results in which the words were mentioned several times, but these tended to be discussions about programming languages in general. With this search, however, the presence of the words in the opening sentence (e.g., "Haskell is a standardized pure functional programming language") gave them a much higher score. It's important to realize that neither one of the metrics shown so far is better in every case.

Add this method to the searcher class: def pagerankscore(self,rows): pageranks=dict([(row[0],self.con.execute('select score from pagerank where urlid=%d' % row[0]).fetchone( )[0]) for row in rows]) maxrank=max(pageranks.values( )) normalizedscores=dict([(u,float(l)/maxrank) for (u,l) in pageranks.items( )]) return normalizedscores Once again, you should modify the weights list to include PageRank. For example, try: weights=[(1.0,self.locationscore(rows)), (1.0,self.frequencyscore(rows)), (1.0,self.pagerankscore(rows))] The results for your searches will take into account content and ranking scores. The results for "Functional programming" now look even better: 2.318146 http://kiwitobes.com/wiki/Functional_programming.html 1.074506 http://kiwitobes.com/wiki/Programming_language.html 0.517633 http://kiwitobes.com/wiki/Categorical_list_of_programming_languages.html 0.439568 http://kiwitobes.com/wiki/Programming_paradigm.html 0.426817http://kiwitobes.com/wiki/Lisp_programming_language.html The value of the PageRank score is a little harder to see with this closed, tightly controlled set of documents, which likely contains fewer useless pages or pages intended solely to get attention than you'd find on the Web.

Software Design for Flexibility by Chris Hanson, Gerald Sussman

But this is only the start. In chapter 5 we will transcend this embedding strategy, using the powerful idea of metalinguistic abstraction. 1 The generality of the domain model is an example of “Postel's law”—see page 3. 2 There are some notable exceptions: the functional programming extensions introduced by Java 8 directly capture useful combinations. Functional programming languages, such as Lisp and Haskell, have libraries of useful combination mechanisms. 3 Here things are simple, but in complex programs with many internal procedures, descriptive names can make things easier to read and understand. In MIT/GNU Scheme there is a minor advantage to naming the procedure being returned here, because the debugger can show this name for a procedure that would otherwise be anonymous. 4 Documentation of hash table procedures in MIT/GNU Scheme can be found in [51]. 5 We thank Guy L.

For example, write-line changes the display by printing something to the display. 11 It is another cultural convention that we terminate the name of a procedure that has “side effects” with an exclamation point (!). This warns the reader that changing the order of effects may change the results of running the program. 12 The discipline of programming without assignments is called functional programming. Functional programs are generally easier to understand and have fewer bugs than imperative programs. 13 This terminology dates back to the ACTOR framework [58] and the Smalltalk programming language [46]. References [1]Harold Abelson and Gerald Jay Sussman with Julie Sussman, Structure and Interpretation of Computer Programs (2nd ed.).

A number of early programming language designs in effect made a design commitment to reflect the style of hardware organization called the Harvard architecture: the code is here, the data is there, and the job of the code is to massage the data. But an inflexible, arm's-length separation between code and data turns out to be a significant limitation on program organization. Well before the end of the twentieth century, we learned from functional programming languages (such as ML, Scheme, and Haskell) and from object-oriented programming languages (such as Simula, Smalltalk, C++, and Java) that there are advantages to being able to treat code as data, to treat data as code, and to bundle smallish amounts of code and related data together rather than organizing code and data separately as monolithic chunks.

Introducing Elixir by Simon St.Laurent, J. David Eisenberg

on .4 iti n 1 Ed sio d er 2n rs V Co ve Introducing Elixir GETTING STARTED IN FUNCTIONAL PROGRAMMING Simon St. Laurent & J. David Eisenberg SECOND EDITION Introducing Elixir Getting Started in Functional Programming Simon St.Laurent and J. David Eisenberg Beijing Boston Farnham Sebastopol Tokyo Introducing Elixir by Simon St.Laurent and J. David Eisenberg Copyright © 2017 Simon St.Laurent and J. David Eisenberg. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use.

Who This Book Is For This book is mostly for people who’ve been programming in other languages but want to look around. Maybe you’re being very practical, and a distributed model, with its resulting scale and resilience advantages, appeals to you. Maybe you want to see what this “functional programming” stuff is all about. Or maybe you’re just going for a hike, taking your mind to a new place. We suspect that functional programming is more approachable before you’ve learned to program in other paradigms. However, getting started in Elixir—sometimes even just installing it—requires a fair amount of computing skill. If you’re a complete new‐ comer to programming, welcome, but there will be a few challenges along the way.

What This Book Will Do For You You’ll learn to write simple Elixir programs. You’ll understand why Elixir makes it easier to build resilient programs that can scale up and down with ease. You’ll be able to read other Elixir resources that assume a fair amount of experience and make sense of them. In more theoretical terms, you’ll get to know functional programming. You’ll learn how to design programs around message passing and recursion, creating processoriented programs focused more on data flow. Most importantly, the gates to concurrent application development will be opened. Though this introduction only gets you started using the incredible powers of the Open Telecom Platform (OTP), that foundation can take you to amazing places.

pages: 214 words: 31,751

Software Engineering at Google: Lessons Learned From Programming Over Time by Titus Winters, Tom Manshreck, Hyrum Wright

Since the build system now has full control over what tools are being run when, it can make much stronger guarantees that allow it to be far more efficient while still guaranteeing correctness. A Functional Perspective It’s easy to make an analogy between artifact-based build systems and functional programming. Traditional imperative programming languages (e.g. Java, C, and Python) specify lists of statements to be executed one after another, in the same way that task-based build systems let programmers define a series of steps to execute. Functional programming languages (e.g. Haskell and ML), in contrast, are structured more like a series of mathematical equations. In functional languages, the programmer describes a computation to perform, but leaves the details of when and exactly how that computation is executed to the compiler.

This maps to the idea of declaring a manifest in an artifact-based build system and letting the system figure out how to execute the build. Many problems cannot be easily expressed using functional programming, but the ones that do benefit greatly from it: the language is often able to trivially parallelize such programs and make strong guarantees about their correctness that would be impossible in an imperative language. The easiest problems to express using functional programming are the ones that simply involve transforming one piece of data into another using a series of rules or functions. And that’s exactly what a build system is: the whole system is effectively a mathematical function that takes source files (and tools like the compiler) as inputs and produces binaries as outputs.

And that’s exactly what a build system is: the whole system is effectively a mathematical function that takes source files (and tools like the compiler) as inputs and produces binaries as outputs. So it’s not surprising that it works well to base a build system around the tenants of functional programming. Getting Concrete with Bazel Bazel is the open-source version of Google’s internal build tool, Blaze, and is a good example of an artifact-based build system. Here’s what a buildfile (normally named BUILD) looks like in Bazel: java_binary( name = "MyBinary", srcs = ["MyBinary.java"], deps = [ ":mylib", ], ) java_library( name = "mylib", srcs = ["MyLibrary.java", "MyHelper.java"], visibility = ["//java/com/example/myproduct:__subpackages__"], deps = [ "//java/com/example/common", "//java/com/example/myproduct/otherlib", "@com_google_common_guava_guava//jar", ], ) In Bazel, BUILD files define targets - the two types of targets here are java_binary and java_library.

pages: 292 words: 81,699

More Joel on Software by Joel Spolsky

Now, I freely admit that programming with pointers is not needed in 90% of the code written today, and in fact, it’s downright dangerous in production code. OK. That’s fine. And functional programming is just not used much in practice. Agreed. But it’s still important for some of the most exciting programming jobs. Without pointers, for example, you’d never be able to work on the Linux kernel. You can’t understand a line of code in Linux, or, indeed, any operating system, without really understanding pointers. Without understanding functional programming, you can’t invent MapReduce, the algorithm that makes Google so massively scalable. The terms “Map” and “Reduce” come from Lisp and functional programming. MapReduce is, in retrospect, obvious to anyone who remembers from their 6.001-equivalent programming class that purely 56 More from Joel on Software functional programs have no side effects and are thus trivially parallelizable.

And now you understand something I wrote a while ago where I complained about CS students who are never taught anything but Java: Without understanding functional programming, you can’t invent MapReduce, the algorithm that makes Google so massively scalable. The terms “Map” and “Reduce” come from Lisp and functional programming. MapReduce is, in retrospect, obvious to anyone who remembers from their 6.001-equivalent programming class that purely functional programs have no side effects and are thus trivially parallelizable. The very fact that Google invented MapReduce, and Microsoft didn’t, says something about why Microsoft is still playing catch-up trying to get basic search features to work, while Google has moved on to the next problem: building Skynet^H^H^H^H^H^H, the world’s largest massively parallel supercomputer.

I’ve seen all kinds of figures for dropout rates in CS, and they’re usually between 40% and 70%. The universities tend to see this as a waste; I think it’s just a necessary culling of the people who aren’t going to be happy or successful in programming careers. The other hard course for many young CS students was the course where you learned functional programming, including recursive programming. MIT set the bar very high for these courses, creating a required course (6.001) and a textbook (Abelson and Sussman’s Structure and Interpretation of Computer Programs [The MIT Press, 1996]), which were used at dozens or even hundreds of top CS schools as the de facto introduction to computer science.

pages: 1,065 words: 229,099

Real World Haskell by Bryan O'Sullivan, John Goerzen, Donald Stewart, Donald Bruce Stewart

Novelty Haskell is most likely quite different from any language you’ve ever used before. Compared to the usual set of concepts in a programmer’s mental toolbox, functional programming offers us a profoundly different way to think about software. In Haskell, we deemphasize code that modifies data. Instead, we focus on functions that take immutable values as input and produce new values as output. Given the same inputs, these functions always return the same results. This is a core idea behind functional programming. Along with not modifying data, our Haskell functions usually don’t talk to the external world; we call these functions pure.

On one side, it gave language researchers a stable language in which to experiment with making lazy functional programs run efficiently and on the other side researchers explored how to construct programs using lazy functional techniques, and still others used it as a teaching language. The Modern Era While these basic explorations of the 1990s proceeded, Haskell remained firmly an academic affair. The informal slogan of those inside the community was to “avoid success at all costs.” Few outsiders had heard of the language at all. Indeed, functional programming as a field was quite obscure. During this time, the mainstream programming world experimented with relatively small tweaks, from programming in C, to C++, to Java.

Enjoyment We believe that it is easy to pick up the basics of Haskell programming and that you will be able to successfully write small programs within a matter of hours or days. Since effective programming in Haskell differs greatly from other languages, you should expect that mastering both the language itself and functional programming techniques will require plenty of thought and practice. Harking back to our own days of getting started with Haskell, the good news is that the fun begins early: it’s simply an entertaining challenge to dig into a new language— in which so many commonplace ideas are different or missing—and to figure out how to write simple programs.

pages: 135 words: 31,098

ClojureScript: Up and Running by Stuart Sierra, Luke Vanderhart

However, with only a very slight shift in viewpoint, you can also understand any functional program in terms of the data that it manipulates and how that data flows through the system. Every function takes some data as arguments and returns data when it is complete. Usually, the end goal of a program is not to invoke certain execution paths, but to create, retrieve, or transform data in one form or another. Functions are simply the tool for doing so. In a very real sense, one could say that “data-oriented programing” is a synonym for “functional programming.” Clojure and ClojureScript recognize this, and therefore provide a carefully-designed set of data primitives and composite data structures that are both easy to use and philosophically aligned with basic theories about what data is.

Core JavaScript has a limited number of keywords, concepts, and built-in features. This makes it easy to embed in different environments. It is flexible. Features missing from core JavaScript, such as namespaces or classes, can be added using the language itself. JavaScript functions are first-class. Although JavaScript is not a “functional” programming language in the usual sense, the ability to create and compose functions as values grants it immense power. It’s there. Every web browser has had JavaScript built-in since the mid-1990s. Beyond that, the ease of embedding JavaScript in other applications has led to its inclusion in products as diverse as databases and television set-top boxes.

For example, the number zero, when used in a Boolean expression, is false in JavaScript but true in ClojureScript. See the sidebar on “Truthiness” in Chapter 4. To use a Boolean as a literal, just type one of the special symbols true or false. Functions In ClojureScript (like JavaScript), functions are first-class entities and, as befits a functional programming language, are themselves data. They can be created using the syntax discussed in the previous chapter, and once created can be passed around and added to composite data structures like any other data. Importantly, ClojureScript functions are implemented as plain old JavaScript functions.

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

This brings us to the end of our discussion on the core constructs for controlling flow of code in Python. The next section covers some core concepts and constructs that are parts of the functional programming paradigm in Python. Functional Programming The functional programming paradigm is a style of programming with origins in lambda calculus. It treats any form of computation purely on the basis of executing and evaluating functions. Python is not a pure functional programming language but does have several constructs that can be used for functional programming. In this section we will talk about several of these constructs, including functions and some advanced concepts like generators, iterators, and comprehensions.

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. Principles like abstraction, encapsulation, inheritance, and polymorphism can also be implemented and exhibited using Python. There are several advanced features in Python, including iterators, generators, list comprehensions, lambda expressions, and several modules like itertools and functools, which provide the ability to write code following the functional programming paradigm. Python was designed keeping in mind the fact that simple and beautiful code is more elegant and easy to use rather than doing premature optimization and writing hard-to-interpret code.

Integrated Development Environments Environment Setup Virtual Environments Python Syntax and Structure Data Structures and Types Numeric Types Strings Lists Sets Dictionaries Tuples Files Miscellaneous Controlling Code Flow Conditional Constructs Looping Constructs Handling Exceptions Functional Programming Functions Recursive Functions Anonymous Functions Iterators Comprehensions Generators The itertools and functools Modules Classes Working with Text String Literals String Operations and Methods Text Analytics Frameworks Summary Chapter 3:​ Processing and Understanding Text Text Tokenization Sentence Tokenization Word Tokenization Text Normalization Cleaning Text Tokenizing Text Removing Special Characters Expanding Contractions Case Conversions Removing Stopwords Correcting Words Stemming Lemmatization Understanding Text Syntax and Structure Installing Necessary Dependencies Important Machine Learning Concepts Parts of Speech (POS) Tagging Shallow Parsing Dependency-based Parsing Constituency-based Parsing Summary Chapter 4:​ Text Classification What Is Text Classification?​

Elixir in Action by Saša Jurić

—Ved Antani, Electronic Arts Outstanding coverage of Elixir’s distributed computing capabilities, with a real-world point of view. —Christopher Bailey, HotelTonight Read this book if you want to think and solve problems in the Elixir way! —Kosmas Chatzimichalis, Mach 7x Functional programming made easy. —Mohsen Mostafa Jokar, Hamshahri Probably the best introduction to Elixir and the Functional Programming. —Amazon customer A good book for experienced programmers who want to learn more about Elixir. —Amazon customer Elixir in Action Second Edition SAŠA JURIĆ MANNING Shelter Island For online information and ordering of this and other Manning books, please visit www.manning.com.

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. As a long-time OO programmer, I can sincerely tell you not to worry. The underlying functional concepts in Elixir are relatively simple and should be easy to grasp. Of course, functional programming is significantly different from whatever you’ve seen in a typical OO language, and it takes some getting used to. But it’s not rocket science, and if you’re an experienced developer, you should have no problem understanding these concepts.

The people who gave us Elixir and Erlang, including the original inventors, core team members, and contributors, deserve a special mention. Thank you for creating such great products, which make my job easier and more fun. Finally, special thanks to all the members of the Elixir community; this is the nicest and friendliest developer community I’ve ever seen! about this book Elixir is a modern functional programming language for building large-scale scalable, distributed, fault-tolerant systems for the Erlang virtual machine. Although the language is compelling in its own right, arguably its biggest advantage is that it targets the Erlang platform. Erlang was made to help developers deal with the challenge of high availability.

pages: 398 words: 86,855

Bad Data Handbook by Q. Ethan McCallum

For example, you might want to place a new member of the team on one of the infrastructure pieces that is doing well, and should be a model for other pieces, as to give them a good starting place for learning the system. A more senior team member may be more effective on pieces of the infrastructure that are struggling. Immutability: Borrowing an Idea from Functional Programming Considering the examples above, a core element of our strategy was immutability: even though our processing pipeline transformed our data several times over, we never changed (overwrote) the original data. This is an idea we borrowed from functional programming. Consider imperative languages like C, Java, and Python, in which data tends to be mutable. For example, if we want to sort a list, we might call myList.sort().

, Splits, Dividends, and Rescaling–Splits, Dividends, and Rescaling, But First, Let’s Reflect on Graduate School …–But First, Let’s Reflect on Graduate School …, Moving into Government Work–Government Data Is Very Real, Be Inconsistent in Cleaning and Organizing the Data, Data Traceability–Conclusion, Snapshotting, Backing Out Data, Immutability: Borrowing an Idea from Functional Programming–Immutability: Borrowing an Idea from Functional Programming, Social Media: Whose Data Is This Anyway?–Control, Expectations Around Communication and Expression–Update Notification API, aCcountable–aCcountable assumptions about, problems with, Lessons Learned–Lessons Learned cleaning, General Workflow Example, But First, Let’s Reflect on Graduate School …–But First, Let’s Reflect on Graduate School …, Moving into Government Work–Government Data Is Very Real, Be Inconsistent in Cleaning and Organizing the Data empty values in, Field Validation field values not comparable over time, Splits, Dividends, and Rescaling–Splits, Dividends, and Rescaling immutability of, Snapshotting, Immutability: Borrowing an Idea from Functional Programming–Immutability: Borrowing an Idea from Functional Programming ownership of, Social Media: Whose Data Is This Anyway?

–Control, Expectations Around Communication and Expression–Update Notification API, aCcountable–aCcountable assumptions about, problems with, Lessons Learned–Lessons Learned cleaning, General Workflow Example, But First, Let’s Reflect on Graduate School …–But First, Let’s Reflect on Graduate School …, Moving into Government Work–Government Data Is Very Real, Be Inconsistent in Cleaning and Organizing the Data empty values in, Field Validation field values not comparable over time, Splits, Dividends, and Rescaling–Splits, Dividends, and Rescaling immutability of, Snapshotting, Immutability: Borrowing an Idea from Functional Programming–Immutability: Borrowing an Idea from Functional Programming ownership of, Social Media: Whose Data Is This Anyway?–Control removal of, Backing Out Data, Expectations Around Communication and Expression–Update Notification API traceability of, Data Traceability–Conclusion, aCcountable–aCcountable unique identifiers in, changing over time, Whose Ticker Is It Anyway?

pages: 450 words: 569

ANSI Common LISP by Paul Graham

All such operators are marked as "settable" in Appendix D. 22 WELCOME TO LISP You can give any (even) number of arguments to setf. An expression of the form (setf a b c d e f) is equivalent to three separate calls to s e t f in sequence: (setf a b) (setf c d) (setf e f) 2.12 Functional Programming Functional programming means writing programs that work by returning values, instead of by modifying things. It is the dominant paradigm in Lisp. Most built-in Lisp functions are meant to be called for the values they return, not for side-effects. The function remove, for example, takes an object and a list and returns a new list containing everything but that object: > ( s e t f 1st ' ( c a r a t ) ) (CARAT) > (remove 'a 1st) (C R T) Why not just say that remove removes an object from a list?

To remove all the as from a list x, we say: ( s e t f x (remove ' a x ) ) Functional programming means, essentially, avoiding setf and things like it. At first sight it may be difficult to imagine how this is even possible, let alone desirable. How can one build programs just by returning values? 2.13 23 ITERATION It would be inconvenient to do without side-effects entirely. However, as you read further, you may be surprised to discover how few you really need. And the more side-effects you do without, the better off you'll be. One of the most important advantages of functional programming is that it allows interactive testing.

Introduction 1.1. 1.2. 1.3. 1 New Tools 1 New Techniques 3 A New Approach 4 2. Welcome to Lisp 2.1. 2.2. 2.3. 2.4. 2.5. 2.6. 2.7. 2.8. 2.9. 2.10. 2.11. 2.12. 2.13. 2.14. 2.15. 2.16. 7 Form 7 Evaluation 9 Data 10 List Operations 12 Truth 13 Functions 14 Recursion 16 Reading Lisp 17 Input and Output 18 Variables 19 Assignment 21 Functional Programming 22 Iteration 23 Functions as Objects 25 Types 27 Looking Forward 27 3. Lists 3.1. 3.2. 3.3. 3.4. 3.5. 3.6. 3.7. 3.8. 3.9. 3.10. 3.11. 3.12. 3.13. 3.14. 3.15. 3.16. Mapping Functions 40 Trees 40 Understanding Recursion 42 Sets 43 Sequences 45 Stacks 47 Dotted Lists 49 Assoc-lists 51 Example: Shortest Path 51 Garbage 54 4.

pages: 514 words: 111,012

The Art of Monitoring by James Turnbull

We don't really care about the "how"; the database engine takes care of those details. In addition to their declarative nature, functional programming languages try to eliminate all side effects from changing state. In a functional language, when you call a function its output value depends only on the inputs to the function. So if you repeatedly call function f with the same value for argument x, f(x), it will produce the same result every time. This makes functional programs easy to understand, test, and predict. Functional programming languages call functions that operate like this "pure" functions. The best way to get started with Clojure is to understand the basics of its syntax and types.

Additionally, Riemann comes with a lot of helpers and shortcuts that make it easier to write Clojure to do what we need to process our events. Let's learn a bit more about Clojure and help you get started with Riemann. Clojure is a dynamic programming language that targets the Java Virtual Machine. It's a dialect of Lisp and is largely a functional programming language. Functional programming is a programming style that focuses on the evaluation of mathematical functions and steers away from changing state and mutable data. It's highly declarative, meaning you build programs from expressions that describe "what" a program should accomplish rather than "how" it accomplishes things.

Instrument schemas Time and the observer effect Metrics Application metrics Business metrics Monitoring patterns, or where to put your metrics The utility pattern The external pattern Building metrics into a sample application Logging Adding our own structured log entries Adding structured logging to our sample application Working with your existing logs Health checks, endpoints, and external monitoring Checking an internal endpoint Deployments Adding deployment notifications to our sample application Working with our deployment events Tracing Summary Notifications Our current notifications Updating expired event configuration Upgrading our email notifications Formatting the email subject Formatting the email body Adding graphs to notifications Defining our data source Defining our query parameters Defining our graph panels and rows Rendering the dashboard Adding our dashboard to the Riemann notification Some sample scripted dashboards Other context Adding Slack as a destination Adding PagerDuty as a destination Maintenance and downtime Learning from your notifications Other alerting tools Summary Monitoring Tornado: a capstone The Tornado application Application architecture Monitoring strategy Tagging our Tornado events Monitoring Tornado — Web tier Monitoring HAProxy Monitoring Nginx Addressing the Web tier monitoring concerns Setting up the Tornado checks in Riemann The webtier function Adding Tornado checks to Riemann Summary Monitoring Tornado: Application Tier Monitoring the Application tier JVM Configuring collectd for JMX Collecting our Application tier JVM logs Monitoring the Tornado API application Addressing the Tornado Application tier monitoring concerns Summary Monitoring Tornado: Data tier Monitoring the Data tier MySQL server Using MySQL data for metrics Query timing Monitoring the Data tier's Redis server Addressing the Tornado Data tier monitoring concerns The Tornado dashboard Expanding monitoring beyond Tornado Summary An Introduction to Clojure and Functional Programming A brief introduction to Clojure Installing Leiningen Clojure syntax and types Clojure functions Lists Vectors Sets Maps Strings Creating our own functions Creating variables Creating named functions Learning more Clojure Cover Table of contents The Art of Monitoring Who is this book for?

Pragmatic.Programming.Erlang.Jul.2007 by Unknown

In Chapter 18, Making a System with OTP, we’ll look at how to make highly reliable systems that have been in round-the-clock operation for years. In Section 16.1, The Road to the Generic Server, on page 292, we’ll talk about techniques for writing servers where the software can be upgraded without taking the server out of service. R OAD M AP In many places we’ll be extolling the virtues of functional programming. Functional programming forbids code with side effects. Side effects and concurrency don’t mix. You can have sequential code with side effects, or you can have code and concurrency that is free from side effects. You have to choose. There is no middle way. Erlang is a language where concurrency belongs to the programming language and not the operating system.

There are loads of programming languages, so why should you learn another? Here are five reasons why you should learn Erlang: • You want to write programs that run faster when you run them on a multicore computer. • You want to write fault-tolerant applications that can be modified without taking them out of service. • You’ve heard about “functional programming” and you’re wondering whether the techniques really work. • You want to use a language that has been battle tested in real large-scale industrial products that has great libraries and an active user community. • You don’t want to wear your fingers out by typing lots of lines of code. Can we do these things?

Surely it couldn’t be that easy. The basic program was simple, and with a few more lines of code, file sharing and encrypted conversations became possible. The programmer started typing.... What’s This All About? It’s about concurrency. It’s about distribution. It’s about fault tolerance. It’s about functional programming. It’s about programming a distributed concurrent system without locks and mutexes but using only pure message passing. It’s about speeding up your programs on multicore CPUs. It’s about writing distributed applications that allow people to interact with each other. It’s about design methods and behaviors for writing fault-tolerant and distributed systems.

pages: 821 words: 178,631

The Rust Programming Language by Steve Klabnik, Carol Nichols

Next, we’ll explore some Rust features that were influenced by functional languages: closures and iterators. 13 FUNCTIONAL LANGUAGE FEATURES: ITERATORS AND CLOSURES Rust’s design has taken inspiration from many existing languages and techniques, and one significant influence is functional programming. Programming in a functional style often includes using functions as values by passing them in arguments, returning them from other functions, assigning them to variables for later execution, and so forth. In this chapter, we won’t debate the issue of what functional programming is or isn’t but will instead discuss some features of Rust that are similar to features in many languages often referred to as functional. More specifically, we’ll cover: Closures, a function-like construct you can store in a variable Iterators, a way of processing a series of elements How to use these two features to improve the I/O project in Chapter 12 The performance of these two features (Spoiler alert: they’re faster than you might think!)

In Chapter 12, we’ll build our own implementation of a subset of functionality from the grep command line tool that searches for text within files. For this, we’ll use many of the concepts we discussed in the previous chapters. Chapter 13 explores closures and iterators: features of Rust that come from functional programming languages. In Chapter 14, we’ll examine Cargo in more depth and talk about best practices for sharing your libraries with others. Chapter 15 discusses smart pointers that the standard library provides and the traits that enable their functionality. In Chapter 16, we’ll walk through different models of concurrent programming and talk about how Rust helps you to program in multiple threads fearlessly.

There are multiple trade-offs to consider in addition to the prevention of bugs. For example, in cases where you’re using large data structures, mutating an instance in place may be faster than copying and returning newly allocated instances. With smaller data structures, creating new instances and writing in a more functional programming style may be easier to think through, so lower performance might be a worthwhile penalty for gaining that clarity. Differences Between Variables and Constants Being unable to change the value of a variable might have reminded you of another programming concept that most other languages have: constants.

pages: 688 words: 107,867

Python Data Analytics: With Pandas, NumPy, and Matplotlib by Fabio Nelli

.>>> items = [1,2,3,4,5] >>> for item in items: ... print(item + 1) ... 2 3 4 5 6 Functional Programming The for-in loop shown in the previous example is very similar to loops found in other programming languages. But actually, if you want to be a “Python” developer, you have to avoid using explicit loops. Python offers alternative approaches, specifying programming techniques such as functional programming (expression-oriented programming). The tools that Python provides to develop functional programming comprise a series of functions: map(function, list) filter(function, list) reduce(function, list) lambda list comprehension The for loop that you have just seen has a specific purpose, which is to apply an operation on each item and then somehow gather the result.

.>>> list(filter((lambda x: x < 4), items)) [1, 2, 3] >>> from functools import reduce >>> reduce((lambda x,y: x/y), items) 0.008333333333333333 Both of these functions implement other types by using the for loop. They replace these cycles and their functionality, which can be alternatively expressed with simple functions. That is what constitutes functional programming. The final concept of functional programming is list comprehension. This concept is used to build lists in a very natural and simple way, referring to them in a manner similar to how mathematicians describe datasets. The values in the sequence are defined through a particular function or operation.>>> S = [x**2 for x in range(5)] >>> S [0, 1, 4, 9, 16] Indentation A peculiarity for those coming from other programming languages is the role that indentation plays.

Index A Accents, LaTeX Advanced Data aggregation apply() functions transform() function Anaconda Anderson Iris Dataset, see Iris flower dataset Array manipulation joining arrays column_stack() and row_stack() hstack() function vstack() function splitting arrays hsplit() function split() function vsplit() function Artificial intelligence schematization of Artificial neural networks biological networks edges hidden layer input and output layer multi layer perceptron nodes schematization of SLP ( see Single layer perceptron (SLP)) weight B Bar chart 3D error bars horizontal matplotlib multiserial multiseries stacked bar pandas DataFrame representations stacked bar charts x-axis xticks() function Bayesian methods Big Data Bigrams Biological neural networks Blending operation C Caffe2 Chart typology Choropleth maps D3 library geographical representations HTML() function jinja2 JSON and TSV JSON TopoJSON require.config() results US population data source census.gov file TSV, codes HTML() function jinja2.Template pop2014_by_county dataframe population.csv render() function SUMLEV values Classification and regression trees Classification models Climatic data Clustered bar chart IPython Notebook jinja2 render() function Clustering models Collocations Computer vision Concatenation arrays combining concat() function dataframe keys option pivoting hierarchical indexing long to wide format stack() function unstack() function removing Correlation Covariance Cross-validation Cython D Data aggregation apply() functions GroupBy groupby() function operations output of SPLIT-APPLY-COMBINE hierarchical grouping merge() numeric and string values price1 column transform() function Data analysis charts data visualization definition deployment phase information knowledge knowledge domains computer science disciplines fields of application machine learning and artificial intelligence mathematics and statistics problems of open data predictive model process data sources deployment exploration/visualization extraction model validation planning phase predictive modeling preparation problem definition stages purpose of Python and quantitative and qualitative types categorical data numerical data DataFrame pandas definition nested dict operations structure transposition structure Data manipulation aggregation ( see Data aggregation) concatenation discretization and binning group iteration permutation phases of preparation ( see Data preparation) string ( see String manipulation) transformation Data preparation DataFrame merging operation pandas.concat() pandas.DataFrame.combine_first() pandas.merge() procedures of Data structures, operations DataFrame and series flexible arithmetic methods Data transformation drop_duplicates() function mapping adding values axes dict objects replacing values remove duplicates Data visualization adding text axis labels informative label mathematical expression modified of text() function bar chart ( see Bar chart) chart typology contour plot/map data analysis 3D surfaces grid grids, subplots handling date values histogram installation IPython and IPython QtConsole kwargs figures and axes horizontal subplots linewidth plot() function vertical subplots legend chart of legend() function multiseries chart upper-right corner line chart ( see Line chart) matplotlib architecture and NumPy matplotlib library ( see matplotlib library) mplot3d multi-panel plots grids, subplots subplots pie charts axis() function modified chart pandas Dataframe pie() function shadow kwarg plotting window buttons of commands matplotlib and NumPy plt.plot() function properties QtConsole polar chart pyplot module saving, charts HTML file image file source code scatter plot, 3D Decision trees Deep learning artificial ( see Artificial neural networks) artificial intelligence data availability machine learning neural networks and GPUs Python frameworks programming language schematization of TensorFlow ( see TensorFlow) Digits dataset definition digits.images array digit.targets array handwritten digits handwritten number images matplotlib library scikit-learn library Discretization and binning any() function categorical type cut() function describe() function detecting and filtering outliers qcut() std() function value_counts() function Django Dropping E Eclipse (pyDev) Element-wise computation Expression-oriented programming F Financial data Flexible arithmetic methods Fonts, LaTeX G Gradient theory Graphics Processing Unit (GPU) Grouping Group iteration chain of transformations functions on groups mark() function quantiles() function GroupBy object H Handwriting recognition digits dataset handwritten digits, matplotlib library learning and predicting OCR software scikit-learn svc estimator TensorFlow validation set, six digits Health data Hierarchical indexing arrays DataFrame reordering and sorting levels stack() function statistic levels structure two-dimensional structure I IDEs, see Interactive development environments (IDEs) Image analysis concept of convolutions definition edge detection blackandwhite.jpg image black and white system filters function gradients.jpg image gray gradients Laplacian and Sobel filters results source code face detection gradient theory OpenCV ( see Open Source Computer Vision (OpenCV)) operations representation of Indexing functionalities arithmetic and data alignment dropping reindexing Integration Interactive development environments (IDEs) Eclipse (pyDev) Komodo Liclipse NinjaIDE Spyder Sublime Interactive programming language Interfaced programming language Internet of Things (IoT) Interpreted programming language Interpreter characterization Cython Jython PVM PyPy tokenization IPython and IPython QtConsole Jupyter project logo Notebook DataFrames QtConsole shell tools of Iris flower dataset Anderson Iris Dataset IPython QtConsole Iris setosa features length and width, petal matplotlib library PCA decomposition target attribute types of analysis variables J JavaScript D3 Library bar chart CSS definitions data-driven documents HTML importing library IPython Notebooks Jinja2 library pandas dataframe render() function require.config() method web chart creation Jinja2 library Jython K K-nearest neighbors classification decision boundaries 2D scatterplot, sepals predict() function random.permutation() training and testing set L LaTeX accents fonts fractions, binomials, and stacked numbers with IPython Notebook in Markdown Cell in Python 2 Cell with matplotlib radicals subscripts and superscripts symbols arrow symbols big symbols binary operation and relation symbols Delimiters Hebrew lowercase Greek miscellaneous symbols standard function names uppercase Greek Learning phase Liclipse Linear regression Line chart annotate() arrowprops kwarg Cartesian axes color codes data points different series gca() function Greek characters LaTeX expression line and color styles mathematical expressions mathematical function pandas plot() function set_position() function xticks() and yticks() functions Linux distribution LOD cloud diagram Logistic regression M Machine learning (ML) algorithm development process deep learning diabetes dataset features/attributes Iris flower dataset learning problem linear/least square regression coef_ attribute fit() function linear correlation parameters physiological factors and progression of diabetes single physiological factor schematization of supervised learning SVM ( see Support vector machines (SVMs)) training and testing set unsupervised learning Mapping adding values inplace option rename() function renaming, axes replacing values Mathematical expressions with LaTeX, see LaTeX MATLAB matplotlib matplotlib library architecture artist layer backend layer functions and tools layers pylab and pyplot scripting layer (pyplot) artist layer graphical representation hierarchical structure primitive and composite graphical representation LaTeX NumPy Matrix product Merging operation DataFrame dataframe objects index join() function JOIN operation left_index/right_index options left join, right join and outer join left_on and right_on merge() function Meteorological data Adriatic Sea and Po Valley cities Comacchio image of mountainous areas reference standards TheTimeNow website climate data source JSON file Weather Map site IPython Notebook chart representation CSV files DataFrames humidity function linear regression matplotlib library Milan read_csv() function result shape() function SVR method temperature Jupyter Notebook access internal data command line dataframe extraction procedures Ferrara JSON file json.load() function parameters prepare() function RoseWind ( see RoseWind) wind speed Microsoft excel files dataframe data.xls internal module xlrd read_excel() function MongoDB Multi Layer Perceptron (MLP) artificial networks evaluation of experimental data hidden layers IPython session learning phase model definition test phase and accuracy calculation Musical data N Natural Language Toolkit (NLTK) bigrams and collocations common_contexts() function concordance() function corpora downloader tool fileids() function HTML pages, text len() function library macbeth variable Python library request() function selecting words sentimental analysis sents() function similar() function text, network word frequency macbeth variable most_common() function nltk.download() function nltk.FreqDist() function stopwords string() function word search Ndarray array() function data, types dtype (data-type) intrinsic creation type() function NOSE MODULE “Not a Number” data filling, NaN occurrences filtering out NaN values NaN value NumPy library array manipulation ( see Array manipulation) basic operations aggregate functions arithmetic operators increment and decrement operators matrix product ufunc broadcasting compatibility complex cases operator/function BSD conditions and Boolean arrays copies/views of objects data analysis indexing bidimensional array monodimensional ndarray negative index value installation iterating an array ndarray ( see Ndarray) Numarray python language reading and writing array data shape manipulation slicing structured arrays vectorization O Object-oriented programming language OCR, see Optical Character Recognition (OCR) software Open data Open data sources climatic data demographics IPython Notebook matplotlib pandas dataframes pop2014_by_state dataframe pop2014 dataframe United States Census Bureau financial data health data miscellaneous and public data sets musical data political and government data publications, newspapers, and books social data sports data Open Source Computer Vision (OpenCV) deep learning image processing and analysis add() function blackish image blending destroyWindow() method elementary operations imread() method imshow() method load and display merge() method NumPy matrices saving option waitKey() method working process installation MATLAB packages start programming Open-source programming language Optical Character Recognition (OCR) software order() function P Pandas dataframes Pandas data structures DataFrame assigning values deleting column element selection filtering membership value nested dict transposition evaluating values index objects duplicate labels methods NaN values NumPy arrays and existing series operations operations and mathematical functions series assigning values declaration dictionaries filtering values index internal elements, selection operations Pandas library correlation and covariance data structures ( see Pandas data structures) function application and mapping element row/column statistics getting started hierarchical indexing and leveling indexes ( see Indexing functionalities) installation Anaconda development phases Linux module repository, Windows PyPI source testing “Not a Number” data python data analysis sorting and ranking Permutation new_order array np.random.randint() function numpy.random.permutation() function random sampling DataFrame take() function Pickle—python object serialization cPickle frame.pkl pandas library stream of bytes Political and government data pop2014_by_county dataframe pop2014_by_state dataframe pop2014 dataframe Portable programming language PostgreSQL Principal component analysis (PCA) Public data sets PVM, see Python virtual machine (PVM) pyplot module interactive chart Line2D object plotting window show() function PyPy interpreter Python data analysis library deep learning frameworks module OpenCV Python Package Index (PyPI) Python’s world code implementation distributions Anaconda Enthought Canopy Python(x,y) IDEs ( see Interactive development environments (IDEs)) installation interact interpreter ( see Interpreter) IPython ( see IPython) programming language PyPI Python 2 Python 3 running, entire program code SciPy libraries matplotlib NumPy pandas shell source code data structure dictionaries and lists functional programming Hello World index libraries and functions map() function mathematical operations print() function writing python code, indentation Python virtual machine (PVM) PyTorch Q Qualitative analysis Quantitative analysis R R Radial Basis Function (RBF) Radicals, LaTeX Ranking Reading and writing array binary files tabular data Reading and writing data CSV and textual files header option index_col option myCSV_01.csv myCSV_03.csv names option read_csv() function read_table() function .txt extension databases create_engine() function dataframe pandas.io.sql module pgAdmin III PostgreSQL read_sql() function read_sql_query() function read_sql_table() function sqlalchemy sqlite3 DataFrame objects functionalities HDF5 library data structures HDFStore hierarchical data format mydata.h5 HTML files data structures read_html () web_frames web pages web scraping I/O API Tools JSON data books.json frame.json json_normalize() function JSONViewer normalization read_json() and to_json() read_json() function Microsoft excel files NoSQL database insert() function MongoDB pickle—python object serialization RegExp metacharacters read_table() skiprows TXT files nrows and skiprows options portion by portion writing ( see Writing data) XML ( see XML) Regression models Reindexing RoseWind DataFrame hist array polar chart scatter plot representation showRoseWind() function S Scikit-learn library data analysis k-nearest neighbors classification PCA Python module sklearn.svm.SVC supervised learning svm module SciPy libraries matplotlib NumPy pandas Sentimental analysis document_features() function documents list() function movie_reviews negative/positive opinion opinion mining Shape manipulation reshape() function shape attribute transpose() function Single layer perceptron (SLP) accuracy activation function architecture cost optimization data analysis evaluation phase learning phase model definition explicitly implicitly learning phase placeholders tf.add() function tf.nn.softmax() function modules representation testing set test phase and accuracy calculation training sets Social data sort_index() function Sports data SQLite3 stack() function String manipulation built-in methods count() function error message index() and find() join() function replace() function split() function strip() function regular expressions findall() function match() function re.compile() function regex re.split() function split() function Structured arrays dtype option structs/records Subjective interpretations Subscripts and superscripts, LaTeX Supervised learning machine learning scikit-learn Support vector classification (SVC) decision area effect, decision boundary nonlinear number of points, C parameter predict() function regularization support_vectors array training set, decision space Support vector machines (SVMs) decisional space decision boundary Iris Dataset decision boundaries linear decision boundaries polynomial decision boundaries polynomial kernel RBF kernel training set SVC ( see Support vector classification (SVC)) SVR ( see Support vector regression (SVR)) Support vector regression (SVR) curves diabetes dataset linear predictive model test set, data swaplevel() function T TensorFlow data flow graph Google’s framework installation IPython QtConsole MLP ( see Multi Layer Perceptron (MLP)) model and sessions SLP ( see Single layer perceptron (SLP)) tensors operation parameters print() function representations of tf.convert_to_tensor() function tf.ones() method tf.random_normal() function tf.random_uniform() function tf.zeros() method Text analysis techniques definition NLTK ( see Natural Language Toolkit (NLTK)) techniques Theano trigrams() function U, V United States Census Bureau Universal functions (ufunc) Unsupervised learning W Web Scraping Wind speed polar chart representation RoseWind_Speed() function ShowRoseWind() function ShowRoseWind_Speed() function to_csv () function Writing data HTML files myFrame.html to_html() function na_rep option to_csv() function X, Y, Z XML books.xml getchildren() getroot() function lxml.etree tree structure lxml library objectify parse() function tag attribute text attribute

pages: 559 words: 130,949

Learn You a Haskell for Great Good!: A Beginner's Guide by Miran Lipovaca

They’re a great resource for Haskell newbies. So, What's Haskell? Haskell is a purely functional programming language. In imperative programming languages, you give the computer a sequence of tasks, which it then executes. While executing them, the computer can change state. For instance, you can set the variable a to 5 and then do some stuff that might change the value of a. There are also flow-control structures for executing instructions several times, such as for and while loops. Purely functional programming is different. You don’t tell the computer what to do—you tell it what stuff is. For instance, you can tell the computer that the factorial of a number is the product of every integer from 1 to that number or that the sum of a list of numbers is the first number plus the sum of the remaining numbers.

For instance, you can tell the computer that the factorial of a number is the product of every integer from 1 to that number or that the sum of a list of numbers is the first number plus the sum of the remaining numbers. You can express both of these operations as functions. In functional programming, you can’t set a variable to one value and then set it to something else later on. If you say a is 5, you can’t just change your mind and say it’s something else. After all, you said it was 5. (What are you, some kind of liar?) In purely functional languages, a function has no side effects. The only thing a function can do is calculate something and return the result.

Now, we just need to modify the function to only output the triangles whose perimeter equals 24: ghci> let rightTriangles' = [ (a,b,c) | c <- [1..10], a <- [1..c], b <- [1..a], a^2 + b^2 == c^2, a+b+c == 24] ghci> rightTriangles' [(6,8,10)] And there’s our answer! This is a common pattern in functional programming: you start with a certain set of candidate solutions, and successively apply transformations and filters to them until you’ve narrowed the possibilities down to the one solution (or several solutions) that you’re after. Chapter 2. Believe the Type One of Haskell’s greatest strengths is its powerful type system.

pages: 239 words: 64,812

Geek Sublime: The Beauty of Code, the Code of Beauty by Vikram Chandra

The next great hope for more stable, bug-free software is functional programming, which is actually the oldest paradigm in computing—it uses the algebraic techniques of function evaluation used by the creators of the first computers. In functional programming, all computation is expressed as the evaluation of expressions; the radical simplicity of thinking about programming as only giving input to functions that produce outputs promotes legibility and predictability. There is again the same fervent proselytizing about functional programming that I remember from the early days of OOP, the same conviction that this time we’ve discovered the magic key to the kingdom.

The poet Kshemendra—Abhinavagupta’s student—left this advice: A poet should learn with his eyes the forms of leaves he should know how to make people laugh when they are together he should get to see what they are really like he should know about oceans and mountains in themselves and the sun and the moon and the stars his mind should enter into the seasons he should go among many people in many places and learn their languages10 I have a sabbatical coming up. My plan is: (1) write fiction; (2) learn a functional programming language; and (3) learn Sanskrit. In Red Earth and Pouring Rain one of the characters builds a gigantic knot. “I made the knot,” he says. I made it of twine, string, leather thongs, strands of fibrous materials from plants, pieces of cloth, the guts of animals, lengths of steel and copper, fine meshes of gold, silver beaten thin into filament, cords from distant cities, women’s hair, goats’ beards; I used butter and oil; I slid things around each other and entangled them, I pressed them together until they knew each other so intimately that they forgot they were ever separate, and I tightened them against each other until they squealed and groaned in agony; and finally, when I had finished, I sat cross-legged next to the knot, sprinkled water in a circle around me and whispered the spells that make things enigmatic, the chants of profundity and intricacy.

pages: 190 words: 52,865

Full Stack Web Development With Backbone.js by Patrick Mulder

With NVM, you can easily switch between versions of Node.js. 157 Getting Functional with Underscore.js Because JavaScript in its old standard didn’t have helpers for dealing with enumerators, Underscore.js was born. Underscore.js provides many nifty JavaScript shortcuts and is also a core dependency of Backbone.js. Underscore.js derives many ideas from func‐ tional programming. In functional programming, we can easily extract meta information from data struc‐ tures, or chain operations on data structures independent from the data itself. This flexibility is achieved by passing functions as arguments to other functions, often under the concept of higher-level functions. The main goal of the Underscore.js library is to provide a set of abstractions to transform and aggregate data structures.

After loading the library, we obtain a helper to the global namespace of the browser window. To get a feeling of what the shortcut can do, we can look at some examples. Due to the success of Underscore.js, there are a number of deriva‐ tives from the original library. First, in underscore-contrib, a lot more ideas from functional programming are made possible in JavaScript. Another variation can be found in underscore.string. This library provides a number of default string transformations Last, there is underscore-cli, which provides helpers to transform JSON from the command line. Collections and Arrays Some of the most important helpers from Underscore.js are improvements in dealing with collections.

Send email to index@oreilly.com. 165 Backbone.Collection, sorting/filtering models with, 61–71 Backbone.js dependencies, 2 distributed application design, 6 fetching local copy of, 4 fetching via content delivery networks, 5 fetching with Node’s package manager, 2 philosophy of, 2, 145 Backbone.Model building a data layer, 26 data resolution, 88 DRYer Views and ViewModels, 46 modal view, 125 sorting, 62 wrapping a data store, 101 Backbone.ModelBinder, 39 Backbone.Obscura, 68, 137 Backbone.Router addressing state, 49–55 orchestrating views, 55–60 overview of, 49 Backbone.Sync, 84, 87 Backbone.View basic events, 31 basic rendering, 37 basic view templates, 41 DRYer Views and ViewModels, 46 filtering, 66 handling UI events, 43 modal view, 125 navbar view, 123 parent/child views, 56 rendering a collection, 42 sorting, 62 templates, 74 Backburner, 76 backend-as-a-service providers, 94, 98 bind function, 159 bindAll function, 159 binding, 39 Bluebird library, 103 Bower, 136 Browserify, 10, 29, 136 browsers development console, 15 DOM representation in, 161 packaging modules for, 9 166 | Index security in, 113 (see also authentication) browsing experience mock-up, 19 Brunch, 136 build automation goals of, 77 Grunt, 77 overview of, 135 scaffolding components, 143 tools to improve productivity, 135 Yeoman, 138 C callbacks, 103 Catero, 136 Cavage, Mark, 100 chaining methods, 161 change events, 28 Chaplin framework, 136, 146 child views, 56 className property, 37 click dummy basic CSS for, 25 basic events, 31 basic HTML for, 24 data layer, 26 preparation overview, 24 Cloudflare, 5 Cocoa API, 22 Codepen.io, 5 CoffeeScript, 136 collection helpers, 161 collections filtering, 21, 66 pagination, 68 sorting, 21, 62 transforming, 61 Underscore.js helpers, 158 command line interface (CLI) benefits of, 1 bundling modules from, 10 npm (Node package manager), 2 CommonJS modules benefits of, 8 Browserify, 10 Cartero management system, 136 Express.js and Stitch, 13 require in browsers, 9 comparator function, 62 content delivery network (CDN), 5 controllers, 24, 55 convention-over-configuration, 147 cookies drawbacks of, 115, 118 overview of, 114 session management, 118 user signup, 116 CORS (cross origin resource sharing), 99 createUser method, 116 cross-site request forgery (CSRF), 114 cross-site scripting (XSS), 114 D data binding, 39 building the data layer, 26 controlling access to, 113 (see also authentication) representation with models, 21 transforming with Underscore.js, 158 databases non-relational, 98 NoSQL, 98 relational, 98 wrapping data stores behind an API, 101 debuggers, 15 Decker, Kevin, 145 default properties, 27 dependencies managing with Bower, 136 resolving with main.js file, 141 reusing across projects, 8 Underscore.js, 158–160 Document Object Model (DOM) changing multiple nodes at once, 76 manipulation libraries, 2 node types, 161 statelessness and, 19 DOM nodes attaching/removing event handlers, 162 chaining methods on, 161 operating on directly, 161 preventing event bubbling, 162 selecting with jQuery, 161 types of, 161 DRYer views, 46 E Eastridge, Ryan, 145 ECO (embedded CoffeeScript), 75 event bubbling, 162 event handlers attaching/removing, 162 for UI events, 43 event listeners, 39 events change events, 28 default, 31 handling UI events, 43 sources of, 21, 31 Express.js, 13, 100 extend function, 27, 160 F fetching information asynchronous effects, 92 from hosted backend services, 94 overview of, 83, 87 RESTful web service handling, 84 filtering, 66 Firebase, 94 frameworks benefits of, 145 Chaplin, 146 Giraffe, 146 Junior, 146 Marionette, 146 Rendr, 146 Thorax.js, 146 Function.prototype.bind, 159 functional programming, 158 functions binding context to, 159 get, 28 private, 28 set, 28 sharing across multiple objects, 160 G get function, 28 Giraffe, 146 Grunt, 77 Index | 167 H Handlebars, 76 hashes/hashbangs, 50 Homebrew package manager, 157 HTTP requests basic verbs, 84 cookies, 115 sending from JavaScript, 163 signing, 114 HTTP responses, 102 I index.html, 9 inheritance, 160 isomorphic application design, 97 J JavaScript adding moudles from command line, 143 Ajax, 163 basic abstractions for Backbone.js, 1 debugging, 15 distributed application design, 6 HTTP requests from, 163 jQuery basics of, 160 element selection, 161 event handling, 162 Node.js installation, 157 overview of, 157 promises, 102 Underscore.js benefits of, 158 collections/arrays, 158 functions, 159 objects, 160 utility functions, 160 (see also objects) jQuery Ajax browsing experience mock-up, 19 jQuery API for, 163 basics of, 160 chaining methods, 161 collection helpers, 161 element selection, 161 event handling, 162 168 | Index node wrappers, 161 referencing, 35 JSBin, 5 JSFiddle, 5 JSLint/JSHint, 16 JST (JavaScript Templates), 74 Junior, 146 K key-value pairs data representation with, 21 primary keys, 107 syntax considerations for, 28 L LAMP (Linux-Apache-MySQL-PHP), 98 Layout View, 55 Linux, Node.js installation, 157 M Mac OS Homebrew package manager, 157 Node.js installation, 157 main.js file, 141 Marionette, 146 Mincer, 13 mixin functions, 46 mock-ups APIs, 85 browsing experience, 19 data, 149 wireframes, 19 Mockjax, 149 modal view, 125 model parameter, 29 model-view-controller (MVC) pattern, 22 models (see Backbone models) modules Browserify, 10 bundling from command line, 10 choosing, 8 CommonJS, 8 packaging for browsers, 9 RequireJS, 142 Morell, Jeremy, 68 Munich Cinema example API creation, 100 click dummy preparation basic CSS, 25 basic events, 31 basic HTML, 24 data layer, 26 overview of, 24 current web page, 18 preliminary mock-up, 19 project goals, 18 star rating/voting system, 108 synchronizing state in basic sync and fetch, 87 fetching remote movies, 84 goals of, 83 user interface DRYer views/ViewModels, 46 goals for, 35 handling UI events, 43 interfacing the DOM, 36–43 referencing jQuery, 35 N Navbar view, 123 navigate function, 54 navigation view (navbar), 123 NeXTSTEP operating system, 22 noBackend providers, 94, 98 Node.js installation of, 157 package manager, 2 read-eval-print-loop (REPL), 15 nodes (see DOM nodes) non-relational data stores, 98 npm (Node package manager), 2, 8 O object-relational-mapper (ORM), 98 objects customizing interfaces of, 160 rendering within templates, 160 open-source software, 4 P package managers, 13 pagination, 68 parent views, 56 passwords, 113 (see also authentication) persistence, 101, 108 primary keys, 107 private functions, 28 productivity, improving, 135 (see also workflow automation) promises, 103 proxies, 98 publish-subscribe pattern, 31 pushState(), 50 R React.js, 77 read-eval-print-loop (REPL), 15, 29 relational databases, 98 render function, 37 Rendr, 146 representations in RESTful web services, 85 with models, 21 RequireJS adding modules, 142 benefits of, 140 main.js file, 141 RESTful web services, 84 Restify library, 100 router basics addressing state defining routes, 51 goal of, 49 navigating, 54 preparing, 50 orchestrating views Layout View, 55 parent/child views, 56 overview of, 49 S security, 113 (see also authentication) session management Backbone applications API calls, 118 login dialog, 129 modal view, 125 navbar view, 123 cookies, 118 Index | 169 creating new, 131 logout, 132 set function, 28 signing requests approaches to, 114 benefits of, 114 sorting, 62 Sprockets, 13 state addressing with routers defining routes, 51 goal of, 49 navigating, 54 preparing, 50 authentication and, 131 decoupling from UI benefits of, 22 models and collections, 21 MVC pattern, 22 need for, 19 views, 22 synchronizing basic sync and fetch, 87 fetching remote information, 84 overview of, 83 statelessness, 19, 84 Stitch, 13 T tagName property, 37 template property, 41, 75 templates embedded CoffeeScript, 75 Handlebars, 76 JavaScript Templates, 74 overview of, 73 Thorax.js benefits of, 145 getting started application initialization, 150 build tasks, 147 installation/setup of, 147 mock data preparation, 149 overview of, 146 rendering advanced views, 154 Router setup, 152 Thorax.Collection, 152 TodoMVC demo, 24 tokens, access, 114 170 | Index U Ubuntu, Node.js installation, 157 Underscore.js benefits of, 158 collections/arrays, 158 functions, 159 objects, 160 utility functions, 160 user interface decoupling from state benefits of, 22 models and collections, 21 MVC pattern, 22 need for, 19 views, 22 DRYer views/ViewModels, 46 goals for, 35 handling UI events, 43 interfacing the DOM basic rendering, 37 basic view templates, 41 bindings to data changes, 39 rendering a collection, 42 strategy overview, 36 referencing jQuery, 35 V ViewModels, 46 views advanced view templates, 73 Backbone views, 22 data display management with, 23 DRYer view/ViewModels, 46 Layout View, 55 modal view, 125 MVC pattern, 22 navbar view, 123 parent/child views, 56 updating immediately, 39 welcome view, 59 vulnerabilities cross-site request forgery (CSRF), 114 cross-site scripting (XSS), 114 W Walmart’s shopping cart, 147 welcome view, 59 Windows, Node.js installation, 157 wireframes benefits of, 19 creating, 18 workflow, automation of (see build automation) X benefits of, 136, 138 installation of, 138 running, 139 Z Zepto library, 2, 160 XMLHttpRequest object, 163 Y Yeoman application directory, 140 Index | 171 About the Author Before discovering software development for web applications with Java and Ruby in 2008, Patrick Mulder mainly worked as a software engineer on measurement equip‐ ment and electronic devices.

pages: 818 words: 153,952

C++ Concurrency in Action: Practical Multithreading by Anthony Williams

Using synchronization of operations to simplify code Using the synchronization facilities described so far in this chapter as building blocks allows you to focus on the operations that need synchronizing rather than the mechanics. One way this can help simplify your code is that it accommodates a much more functional (in the sense of functional programming) approach to programming concurrency. Rather than sharing data directly between threads, each task can be provided with the data it needs, and the result can be disseminated to any other threads that need it through the use of futures. 4.4.1. Functional programming with futures The term functional programming (FP) refers to a style of programming where the result of a function call depends solely on the parameters to that function and doesn’t depend on any external state.

Making (std::)promises 4.2.4. Saving an exception for the future 4.2.5. Waiting from multiple threads 4.3. Waiting with a time limit 4.3.1. Clocks 4.3.2. Durations 4.3.3. Time points 4.3.4. Functions that accept timeouts 4.4. Using synchronization of operations to simplify code 4.4.1. Functional programming with futures 4.4.2. Synchronizing operations with message passing 4.5. Summary Chapter 5. The C++ memory model and operations on atomic types 5.1. Memory model basics 5.1.1. Objects and memory locations 5.1.2. Objects, memory locations, and concurrency 5.1.3. Modification orders 5.2.

This is such a powerful simplification that programming languages such as Haskell,[2] where all functions are pure by default, are becoming increasingly popular for programming concurrent systems. Because most things are pure, the impure functions that actually do modify the shared state stand out all the more, and it’s therefore easier to reason about how they fit into the overall structure of the application. 2 See http://www.haskell.org/. The benefits of functional programming aren’t limited to those languages where it’s the default paradigm, however. C++ is a multiparadigm language, and it’s entirely possible to write programs in the FP style. This is even easier in C++11 than it was in C++98, with the advent of lambda functions (see appendix A, section A.6), the incorporation of std::bind from Boost and TR1, and the introduction of automatic type deduction for variables (see appendix A, section A.7).

pages: 489 words: 117,470

Programming in Lua, Fourth Edition by Roberto Ierusalimschy

Instead of a one-size-fits-all solution, Lua offers us a meta-mechanism, so that we can tailor our environment for our specific security needs. (Real sandboxes do more than protecting external files. We will return to this subject in the section called “Sandboxing”.) A Taste of Functional Programming To give a more concrete example of functional programming, in this section we will develop a simple system for geometric regions.[11] The goal is to develop a system to represent geometric regions, where a region is a set of points. We want to be able to represent all kinds of shapes and to combine and modify shapes in several ways (rotation, translation, union, etc.).

The External World The Simple I/O Model The Complete I/O Model Other Operations on Files Other System Calls 8. Filling some Gaps Local Variables and Blocks Control Structures break, return, and goto II. Real Programming 9. Closures Functions as First-Class Values Non-Global Functions Lexical Scoping A Taste of Functional Programming 10. Pattern Matching The Pattern-Matching Functions Patterns Captures Replacements Tricks of the Trade 11. Interlude: Most Frequent Words 12. Date and Time The Function os.time The Function os.date Date–Time Manipulation 13. Bits and Bytes Bitwise Operators Unsigned Integers Packing and Unpacking Binary Data Binary files 14.

Together, these two features give great flexibility to the language; for instance, a program can redefine a function to add new functionality or erase a function to create a secure environment when running a piece of untrusted code (such as code received through a network). More importantly, these features allow us to apply in Lua many powerful programming techniques from the functional-language world. Even if you have no interest at all in functional programming, it is worth learning a little about how to explore these techniques, because they can make your programs smaller and simpler. Functions as First-Class Values As we just saw, functions in Lua are first-class values. The following example illustrates what that means: a = {p = print} -- 'a.p' refers to the 'print' function a.p("Hello World") --> Hello World print = math.sin -- 'print' now refers to the sine function a.p(print(1)) --> 0.8414709848079 math.sin = a.p -- 'sin' now refers to the print function math.sin(10, 20) --> 10 20 If functions are values, are there expressions that create functions?

pages: 262 words: 60,248

Python Tricks: The Book by Dan Bader

You can assign them to variables, store them in data structures, pass them as arguments to other functions, and even return them as values from other functions. Grokking these concepts intuitively will make understanding advanced features in Python like lambdas and decorators much easier. It also puts you on a path towards functional programming techniques. Over the next few pages I’ll guide you through a number of examples to help you develop this intuitive understanding. The examples will build on top of each other, so you might want to read them in sequence and even to try out some of them in a Python interpreter session as you go along.

It allows you to abstract away and pass around behavior in your programs. In this example, the greet function stays the same but you can influence its output by passing in different greeting behaviors. Functions that can accept other functions as arguments are also called higher-order functions. They are a necessity for the functional programming style. The classical example for higher-order functions in Python is the built-in map function. It takes a function object and an iterable, and then calls the function on each element in the iterable, yielding the results as it goes along. Here’s how you might format a sequence of greetings all at once by mapping the bark function to them: >>> list(map(bark, ['hello', 'hey', 'hi'])) ['HELLO!'

Functions Can Capture Local State You just saw how functions can contain inner functions, and that it’s even possible to return these (otherwise hidden) inner functions from the parent function. Best put on your seat belt now because it’s going to get a little crazier still—we’re about to enter even deeper functional programming territory. (You had that coffee break, right?) Not only can functions return other functions, these inner functions can also capture and carry some of the parent function’s state with them. Well, what does that mean? I’m going to slightly rewrite the previous get_speak_func example to illustrate this.

pages: 692 words: 95,244

Speaking JavaScript: An In-Depth Guide for Programmers by Axel Rauschmayer

On the other hand, it has several powerful features that allow you to work around these problems. In other languages, you learn language features. In JavaScript, you often learn patterns instead. Given its influences, it is no surprise that JavaScript enables a programming style that is a mixture of functional programming (higher-order functions; built-in map, reduce, etc.) and object-oriented programming (objects, inheritance). Syntax This section explains basic syntactic principles of JavaScript. An Overview of the Syntax A few examples of syntax: // Two slashes start single-line comments var x; // declaring a variable x = 3 + y; // assigning a value to the variable `x` foo(x, y); // calling function `foo` with parameters `x` and `y` obj.bar(3); // calling method `bar` of object `obj` // A conditional statement if (x === 0) { // Is `x` equal to zero?

I’ve written fair amounts of code in several programming languages from different paradigms. Therefore, I’m well aware that JavaScript isn’t the pinnacle of elegance. However, it is a very flexible language, has a reasonably elegant core, and enables you to use a mixture of object-oriented programming and functional programming. Language compatibility between JavaScript engines used to be a problem, but isn’t anymore, partly thanks to the test262 suite that checks engines for conformance to the ECMAScript specification. In contrast, browser and DOM differences are still a challenge. That’s why it is normally best to rely on frameworks for hiding those differences.

For example, you can freely add and remove properties (fields) of objects after they have been created. And you can directly create objects, without creating an object factory (e.g., a class) first. It’s dynamically typed Variables and object properties can always hold values of any type. It’s functional and object-oriented JavaScript supports two programming language paradigms: functional programming (first-class functions, closures, partial application via bind(), built-in map() and reduce() for arrays, etc.) and object-oriented programming (mutable state, objects, inheritance, etc.). It fails silently JavaScript did not have exception handling until ECMAScript 3. That explains why the language so often fails silently and automatically converts the values of arguments and operands: it initially couldn’t throw exceptions.

Reactive Messaging Patterns With the Actor Model: Applications and Integration in Scala and Akka by Vaughn Vernon

It also doesn’t mean that sequential processes can’t execute other sequential processes because we’ve had that ability even in the mainstream for several decades. Yet, those newly spawned sequential processes are still static and capable of doing only what their build generated them to do. On the other hand, the Actor model can employ both sequential and functional programming techniques in a highly dynamic environment, where actors come and go as needed, and can even alter their behavior on the fly as the domain or operational environment demands. That is, reactive systems are not only concurrent and distributed but also elastic, dynamic, responsive, and resilient.

Since you don’t get Scala for free with Gradle, you will have to drag in the Scala compiler, which you don’t have to do when you use sbt. Still, that’s just a few lines of code. Programming with Scala If you work in Java and you haven’t yet learned Scala, you should. Of all JVM languages other than Java itself, Scala has the greatest uptake. With a mixture of unobtrusive object-oriented and functional programming facilities, it’s hard to imagine not finding the tools you want and need to code better and faster. Back in the early to late 1980s, I was programming in C and C++ and had also spent a bit of time with Smalltalk. I liked Smalltalk a lot, and I kept trying to find ways to make C++ more like Smalltalk.

I purposely avoid an exhaustive treatment on the Scala programming language. I do provide a simple tutorial on some of the Scala basics, preparing you to read code in this book, and even get started programming in Scala yourself. If you are already familiar with an object-oriented language such as Java or C# and possibly have even studied a bit about functional programming or used a functional language, you should find Scala pretty easy to pick up. If you want to learn Scala quickly, I recommend getting the book Atomic Scala by Bruce Eckel and Dianne Marsh [Atomic-Scala]. Others find Scala for the Impatient [Horstmann] to be “the best compact introduction to Scala,” including Scala’s creator, Martin Odersky.

pages: 474 words: 91,222

Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library by Scott Meyers

To see what I mean, here is the same statement, but with all the function names replaced by fn, each n corresponding to one of the functions: v.f1(f2(f3(v.f4(), v.f5(), f6(f7(), y)).f8(), v.f9(), f6(f10(), x)), v.f9()); This looks unnaturally complicated, because I’ve removed the indentation present in the original example, but I think it’s safe to say that any statement involving twelve function calls to ten different functions would be considered excessive by most C++ software developers. Programmers weaned on functional languages such as Scheme might feel differently, however, and my experience has been that the majority of programmers who view the original code without raising an eyebrow have a strong functional programming background. Most C++ programmers lack this background, so unless your colleagues are versed in the ways of deeply nested function calls, code like the erase call above is almost sure to confound the next person who is forced to make sense of what you have written. The second drawback of the code is the significant STL background needed to understand it.

As I noted, some C++ programmers think nothing of the code in this Item. If that’s typical in the environment in which you work and you expect it to be typical in the future, feel free to unleash your most advanced STL programming inclinations. However, if your colleagues are less comfortable with a functional programming style and are less experienced with the STL, scale back your ambitions and write something more along the lines of the two-statement alternative I showed earlier. It’s a software engineering truism that code is read more often than it is written. Equally well established is that software spends far more time in maintenance than it does in development.

., for sorted ranges 197 related functions vs. 192–201 equal_to 86, 112 equality definition of 84 equivalence vs. 83–88 in hashed containers 113 implying inequivalence 92 lower_bound and 195 equivalence definition of 84–85 equality vs. 83–88 in hashed containers 113 lower_bound and 195 equivalent values, inserting in order 198 erase see also erase-remove idiom 43 relation to remove algorithm 139–143 return types for 32 return value for standard sequence containers 46 erase_after 218 erase-remove idiom 43, 47, 142, 145, 146, 184, 207 limitations of 46 list::remove vs. 43 remove_if variant 144 erasing see also container erasing base iterators and 124 elements in containers 43–48 rolling back 14 via range member functions 32 errata list for Effective C++ 228 for Effective C++ CD 228 for More Effective C++ 228 for this book xii error messages, deciphering 210–217 example classes/templates Average 205 BadPredicate 167, 168 BetweenValues 188, 189 BPFC 164, 165 BPFCImpl 165 CIStringCompare 85 Contestant 77 CustomerList 20 DataCompare 105 DeleteObject 37, 38 Dereference 90 DereferenceLess 91 DoSomething 163 Employee 95 Heap1 57 Heap2 57 IDNumberLess 96 list 52 list::ListNode 52 Lock 60 lt_nocase 231 lt_str_1 235 lt_str_1::lt_char 235 lt_str_2 236 lt_str_2::lt_char 236 MaxSpeedCompare 179 MeetsThreshold 171 NiftyEmailProgram 212, 215 Person 198 PersonNameLess 198 Point 159, 161 PointAverage 160, 161 PtrWidgetNameCompare 172 RCSP 146 SharedMemoryAllocator 55 SpecialAllocator 19, 49 SpecialContainer 240 SpecialString 37 SpecialWidget 21 SpecificHeapAllocator 57 std::less<Widget> 178 StringPtrGreater 93 StringPtrLess 89 StringSize 204 Timestamp 197 vector 240 Widget 7, 18, 19, 21, 35, 84, 106, 111, 143, 174, 177, 182, 222 WidgetNameCompare 171 example functions/templates anotherBadPredicate 169 average 204 Average::operator() 205 BadPredicate::BadPredicate() 167 BadPredicate::operator() 167, 168 BetweenValues::BetweenValues 188 BetweenValues::operator() 188 BPFC::operator() 164, 165 BPFCImpl:: BPFCImpl 165 BPFCImpl::operator() 165 ciCharCompare 151 ciCharLess 153 ciStringCompare 152, 153, 154 CIStringCompare::operator() 85 ciStringCompareImpl 152 copy_if 155, 156 DataCompare::keyLess 105 DataCompare::operator() 105 delAndNullifyUncertified 145 DeleteObject::operator() 37, 38 Dereference::operator() 90 DereferenceLess::operator() 91 doSomething 36, 37, 38, 39, 74, 75, 77 DoSomething::operator() 163 doubleGreater 202 efficientAddOrUpdate 110 Employee::idNumber 95 Employee::name 95 Employee::setName 95 Employee::setTitle 95 Employee::title 95 fillArray 76, 77, 184 fillString 76 hasAcceptableQuality 137 Heap1::alloc 57 Heap1::dealloc 57 IDNumberLess::operator() 96 isDefective 155 isInteresting 169 lastGreaterThanFirst 8 Lock:: Lock 60 Lock::Lock 60 lt_nocase::operator() 231 lt_str_1::lt_char::lt_char 235 lt_str_1::lt_char::operator() 235 lt_str_1::lt_str_1 236 lt_str_1::operator() 236 lt_str_2::lt_char::lt_char 236 lt_str_2::lt_char::operator() 236 lt_str_2::lt_str_2 237 lt_str_2::operator() 237 MaxSpeedCompare::operator() 179 MeetsThreshold::MeetsThreshold 171 MeetsThreshold::operator() 171 NiftyEmailProgram::showEmailAddress 212, 215 operator< for Timestamp 197 operator< for Widget 177 operator== for Widget 8, 84 Person::name 198 Person::operator() 198 Point::Point 159 PointAverage::operator() 160, 161 PointAverage::PointAverage 160, 161 PointAverage::result 161 print 90 PtrWidgetNameCompare::operator() 172 qualityCompare 134 SharedMemoryAllocator::allocate 55 SharedMemoryAllocator::deallocate 55 SpecificHeapAllocator::allocate 57 SpecificHeapAllocator::deallocate 57 std::less<Widget>::operator() 178 stringLengthSum 158 StringPtrGreater::operator() 93 stringPtrLess 91 StringPtrLess::operator() 89 StringSize::operator() 204 test 174 transmogrify 129, 220 vector<bool>::operator[] 80 vector<bool>::reference 80 Widget::isCertified 143 Widget::maxSpeed 177 Widget::operator= 21, 106, 111 Widget::readStream 222 Widget::redraw 182 Widget::test 174 Widget::weight 177 Widget::Widget 21, 106 widgetAPCompare 41 WidgetNameCompare::operator() 171 writeAverages 204, 205 exception safety 14, 37, 39, 50, 61 Exceptional C++ 14, 165 bibliography entry for 226 exceptions, to guidelines in this book 10 explicit template argument specification distance and 122 for_each and 163 use_facet and 234 extending the STL 2 F facets, locales and 234–235 find count in multiset, multimap vs. 199 lower_bound in multiset, multimap vs. 201 related functions vs. 192–201 using equivalence vs. equality 86 first_argument_type 170 for_each declaration for 163 explicit template argument specification and 163 possible implementation of 174 side effects and 160 forward iterators definition of 5 operator-- and 5 fragmentation, memory, reducing 54 fraud, in allocator interface 51 free STL implementations 217, 220 front_insert_iterator 216 front_inserter 130, 216 push_front and 130 Fuller, John xviii function objects as workaround for compiler problems 204 definition of 5 dereferencing, generic 90 for accumulate 158 functions vs. 201–205 monomorphic, definition of 164 pass-by-value and 162–166 slicing 164 functional programming 206 functions calling forms 173 calling syntax in the STL 175 comparison equal values and 92–94 for pointers 88–91 declaration forms 33–35 declaring templates in 188 function objects vs. 201–205 in <cctype>, conventions of 151 in <ctype.h>, conventions of 151 pointers to, as formal parameters 34 predicates, need to be pure 166–169 pure, definition of 166 range vs. single-element 24–33 functor classes adaptability and 169–173 classes vs. structs 171 definition of 5 overloading operator() in 114 pass-by-value and 162–166 functor, see function objects G Gamma, Erich 226 see also Design Patterns Generic Programming and the STL 2, 94, 217, 229 bibliography entry for 226 gew rztraminer 232 glass, broken, crawling on 95, 97 Glassborow, Francis xvii Green, Cliff xvii growth factor, for vector/string 66 H hand-written loops algorithms vs. 181–189 iterator invalidation and 185 Hansen, Karin xviii Harrison, Doug xvi, xvii hashed containers 111–115 Dinkumware interface for 113 equality vs. equivalence in 113 SGI interface for 112 two implementation approaches to 114 headers #includeing the proper ones 209–210 <algorithm> 210 <cctype> 151 <ctype.h> 151 <functional> 210 <iterator> 210 <list> 209 <map> 209 <numeric> 210 <numeric> 157 <set> 209 <vector> 209 failing to #include 217 summary of 209–210 heaps, separate, allocators and 56–58 Helm, Richard 226 see also Design Patterns Henney, Kevlin xvi “hint” form of insert 100, 110 How the Grinch Stole Christmas!

pages: 408 words: 85,118

Python for Finance by Yuxing Yan

Python is available for all major operating systems such as Windows, Linux/Unix, OS/2, Mac, and Amiga, among others. Thirdly, Python is suitable for Big Data. Dasgupta (2013) argues that R and Python are two of the most popular open source programming languages for data analysis. Compared with R, Python is generally a better overall language, especially when you consider its blend of functional programming with object orientation. Combined with Scipy/Numpy, Matplotlib, and Statsmodel, it provides a powerful tool. In this book, we will discuss a module called Pandas when we deal with financial data. Fourthly, there are many useful modules for Python, such as toolboxes in MATLAB and packages in R.

The second way to input values is based on key words. The advantage of this so-called key word method is that the order of input values does not play a role anymore. This could reduce our careless mistakes because we don't have to remember the input order when we call a function. This is especially true when we are dealing with many functions (programs) written by different developers/authors: >>>pv_f(r=0.1,fv=100,n=1) 90.9090909090909 >>>pv_f(n=1,fv=100,r=0.1) 90.9090909090909 • The third way is the combination of the preceding two methods: ordered input first and then inputs with keywords, as shown in the following code: >>>pv=pv_f(100,r=0.1,n=1) >>>pv2=pv_f(100,n=1,r=0.1) A word of caution is that the third method is the ordered inputs first, then input(s) with key words, and not the other way around.

Note that the return value is a1 instead of x. Click on Run and then click on Run from module F5; you will see that the following line appears: >>>===========RESTART ================== 7. We could test this program by entering any value. Here is an example: >>>CND(1) 0.31938153 8. Repeat the previous step until we complete this CND() function (program) as shown in the following code: from math import * def CND(X): [ 73 ] 13 Lines of Python to Price a Call Option (a1,a2,a3,a4,a5)=(0.31938153,-0.356563782,1.781477937, -1.821255978,1.330274429) L = abs(X) K=1.0/(1.0+0.2316419*L) w=1.0-1.0/sqrt(2*pi)*exp(-L*L/2.)*(a1*K+a2*K*K+a3*pow(K,3) +a4*pow(K,4)+a5*pow(K,5)) if X<0: w = 1.0-w return w 9.

pages: 246 words: 16,997

Financial Modelling in Python by Shayne Fletcher, Christopher Gardner

Derived 209–11 dictionaries, Python basics 119–22, 181, 196–7, 215–16 dimensions 24–6 discount-factor functions see also curves concepts 3, 6, 63–7, 97–8, 100–22, 131–42, 146–57, 217–18 Hull–White model 100–22, 146–57 discount factor 100–22 226 Index doctest testing module, concepts 6–7 dot 38–9, 42–4 duration 78–9, 80–2, 86–91, 96–8, 120–2, 178–87 dynamic type system of Python 2–3 early exercise premiums 4, 85–91, 132–3, 219–20 elem 83–5 elif examples 14–16, 30–1, 35–7 else statements, Python basics 199–200 embedding, Boost.Python library 161–3, 214–16 encapsulation support, Python 2–3, 58–61, 209 end 80–91, 96–8, 120–2, 177–87 endif 19–23 end of start year 16 enforce no exercise stubs 90, 125–8, 129–42 enforce single currency 90–1 enum types 14–16, 214 env 67, 97–8, 100–22, 125–8, 129–42, 146–57 env id 188–9 environment 65–7, 97–8, 100–22, 169–76 see also common market information; curves; surfaces epsilon 18–19 equal range 30–1, 55–7 equity spot prices 63, 69–70 errors.hpp 20 Essential COM 165 Euler’s scheme 113–14 EUR 70, 87–91 European options 5–9, 149–52 see also options europeans 150–2 european symbol table listener 128, 150–2 evaluate regression 133–42 event 93–8, 126–8, 130–42, 146–57 events see also timeline concepts 93–8, 126–8, 129–42, 146–57 definitio 93 event type 93–4 evolve 112–22, 129–42 evolve component, pricing models 112–15, 129–42 except 27–8 exercise 85–91, 94–8, 115–22, 132–42, 177–87 exercise component, pricing models 115–22, 123–8 exercise dates 88–91 exercise schedules concepts 88–91, 177, 179–87 definitio 69 exercise boundary regression 137–42 exercise date 86–91 exercise event 93–8, 138–42 exercise helper 134–42 exercise info 88–91 exercise opportunity 94–8 exercises see also notificatio dates concepts 3, 69, 85–91, 93–8, 115–22, 123–8, 131–42, 176–87, 219–20 definitio 69, 85–7 early exercise premiums 4, 85–91, 132–3, 219–20 exercise schedule 88–91, 95–8, 180–7 exercise type 86–91, 94–8, 120–2, 142, 150–2, 180–7 exotic financia instruments, pricing approaches 99, 123–8, 145–57 exotic first flow pv 156 exp 28–9, 52–61, 109–22, 170–6 expectation calculations see also integration concepts 3, 49–61, 108–9 conditional expectations 57–61 expected libor 117–22 expected swap 117–22 Expecting 6–7 expect non null 21–6 expiries 64–7, 101–22, 170–6 explanatory variables 135–42, 150–2 expressiveness aspects of Python 1 ex sched 88–91, 96–8, 120–2, 150–2 extensibility aspects of Python 1–4, 7–9, 11–26 extract 162–3, 215–16 fabs 37, 60–1, 114–22 factors 63–7, 109–22 factory 151–2, 155–6, 188–9 factory classes 119–22, 151–2, 155–6, 188–9 fee 85–7 fee ccy 85–7 fill 45–6, 101–22, 133–42, 146–57 fille component, pricing models 45–6, 101–22, 133–42, 146–57 filtratio 57–61, 145–52, 217–18 final date 89–91 final important date 88–91 financia contracts see also trades concepts 69, 88–91 financia engineering, Python uses 1–4, 11–26 financia instruments see also bonds; derivatives; options; swap... path-dependency issues 99, 123–43, 157 Index pricing approaches 99, 108–9, 123–43, 145–57 types 99, 123–8 financia payoffs 49–61, 85–6, 98, 145–56, 176–87 finit differences 123 see also lattice-based pricing framework first axis 64–5 first imm after 14 first imm before 13–14 fit 133–42 fit fos 44–6, 133–42 fitted fos 132–42 fix 70–9, 105–22, 147–57 fi ed leg, swaps 74–9, 145–52, 181–7 fixed flows 75–9, 105–22 fixed leg payoff 145–52, 181–7 fixed pay basis 75–9 fixed pay holiday centres 75–9 fixed period... 75–9 fixed pv 77, 106–22, 149–52 fixed rate 145–57 fixed shift convention 75–9 fixing 69–79, 147–57 float 43–4, 212 float flows 75–9, 106–22 floatin leg, swaps 74–9, 145–52, 181–7 floatin point numbers, Python basics 194–6 float leg payoff 146–57, 181–7 float pay basis 75–9 float pay holiday centres 75–9 float period... 75–9 float pv 106–22, 149–52 float shift convention 75–9 floor 155–6 flow 79–83, 93–8, 146–57, 177–87 flow id 69–79 flows 79–83, 85–6, 88–9, 90–1, 93–8, 105–22, 123–43, 146–57, 177–87 fl ws see also legs; observables concepts 3, 6, 69, 79–83, 88–91, 93–8, 105–42, 176–87 definitio 69, 74, 79 for statements, Python basics 197–200 foreign exchange rates 63, 70–9, 80–3, 86–7, 90–1, 93–8, 105–22, 135–42, 146–57, 177–87 see also reset currencies Fortran 77/90 19 forward 72–9, 149–57 forward contracts 72–9, 104–5 fos 132–42 fsT 60–1 ftT 57–61 functional programming idioms, Python support 1 227 functionally orthogonal components, Hull–White model 99–122 functions Boost.Python library 212–14 overloaded functions 212–14 Python basics 2–3, 200–1 funding first flow pv 156 funding leg... 148–57 fund pv 77 gauss 27–8, 46, 113–22 Gaussian distributions 27–8, 46, 51–7, 102–22 GBP 70–9 generalized linear least squares, concepts 3, 44–6, 133–42 generalized least squares 44–6, 133–42 GenerateAdjuvantTable 177, 179–87 generate adjuvant table 82–4, 147–52, 153–6, 179–87 GenerateExerciseSchedule 177, 179–87 generate exercise table 86–91, 95–8, 120–2, 151–2 GenerateFixedCoupon Observables 177, 181, 182 generate fixed coupon observables 89–1, 96–8, 120–2 GenerateFlows 177, 181, 184–5 generate flows 74–9, 80–3, 89–1, 96–8, 120–2, 178–87 GenerateLiborCoupon Observables 181 GenerateLiborObservables 177–8, 181, 182–3 generate libor observables 72–9, 89–91, 96–8, 178–87 generate observables 72–9, 95–8, 120–2 generate swap observables 77–9 get 22–6, 94–8, 114–22 get adjuvant table 147–52, 153–6 get date 13–16, 160–3 get environment 97–8, 146–57 get event 97–8, 146–57 get model 97–8, 146–57 getopt 27–8 get override 160–3 Getting Started Tutorial, Boost.Python library 207 get trade 97–8, 154–6 Girsanov’s theorem 218 GNUPlot 2 the Greeks 142–3 gregorian 160–3 228 Index gregorian calendar base 15–16, 160–3 GUI toolkits, Python integration benefit 2 Hammond, Mark 165 handle zero derivative 36–7 has constant 66–7 has curve 66–7 has exercise schedule 131–42 has key 94–8 has surface 66–7 ‘Hello World’ C++ function, Boost.Python library 207 help 27–8 helper functions 93–8, 161–3 high-bias estimators 131–2 high-level aspects of Python 1 historical df 97–8, 146–57 holiday centres 15–16, 75–84, 86–8 holidays 14–16, 75–84 Hull–White model 3–4, 6, 65–7, 99–122, 145–57, 168–89, 217–18 brief outline 217–18 calibration routine 100–1 component-based design 99–122 concepts 4, 99–122, 145–57, 168–89, 217–18 constants 65–7 evolve component 112–15 exercise component 115–22 fille component 101–22, 146–57 functionally orthogonal components 99–122 mathematics 4, 99–100, 217–18 Microsoft Excel 168–89 model factories 118–22, 149–52, 155–6, 188–9 requestor component 100–22 rollback component 108–12 state component 101–22, 145–52 hull white... 67, 100–22, 151–2, 155–6, 188–9 hull white monte carlo model factory 121, 151–2, 155–6, 188–9 hwmodel 121–2 hybrid financia instruments, pricing approaches 99 ‘Hybrid Systems’ 4, 159–63 if statements, Python basics 199–200 IMM dates, concepts 12–16, 159–63 immutable types, Python basics 195–7 impl 63–7 import directive, Python basics 203–5 import array 23–4 in-the-money option prices 150–2 incremental distribution 102–22 incremental fill 102–22 incremental vol 102–22 indented code, Python basics 198–200 Indexable concepts 3 indicator 54–7, 134–42, 154–6 inflatio rates 104–5 information, common market information 3, 63–7, 69, 99–100, 169–76, 177–87 inheritance, Python basics 122, 202–3, 209–11 init 31–4, 51–7, 63–7, 69–91, 97–8 input 21–2 insert symbol 97–8, 125–8, 130–42 install 9 installing ppf packages, concepts 7–9 integers, Python basics 194–6 integral 51–7 integral indicator 54–7 integral max 55–61 integration Brownian motion 57–61 concepts 49–61 piecewise constant polynomial fittin 49–51, 57–61 piecewise polynomial integration 51–61 semi-analytic conditional expectations 57–61 integrator 58–61, 108–22 integrator tests 59–61 interactive interpreter mode, Python 193–4 interest rates 6, 69–70, 70–9, 89–91, 101–2, 104–22, 143, 145–56, 177–87 LIBOR rate 6, 69, 70–9, 89–91, 104–22, 143, 145–56, 177–87 swap rates 70–9, 104–5 international money market 12–16, 159–63 see also IMM... interoperability aspects of Python 1–4, 7–9, 11–26, 157 interp 63–7 interpolation... 31–4, 63–7, 106–22, 170–6 interpolation schemes see also curve... concepts 3, 29–34, 63–7, 106–22, 170–6 cubic spline interpolation 33–4, 171–6 linear interpolation 31–3, 171–6 linear on zero interpolation 32–3, 171–6 loglinear interpolation 32–4, 106–22, 171–6 interpolation base 31–4 interpreters 2, 24–6, 45–6, 193–4, 208–9 inv 38–9 inverse floater 115–16 InvokePricer 189 is business day 15–16 is exercise event 138–42 is last flow 153–6 is pay event 138–42 Index JPY 73–9, 81–3, 89–91, 96–8 key 66–7, 100–22, 148–57 keys, Python basics 196–7 Kiusalaas, Jaan 38 Kolmogorov’s strong law of large numbers 129 lags, LIBOR rates 70–9 lambda 19, 31, 36–7, 133–42, 152–6, 188–9 Langtangen, Hans Peter 2 last important date 69–79 lattice 102–3, 108–22, 124–8 lattice-based pricing framework 3, 6, 49–51, 67, 99, 101–22, 123–31, 142–3, 149–52, 168–89 concepts 99, 102–3, 108–22, 123–31, 142–3, 149–52, 168–89 rollback 108–22, 124–8 lattice pricer 125–8, 188–9 leg 84–5, 90–1, 94–8, 120–2, 126–8, 130–42, 148–57, 177–87 leg id 93–8, 150–6 leg pv 126–8, 131–42 legs 88–91, 95–8, 130–42, 177–87 legs see also fl ws concepts 3, 69, 74–9, 84–5, 88–91, 93–8, 120–2, 125–8, 130–42, 148–57, 176–87 definitio 69, 84 swaps 74–9 len 43–6, 50–1, 52–7, 81–5, 133–42 leverage 156 libor 147–57 LIBOR rate 6, 69, 70–9, 89–91, 104–22, 123–8, 143, 145–56, 177–87 concepts 70–9, 104–22, 123–8, 143, 145–52 definitio 71 libor basis 75–9 libor holiday centres 75–9 libor observables 96–8, 105–22 libor rate 70–9 libor shift convention 75–9 likelihood ratios 143 LIMITS 17–18 linalg 38–44 linear 31–4, 45–6 linear algebra 3, 17–19, 33–4, 38–44, 49–51 concepts 38–44 matrix inversion 38–9 matrix multiplication 38 matrix pseudo-inverse 39 singular value decomposition of a matrix 42–6 solving linear systems 39–40 solving tridiagonal systems 2–3, 34, 39–40 solving upper diagonal systems 17–19, 40–4, 49–51 229 linear equations 17–19, 33–4 linear interpolation see also interpolation schemes concepts 31–3, 171–6 linear on zero interpolation see also interpolation schemes concepts 32–4, 171–6 linear algebra 31, 34, 40–1, 50–1 linear fo 132–42 linear on zero 32–4 linspace 111–22 Linux 8 list comprehensions, Python basics 196–7 lists, Python basics 3, 196–7, 215 local volatility, Hull–White model 100–22 local vol 101–22 locate 31–4 log 32–4 loglinear 32–4, 63–7, 106–22 loglinear interpolation see also interpolation schemes concepts 32–4, 106–22, 171–6 lognormal distributions, random number generation 27–8 lognormal martingale test 59–61 lognormvariate 27–8 Longstaff, F.A. 219 low-bias estimators 131–2 lower bound 29–31, 52–7 main 162–3, 166–8, 214–16 make array 23–6 market 6, 63–7, 101–22, 169–76 market server, COM servers 169–76 MarketServer COM component 169–76, 181, 188–9 market server 169–76, 188–9 Markovian models 123–8 martingales 59–61, 110–22, 145–52, 217–18 math 2–3, 6–9, 17–19, 23–6, 28–9, 31–4, 35–6, 40–1, 44–9, 50–61, 100–22, 132–42, 170–6, 205 mathematics 3, 4, 6–9, 23–6, 27–61, 99–102, 217–18 see also interpolation schemes; linear algebra basic tools 3, 27–61 concepts 27–61 cubic roots 3, 46–9, 53–7 generalized linear least squares 3, 44–6, 133–42 Hull–White model 4, 99–100, 217–18 integration 49–61 quadratic roots 3, 46–9 random number generation 3, 27–8, 45–6, 112–22 root-findin algorithms 3, 35–7 230 Index mathematics (cont.) standard normal cumulative distributions 3, 27–9, 31 Matlab 2 matrices 33–4, 38–44 see also linear algebra matrix 38, 41–4 matrix inversion, concepts 38–9 matrix multiplication, concepts 38 matrix pseudo-inverse, concepts 39 max 135–42, 152–6 max dim 21–2 max flt 35–7 max its 35–7 mean 51–61, 114–22, 127–8, 131–42 mean reversion 65–7 mean/variance 114–15 memory management issues, Python benefit 1 Mersenne Twister 19939 (MT19939) 27 methods Boost.Python library 207–9 Python basics 201 Microsoft Excel 4, 165–89 Microsoft Excel VBA 165, 167–8, 172–4, 181, 188–9 Microsoft VBScript 167–8 Microsoft Visual Studio C++ compiler versions 8 Microsoft Windows COM servers 4, 5–6, 98, 165–89 ppf package 8 min 152–6 min dim 21–2 mingw/gcc... 8 misconceptions about Python 2–3 model 97–8, 100–22, 124–8, 129–42, 146–57, 187–9 model factories Hull–White model 118–22, 149–52, 155–6, 188–9 Monte-Carlo simulations 121, 151–2, 155–6 model factories module 119–22 modified following 73–9, 80–2, 83–4, 86–91, 96–8, 111–22, 151–2 module.hpp 11–12 modules, Python basics 203–5 moments 52–7 moneyness tests 150–2 monotonic with target test 156–7 Monte-Carlo simulations callable trades 131–42 concepts 3, 4, 6, 99, 101–2, 108–22, 123, 128–43, 150–7, 219–20 evolve component 112–15, 129–42 exercise component 115–22 model factories 121, 151–2, 155–6 non-callable structures 129–31, 142–3 pricing framework 123, 128–43, 150–2 monte carlo... 112–22, 129–42, 150–2 months 64–5, 74–9, 89–91, 111–22, 159–63 MT19939 27 multi-asset products 123 multi array, concepts 17–19 MultiArray multidimensional array types 17–19 mut 59–61 mutable types, Python basics 195–7 muT 59–61 N 28–9, 31, 34, 52–7 see also standard normal cumulative distributions namespaces 2–3, 11–26, 160–3, 208–9, 215–16 ‘natural spline’ 34 Newton–Raphson root-findin method see also root-findin algorithms concepts 36–7 newton raphson 36–7 *NIX users 8 non-callable structures Monte-Carlo simulations 129–31, 142–3 pricing framework 129–31, 142–3 normal distribution 51–7, 59–61, 102–22 normalisation 137–42 notificatio dates, exercises 88–91, 95–8 notification date 85–91, 95–8 notional 79–82, 146–57 n quadratic fo 132–42 nt 58–61 nth imm of year 13–14, 159–63 nth kday of month 13–14, 159–63 nT 58–61 ntT 58–61 num... 133–42 numeraire 104–22, 135–42, 146–57 numeraire rebased bonds 67, 104–22, 146–57 numerical analysis 3–4, 27–61, 99–122, 123–43, 168–89 Numerical Methods in Engineering with Python (Kiusalaas) 38 numerical techniques 99–122, 123–43, 145–57, 168–89 see also Hull–White model; lattice-based...; Monte-Carlo... num explanatory variables 115–22 num obs 133–42 NumPy 3, 8–9, 19–26, 38–46, 50–1, 64–7, 102–22, 127–8, 133–42, 152–7 see also Python; SciPy Index C++ array data accesses 19–26 concepts 3, 8–9, 19–26, 38–44, 127–8, 152–3, 157 num sims 103–22, 150–2 NumStates 188–9 num states 188–9 num std dev 188–9 object as array impl 21–6 observable 70–9, 95–8, 104–22, 146–57, 177–87 observable base 69–79 observables see also common market information; fl ws concepts 3, 69–79, 89–90, 95–8, 100–1, 104–22, 146–57, 177–87 definitio 69–70 examples 69–70 LIBOR rate 6, 69, 70–9, 89–91, 104–22, 123–8, 143, 145–52 reset dates 69–79 swap rates 74–9, 104–5 operator 29–31 optimal exercise rule 131–42 options see also call...; financia instruments; put... at-the-money option prices 61 Black–Scholes option pricing formula 5–9, 28–9, 111–22, 165–8 early exercise premiums 4, 85–91, 132–3, 219–20 exercises 4, 85–91, 131–42, 219–20 in-the-money option prices 150–2 out-of-the-money option prices 150–2 pricing approaches 99, 108–9, 165–8 types 99 ordinates 31–4, 63–7 see also curves out-of-the-money option prices 150–2 overloaded functions, C++ 212–14 overview of the book 3–4 packages, Python basics 1, 203–5 partial proxy scheme 143 Pascal 201 path-dependency issues, pricing models 99, 123–43, 157 pathwise derivatives 143 pay currency 79–82, 90, 93–8, 120–2, 135–42, 146–57, 178–87 pay date 77–9, 79–82, 106–22, 146–57 pay df 146–57 pay event 93–8, 138–42 pay flows 96–8, 120–2 pay leg 90–1, 96–8, 120–2 payoff 85–6, 98, 145–56, 176–87 231 payoffs, path-dependency issues 99, 123–43, 157 pay or receive 84–5, 180–7 pay rcv 93–8 pay receive 84–5, 93–8, 120–2, 148–57 see also legs pay shift method 80–2, 178–87 PDE techniques 143 period 80–2, 86–91, 96–8, 120–2, 178–87 phiTTN 104–22 pickup value regression 132–42, 150–2, 219–20 pickup value regression 133–42 piecewise constant polynomial fittin see also integration concepts 49–51, 57–61 piecewise polynomial integration see also integration concepts 51–61 piecewise cubic fit 50–1 piecewise polynomial fitting 50–1 pointers, C++ 212–14 policies, concepts 121–2 polynomials 33–4, 37, 49–61 see also cubic spline...

.; mathematics; NumPy; ppf package basics 193–205 batch interpreter mode 193–4 benefit 1–4 built-in data types 1, 195–7 C++/Python ‘Hybrid Systems’ 4, 159–63 C API routines 19–26, 161–3 C/C++ interoperability benefit 2, 3–4, 7–9, 11–26, 157 class basics 2–3, 201–3 COM servers 4, 5–6, 98, 165–89 concepts 1–4, 193–205 control fl w statements 197–200 dictionaries 119–22, 181, 196–7, 215–16 dynamic type system 2–3 encapsulation support 2–3, 58–61, 209 expressiveness aspects 1 extensibility aspects 1–4, 7–9, 11–26 financia engineering 1–4, 11–26 function basics 2–3, 200–1 functional programming idioms 1 GUI toolkits 2 high-level aspects 1 indented code 198–200 inheritance basics 122, 202–3, 209–11 interactive interpreter mode 193–4 interoperability aspects 1–4, 7–9, 11–26, 157 interpreters 2, 24–6, 45–6, 193–4, 208–9 list basics 3, 196–7, 215 Microsoft Excel 4, 165–89 misconceptions 2–3 module basics 203–5 overview of the book 3–4 package basics 1, 203–5 productivity benefit 1 simple expressions 194–5 Index standard libraries 1 structure misconceptions 2–3 tuples 131, 195–7, 200–1, 215 visualisation software integration 2 whirlwind tour 193–205 white space uses 198–200 Python Distutils package 9 Python Programming on Win32 (Hammond & Robinson) 165 Python Scripting for Computational Science (Langtangen) 2 python.hpp 214–15 python -i command 193 PyUnit testing module, concepts 6–7, 9 quadratic roots, concepts 3, 46–9 quadratic fo 132–42 quadratic roots 46–9 quantitative analysis 1–4, 27–61, 123–43, 165–89 raise 15–16, 30–1, 35–6, 40–1, 43–5, 50–8, 66–7, 78, 81–3, 85–7, 88, 89, 91, 98, 102, 105–6, 113, 118–19, 131, 133, 134–6, 166–9, 170–6 random 27–8, 45–6 random number generation, concepts 3, 27–8, 45–6, 112–22 random variables, expectation calculations 3, 49–61 range function, Python basics 197–8 ratio 48–9 rcv flows 89–91, 96–8, 120–2 redemption cap 153–6 redemption floor 153–6 reference counts 20–6 references, C++ 212–14 reg clsid 169–76, 177–87, 188–9 register com class 169–76 register date... 11–16, 160–3 register date more.cpp 160 register numpy.cpp 23 register special functions 18–19 reg progid 169–76, 177–89 regression schemes 4, 132–42, 150–2, 219–20 regression model 136–42, 150–2 regressions 132–42 regrid 55–61 regridder 58–61 regrid fs 55–7 regrid xT 58–61 regrid yT 58–61 relative date 66–7, 105–22, 125–8, 146–57 233 requestor 100–22, 124–8, 129–42, 146–57 requestor component, pricing models 100–22, 124–8, 129–42 reset currencies, concepts 70–9, 96–8, 105–22 reset dates 69–79, 95–8 see also observables reset basis 72–9, 89–91, 96–8, 120–2, 178–87 reset ccy 69–79, 90 reset currency 71–9, 89–90, 96–8, 105–22, 177–87 reset date 69–79, 95–8 reset duration 73–9, 89–91, 96–8, 120–2 reset holiday centres 72–9 reset id 69–79, 93–8, 146–57 reset lag 72–9 reset period 73–9, 89–91, 96–8, 120–2 reset shift method 72–9, 89–91, 96–8, 120–2, 178–87 retrieve 66–7, 97–8, 124–8, 169–76, 179–87, 188–9 retrieve constant 67, 100–22 retrieve curve 66–7, 100–22, 148–57 retrieve surface 67, 100–22 retrieve symbol... 97–8, 124–8, 131–42, 149–52 return statements, Python basics 200–5 risk the Greeks 142–3 management systems 4 Robinson, Andy 165 rollback 57–61, 108–22, 124–8 rollback component, pricing models 108–22, 124–8, 177–87 rollback max 57–61, 108–22, 124–8 rollback tests 109–22 roll duration 72–9, 84–5, 89–91, 96–8, 120–2, 177–87 roll end 72–9, 81–3, 84–5, 86–91 roll period 72–9, 84–5, 89–91, 96–8, 120–2, 177–87 rolls 14–16, 72–3 roll start 77–8, 81–3, 86–91 root-findin algorithms bisection method 35–6, 37 concepts 3, 35–7 Newton–Raphson method 36–7 root finding 35–7 roots 46–9, 53–7 RuntimeError 30–1, 35–6, 40–1, 43–5, 50–8, 66–7, 77, 81–3, 85–7, 88, 89, 90, 98, 102, 104–5, 113, 118–19, 131, 133, 134–6, 147–8, 169, 170–6, 177–8, 202–3 sausage Monte-Carlo method 143 Schwartz, E.S. 219 234 Index SciPy 1, 3, 8 see also NumPy scope guard techniques 20 SDEs 218 second axis 64–5 seed 112–22, 150–2 self 31–4, 45–6, 51–61, 63–7, 69–79, 93–122, 124–8, 130–42, 146–57, 178–89 semi-analytic conditional expectations, concepts 57–61 semi analytic domain integrator 57–61 server 166–89 set event 126–8, 130–42 set last cfs 135–42 sgn 46–9 shape 43–6, 50–1, 58–61, 81–3, 103–22, 133–42 shared ptr hpp 20–4 shift 14–16, 72–9, 86–8, 111–22 shift convention 14–16, 73–9, 80–2, 83–91, 96–8, 120–2, 151–2 shift method 14–16, 73–9, 80–2, 83–91, 120–2 short rates 101–2 sig 42–6, 65 sign 35–6 simple expressions, Python basics 194–5 sin 205 singular value decomposition of a matrix see also linear algebra concepts 42–6 singular value decomposition back substitution 42–6 solve tridiagonal system 2–3, 34, 39–40 solve upper diagonal system 17–19, 40–4, 50–1 solving linear systems see also linear algebra concepts 39–40 solving tridiagonal systems see also linear algebra concepts 2–3, 34, 39–40 solving upper diagonal systems see also linear algebra concepts 17–19, 40–4, 49–51 sort 48–9 special functions 17–18, 27–61 spread 70–9, 154–6 sqrt 48–9, 52–7, 59–61, 100–22 square tridiagonal matrices 33–4, 40–1 standard deviations 44–6, 51–7, 102–22, 133–42, 188–9 standard libraries 1 standard normal cumulative distributions see also N concepts 3, 27–9, 31, 51–7, 102–22 start 80–3, 83–91, 96–8, 120–2, 177–87, 198–200 start date 83–4 start of to year 16 state 59–61, 102–22, 124–8, 129–42, 146–57 state component, pricing models 101–22, 124–8, 129–42, 145–52 stddev 53–7, 102–22 step, Python basics 198–200 STL functions, C++ 29 stochastic volatility 113–14 stop, Python basics 198–200 str 71–9, 80–3, 86–7, 94, 166–8, 170–6 string literals, Python basics 194–6 structure misconceptions, Python 2–3 sum array 23–6 surf 101–22 surface 64–7, 101–22 surfaces see also environment concepts 3, 63, 64–7, 100–22, 170–6 definitio 64 volatility surfaces 3, 6, 63–7, 100–22 surface tests 64–7 svd 42–4 see also singular value decomposition of a matrix swap rates 70–9, 104–5, 115–22 swap obs 105–22 swap rate 74–9, 116–22 swaps 4, 70–9, 101–2, 104–5, 115–22, 123–8, 132–42, 145–52, 157 swap tests 149–52 swaptions 4, 101–2, 115–16, 126–8, 132–42, 145–52, 157 symbol table 97–8, 124–8, 129–42 symbol table listener 125–8, 129–42 symbol value pair 130–42, 155–6 symbol value pairs to add 130–42, 155–6 sys 27–8 table 82–4, 169 tables, adjuvants 82–4, 147–52, 153–6, 177–87 tag 169–76, 177–89 target redemption notes (TARNs) 4, 101–2, 145, 152–7 concepts 152–7 definitio 152 pricing models 4, 101–2, 145, 152–7 target indicator 153–6 tarn coupon leg payoff 152–6 tarn funding leg payoff 154–6 Index TARNs see target redemption notes tarn tests 155–6 templates 18–26, 159–63 tenor duration 72–9 tenor period 72–9 tenors 67, 84–5, 101–22, 170–6 term 28–9, 103–22 term structure of interest rates see yield curves term volatility, Hull–White model 100–22 terminal T 104–22 term var 100–22 term vol 100–22 test 6–7, 9, 17–19, 59–61, 64–7, 109–22, 148–57 test bond 115–22 test bond option 111–22 test bound 30–1 test bound ci 31 test constant 111–22 test discounted libor rollback 109–22 test explanatory variables 117–22 test hull white 67, 109–22 testing concepts 6–7, 9, 17–19 test lattice pricer 148–57 test market 64–7 test math 59–61 test mean and variance 114–22 test monte carlo pricer 154–6 test value 149–52 theta 48–9, 205 throw error already set 21–6 timeline 94–8, 125–8, 129–42 see also events Tk 2 tline 96–8 to ppf date 168–9, 178–87 tower law 60 tower law test 60–1 trace 23–6 Traceback 195–7, 202–3 trade 87–91, 94–8, 125–8, 129–42, 150–7, 177–87 trade representations, concepts 3, 69–91, 93–8 trade server, COM servers 176–87 trade utilities, concepts 88–91 trade VBA client 181 trade id 188–9 trades see also exercise...; fl ws; legs concepts 3, 69, 87–91, 93–8, 123–43, 176–87 definitio 69, 88 TradeServer 176–87, 188–9 trade server 176–87, 188–9 235 trade utils 89–91, 129–42, 153–6, 176–87 transpose 41–4 tridiagonal systems 2–3, 33–4, 39–40 try 27–8, 171–6, 177–87 Trying 6–7 tuples, Python basics 131, 195–7, 200–1, 215 TypeError 195–7 Ubuntu... 8 underlying 127–8, 130–42 unicode 172 unit fo 132–42 update indicator 134–42 update symbol 97–8, 126–8, 131–42 upper bound 29–31 USD 70–83, 152 utility 6–7, 29–61, 64–7 utility functions 17–26, 29–61 utils 168–76, 187–9 values 101–22 vanilla financia instruments, pricing approaches 99, 123–8, 145–57 var 102–22 variance 51–61, 102–22 variates 103–22 varT 102–22 Vasicek models 217–18 see also Hull–White model VB... see Microsoft... vector 41, 44–6, 133–42, 212 vectorize 133–42 visualisation software integration, Python benefit 2 vol 51–7, 59–61, 114–22 volatility Hull–White model 100–22 piecewise polynomial integration 51–61 surfaces 3, 6, 63–7, 100–22 vols 65 volt 59–61, 59–61 weekdays 15–16, 159–63 while statements, Python basics 199–200 white space, Python basics 198–200 win32 165–89 Win32 Python extensions 165–89 xh 52–7 xl 52–7 xprev 53–7 xs 56–61 xsT 60–1 xT 58–61, 108–22 xtT 58–61, 108–22 xt 58–61, 108–22

pages: 508 words: 120,339

Working Effectively With Legacy Code by Michael Feathers

This is an ideal candidate for a “but that would be stupid” rule. If we know when we start to look at the CppClass that we have been given a list that won’t change, our reasoning is much easier. In general, programming gets easier as we narrow effects in a program. We need to know less to understand a piece of code. At the extreme, we end up with functional programming in languages such as Scheme and Haskell. Programs can actually be very easy to understand in those languages, but those languages aren’t in widespread use. Regardless, in OO languages, restricting effects can make testing much easier, and there aren’t any hurdles to doing it. Simplifying Effect Sketches This book is about making legacy code easier to work with, so there is a sort of “spilt milk” quality to a lot of the examples.

The title of this chapter is a bit provocative. We can make safe changes in any language, but some languages make change easier than others. Even though object orientation has pretty much pervaded the industry, there are many other languages and ways of programming. There are rule-based languages, functional programming languages, constraint-based programming languages—the list goes on. But of all of these, none are as widespread as the plain old procedural languages, such as C, COBOL, FORTRAN, Pascal, and BASIC. Procedural languages are especially challenging in a legacy environment. It’s important to get code under test before modifying it, but the number of things you can do to introduce unit tests in procedural languages is pretty small.

It’s important to get code under test before modifying it, but the number of things you can do to introduce unit tests in procedural languages is pretty small. Often the easiest thing to do is think really hard, patch the system, and hope that your changes were right. This testing dilemma is pandemic in procedural legacy code. Procedural languages often just don’t have the seams that OO (and many functional) programming languages do. Savvy developers can work past this by managing their dependencies carefully (there is a lot of great code written in C, for instance), but it is also easy to end up with a real snarl that is hard to change incrementally and verifiably. Because breaking dependencies in procedural code is so hard, often the best strategy is to try to get a large chunk of the code under test before doing anything else and then use those tests to get some feedback while developing.

pages: 58 words: 12,386

Big Data Glossary by Pete Warden

There is a cost to this approach, though. Writing distributed data handling code is tricky and involves tradeoffs between speed, scalability, fault tolerance, and traditional database goals like atomicity and consistency. MapReduce MapReduce is an algorithm design pattern that originated in the functional programming world. It consists of three steps. First, you write a mapper function or script that goes through your input data and outputs a series of keys and values to use in calculating the results. The keys are used to cluster together bits of data that will be needed to calculate a single output result.

pages: 1,237 words: 227,370

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

MapReduce is neither a declarative query language nor a fully imperative query API, but somewhere in between: the logic of the query is expressed with snippets of code, which are called repeatedly by the processing framework. It is based on the map (also known as collect) and reduce (also known as fold or inject) functions that exist in many functional programming languages. To give an example, imagine you are a marine biologist, and you add an observation record to your database every time you see animals in the ocean. Now you want to generate a report saying how many sharks you have sighted per month. In PostgreSQL you might express that query like this: SELECT date_trunc('month', observation_timestamp) AS observation_month, sum(num_animals) AS total_animals FROM observations WHERE family = 'Sharks' GROUP BY observation_month; The date_trunc('month', timestamp) function determines the calendar month containing timestamp, and returns another timestamp representing the beginning of that month.

In principle, one type of processing can be emulated on top of the other, although the performance characteristics vary: for example, microbatching may perform poorly on hopping or sliding windows [6]. Maintaining derived state Batch processing has a quite strong functional flavor (even if the code is not written in a functional programming language): it encourages deterministic, pure functions whose output depends only on the input and which have no side effects other than the explicit outputs, treating inputs as immutable and outputs as append-only. Stream processing is similar, but it extends operators to allow managed, fault-tolerant state (see “Rebuilding state after a failure”).

This style of deployment is convenient, as servers can be added or removed at will, but the state has to go somewhere: typically, a database. The trend has been to keep stateless application logic separate from state management (databases): not putting application logic in the database and not putting persistent state in the application [36]. As people in the functional programming community like to joke, “We believe in the separation of Church and state” [37].i In this typical web application model, the database acts as a kind of mutable shared variable that can be accessed synchronously over the network. The application can read and update the variable, and the database takes care of making it durable, providing some concurrency control and fault tolerance.

Python Web Development With Django by Jeff Forcier

If we had set default to datetime.date.today()—note the parentheses—the function would be called at the time the model was defined, which is not what we want. Instead, we pass the function object; Django is aware of this and calls the function at instance-creation time to generate the value for us. Anonymous Functions Anonymous functions are another functional programming feature of Python.They are created using the lambda keyword and consist of a single expression, which represents the “return value” of the function. Such functions are not declared like a typical function and thus do not receive a name, hence the term anonymous function.They are usually single-line expressions that are meant to be created, used, and discarded in a general fashion.We should point out the distinction between “expressions” and “statements” so there is no confusion.

The following shows how those keyword arguments could also be passed as a dictionary: bobargs = {'title__contains': 'bob', 'subtitle__contains': 'bob', 'text__contains': 'bob', 'byline__contains': 'bob'} bob_stories = Story.objects.filter(**bobargs) Having done that, you can see how you would build up the dictionary dynamically: bobargs = dict((f + '__contains', 'bob') for f in ('title', 'subtitle', 'text', 'byline')) bob_stories = Story.objects.filter(**bobargs) Having done that, you can see how this technique could be helpful in streamlining queries with a lot of redundancy—or, even more commonly, helpful in assembling filter arguments whose names are provided dynamically (from options on a search form, for example). Decorators The last and perhaps most mind-bending concept when learning about Python functions and functional programming is decorators. In our context, a Python decorator is a mechanism enabling you to alter or “decorate” the behavior of a function to perform somewhat differently than designed, or to do something in addition to its native task; a decorator is a “function wrapper” if you will. Some of these extra tasks can include logging, timing, filtering, and so forth.

For example, you can create potentially large queries via looping. first_names = ["John", "Jane", "Jeremy", "Julia"] first_name_keywords = Q() # Empty "query" to build on for name in first_names: first_name_keywords = first_name_keywords | Q(first=name) specific_does = Person.objects.filter(last="Doe").filter(first_name_keywords) As you can see, we created a short for loop, primed it with the first item in our list, and then kept “appending” to the resulting Q object by using the | operator.This example actually isn’t the best—such a simple scenario would be served better by the __in query operator—but hopefully it illustrates the potential power of composing Q objects together programmatically. Note We could have saved a few lines in the previous example by using some functional programming tools Python provides, namely list comprehensions, the built-in method reduce, and the operator module. The operator module provides functional equivalents to operators, such as or_ for | and and_ for &. The three lines surrounding the for loop could have been rewritten as reduce(or_,[Q(first=name) for name in first_names]).

pages: 458 words: 135,206

CTOs at Work by Scott Donaldson, Stanley Siegel, Gary Donaldson

We're drifting away from the classic C#-, Java-, C++-style of object-oriented programming into more of a functional transformation style of programming, running data through transforms and templates that ultimately result in a web page. But that's definitely resulting in less code and simpler programs. S. Donaldson: Very interesting. Ballard: Functional programming is in a paradigm whether you use an explicit functional programming language or not, I think is important. Siegel: Let's shift gears for a minute and talk about technology investment. How does your company invest in technology? Ballard: We invest on multiple different levels. I alluded to this topic earlier when I was speaking about the ROI [return on investment] on a per-product basis.

Index 3D technology David Kuttler, 302 Jerry Krill, 83–85 64-bit architectures, 272–274, 281 A acquisitions, William Ballard, 279–280 Adobe, reverse image searching and, 246 AEP (American Electric Power), 128–129 Aguru Images, Craig Miller, 53–54, 56–59 algae, Craig Miller, 69, 76 Alm, Al, 50 Alving, Amy, 1–20 Amazon EC2, 36 Amazon Web Services (AWS), 245 American Electric Power (AEP), 128–129 American Public Media, 163 Amperion, 128 APL (Applied Physics Laboratory) global technical outreach, 90 Jerry Krill, 82 application development, Jeff Tolnar, 145 architecture technical review, 26 Arduinos, Craig Miller, 77 asymmetric warfare, Jerry Krill's comments on, 92 AWS (Amazon Web Services), 245 B Ballard, William, CTO of Gerson Lehrman Group, Inc, 261–283 Beyster, Bob, 51–52 Bilger, Mark, 23 Black, David, 262 Bloore, Paul, 239–260 Bodine, Greg, 30 BPLG (BPL Global), 127–128, 132 breakout engagements, Gerson Lehrman, 265 budgeting, Jeff Tolnar, 146–148 bundling hardware and software, Jeff Tolnar, 135 Burke, Thomas, 177 business development personnel, Gerson Lehrman, 266 C CA Open Space, 39 callable interface, 41 career lessons Darko Hrelic, 206–207, 211 Jan-Erik de Boer, 236 Jerry Krill, 91 Paul Bloore, 253 Wesley Kaplow, 110 career path Amy Alving, 1–6 Darko Hrelic, 205–206 Dmitry Cherches, 181–185 Jan-Erik de Boer, 237 Jeff Tolnar, 128 Marty Garrison, 152 Paul Bloore, 240–242 Tom Loveland, 176–178 Wesley Kaplow, 105–110 CATEX, Craig Miller, 51 Cherches, Dimitri background, 173 of Mind Over Machines, 173–204 ChoicePoint, 158 CIO responsibilities, of William Ballard, 268 CIO role, versus CTO role, 282 CIOs, Jeff Tolnar, 130–131 cloud computing, 35 Amy Alving, 16–17 Craig Miller, 65 David Kuttler, 302 Dmitry Cherches, 186–188, 200 Gerson Lehrman, 277 Jeff Tolnar, 142, 147–148 Marty Garrison, 160, 167 CloudShield, 13 cluster analysis, Craig Miller, 64 CommonCrawl group, 257 communication activities, of William Ballard, 269 communication, importance of, 30 competition, evaluating Amy Alving, 12–13 Darko Hrelic, 211–212, 217 Gerson Lehrman, 265 Jerry Krill, 101–102 Paul Bloore, 244–245 computing cloud computing, 35 Amy Alving, 16–17 Craig Miller, 65 David Kuttler, 302 Dmitry Cherches, 186–188, 200 Gerson Lehrman, 277 Jeff Tolnar, 142, 147–148 Marty Garrison, 160, 167 distributed computing, 242 mobile computing, 39–40 Darko Hrelic, 209–210 impact on Gerson Lehrman, 276 Jerry Krill, 96 Marty Garrison, 168 Paul Bloore, 254 Wesley Kaplow, 123 Comverge, 137 conference calls, ZipDx, 277–278 consulting, by Gerson Lehrman, 265 continuous deployment cycle, at Gerson Lehrman, 281 corporate strategy, Rick Mosca, 191–194 councils, Gerson Lehrman, 264 creativity, role in career path Jerry Krill, 85–87 Paul Bloore, 241 Wesley Kaplow, 116 Crinks, Bert, 115–116 CTO responsibilities, of William Ballard, 267–271, 282–283 Cuomo, Jerry, 25 customizing software, William Ballard's advice regarding, 270–272 cyanobacteria, Craig Miller, 79 cyber security Amy Alving, 18–19 CloudShield, 13 Darko Hrelic, 214–215 Dmitry Cherches, 201 Gerson Lehrman, 276 Springer, 235 Wesley Kaplow, 123 D Dannelly, Doug, 69 DARPA (Defense Advanced Research Projects Agency), Amy Alving, 5–6 Darwin, Charles, 70 data mining, real-time, 281–282 databases Jeff Tolnar, 141 used at Gerson Lehrman, 272 David Kuttler, 296 DAVID system, 165 de Boer, Jan-Erik, 219–237 Debevec, Paul, 57 decision-making, Jeff Tolnar, 133–134 Defense Advanced Research Projects Agency (DARPA), Amy Alving, 5–6 Delman, Debra, 161 Demand Media, 261–262 Department of Energy (DoE), 54–55, 64 deployment cycle, at Gerson Lehrman, 281 DER (distributed energy resources), 139, 142–149 DEs (Distinguished Engineers), 25 development methodology, Paul Bloore, 256–257 development resources, Jeff Tolnar, 139–140 DiData, Craig Miller, 53, 61 digital watermarking, 243 Dimension Data, Craig Miller, 52 Distinguished Engineers (DEs), 25 distributed computing, 242 distributed energy resources (DER), 139, 142–149 Dobson, David, 36 DoE (Department of Energy), 54–55, 64 domain expertise, 36 E economics of consulting with Gerson Lehrman, 265 William Ballard's advice regarding, 270–271, 279 electric co-ops, Craig Miller, 54–55 electrical transformers, Craig Miller, 68 employees, Gerson Lehrman, 265–266 Endhiran movie, Craig Miller, 58–59 energy policy, Craig Miller, 50 engineering offices, Gerson Lehrman, 266 engineers, cost of, 270, 279 ETL (extraction, translation, load), 203 evaluating competition Amy Alving, 12–13 Darko Hrelic, 211–212, 217 Gerson Lehrman, 265 Jerry Krill, 101–102 Paul Bloore, 244–245 expert network space, Gerson Lehrman, 265 expertise, use of, 274–275 external organizations, affiliations of Gerson Lehrman with, 269 extinction, Craig Miller, 78–79 extraction, translation, load (ETL), 203 F FDA, David Kuttler, 300–301 Ferguson, Don, interview with, 21–47 Fernandez, Raul, 52 ferrofluid, 241 First of a Kind project, 23 Folderauer, Ken, 114 fractal architecture, 273–274 free space optics, 84, 95 frequency variations, Craig Miller, 62–63 functional programming, 278 fundraising, Jeff Tolnar, 146 G Garrison, Marty, interview with, 151 Gayal, Amoosh, 24 Gelpin, Tim, 89 G.I. Joe movie, Craig Miller, 56–58 Google, Springer and, 235 grants, APL, 97–98, 103 GridPoint, Craig Miller, 53 Griffiths, Peter, 36 group CTOs, 8 growth, Jeff Tolnar, 132 H Haank, Derk, 221 Herness, Eric, 25 High, Rob, 25 hiring practices of William Ballard, 267, 270 and recruitment, David Kuttler, 292–298 technical people, Craig Miller, 66–67 Holloway, Tim, 25 Homewood, 88 Howarth, Dennis, 178 HR (human resources), 289 Hrelic, Darko, 205–218 human resources (HR), 289 I IBM David Kuttler, 285, 287–288 Don Ferguson, 21 IBPP (integrated business planning process), 8 ignition grants, APL, 97–98, 103 image searching, reverse image searching, 245 imaging, David Kuttler, 302 infrastructure, William Ballard's involvement with, 274 Inkling, 226 innovation, 198 Amy Alving, 16 Dmitry Cherches comments on, 198 Don Ferguson's comments on, 27–28 integrated business planning process (IBPP), 8 integrated solutions, Jeff Tolnar, 136–139 Internal Research and Development (IRAD), 86, 100 internal systems responsibilities, William Ballard, 268 investments, technology, 42–43 Amy Alving, 17 Darko Hrelic, 215–216 Dmitry Cherches, 188–189, 201–202 Gerson Lehrman, 278–280 Jan-Erik de Boer, 222–223, 228 Jerry Krill, 99–101 Marty Garrison, 168–169 Paul Bloore, 258–259 Tom Loveland, 180–181 IRAD (Internal Research and Development), 86, 100 IT governance, David Kuttler, 304–305 IT lobbying organizations, Maryland, 179 IT pods, 142 J Johnston, George, 111 K Kaplow, Wesley, 105–126 Kouros, Esfahany, 30 Krill, Jerry, 81–104 Kuttler, David, IT consultant formerly of Johnson & Johnson and Vertex Pharmaceuticals, 285–305 L LaBlanc, Robert, 23–24 Lamm, Jacob, 36 learning, importance of, 76 Lee, Annabelle, 66 LIDAR (Light Detection and Ranging technology), 85 Loveland, Tom background, 173 of Mind Over Machines, 173–204 Luman, Ron, 88–89 Lynn, Barry, 23, 26 M mainframes, Don Ferguson's work with, 22 management by objective (MBO), 133 Marklogic, 230 Marston, Charles, 244 Maybridge Imaging, Craig Miller, 54 Mayo, Bob, 179 MBO (management by objective), 133 McCracken, Bill, 36 McGowan, John, 111, 113 meetings, at Gerson Lehrman, 269 memes concept, Craig Miller, 72–73 memory, as important technology, 272–274 mentors Amy Alving, 7–8 Darko Hrelic, 206 David Kuttler, 287 Jeff Tolnar, 128–129, 141 Jerry Krill, 83 Paul Bloore, 242 of William Ballard, 262 mergers and acquisitions Craig Miller, 74 David Kuttler, 302–303 Jeff Tolnar, 146 William Ballard, 279–280 Microsoft Kinect, 255 Miller, Craig, 49–79 Miller, Sienna, 58 Mills, Steve, 24 Mind Over Machines, 173–204 Dimitri Cherches, 173–204 Joe Natoli, 173–204 Rick Mosca, 173–204 Tom Loveland, 173–204 Minnesota Public Radio, 163 mobile computing, 39–40 Darko Hrelic, 209–210 impact on Gerson Lehrman, 276 Jerry Krill, 96 Marty Garrison, 168 Paul Bloore, 254 Wesley Kaplow, 123 mobility, Jeff Tolnar, 143–144 MongoDB, 273–274 Mos, Martin, 221 Mosca, Rick background, 174 of Mind Over Machines, 173–204 MySpace, 262 N Nair, Balan, 115 Nally, Martin, 25 National Institute of Standards and Technology (NIST), Craig Miller, 66 National Rural Electric Cooperative Association (NRECA), Craig Miller, 54–55, 59, 62, 66, 73 Natoli, Joe background, 174 of Mind Over Machines, 173–204 NERC (North American Electric Reliability Corporation), Craig Miller, 66 NetSpend, 261 networking, social David Kuttler, 301 impact on Gerson Lehrman, 275 impact on research, 97 Marty Garrison, 169 Paul Bloore, 254–255 networks, David Kuttler, 302 neuroscience, APL and, 94 New Horizons spacecraft, 94 Nimmo, Ruth, 90 NIST (National Institute of Standards and Technology), Craig Miller, 66 North American Electric Reliability Corporation (NERC), Craig Miller, 66 NRECA (National Rural Electric Cooperative Association), Craig Miller, 54–55, 59, 62, 66, 73 O off-the-shelf software, William Ballard, 270–272 Office Products Network of North America (OPNNA), 178 open source, 280 open-source software, Paul Bloore, 257 operational responsibilities, of CTOs, 283 OPNNA (Office Products Network of North America), 178 out-of-the-box software, William Ballard, 270–272 P partnerships, Jeff Tolnar, 134–135 patents, Jeff Tolnar, 146 payment system, Gerson Lehrman, 265 peer interaction, Jeff Tolnar, 133 permanent staff, Gerson Lehrman, 265–266 personnel, Jeff Tolnar, 140–141 physics, Craig Miller, 50, 62–63, 69–72 PixID, 247 platform group, Springer, 225 Pluck company, 261–262 Poll, Pieter, 115 practice areas, Gerson Lehrman, 264 PRI (Public Radio International), 163 profiling questions, Gerson Lehrman screening process, 264 programming languages, 141, 278 Prout, Will, 128 Proxicom, 52 PRSS (Public Radio Satellite System), 166 Public Radio International (PRI), 163 Public Radio Satellite System (PRSS), 166 pyramid model of needed services, David Kuttler, 290 Q Q&A (question and answer) products, 275 R R&D (research and development) Darko Hrelic, 209 David Kuttler, 289–290 Paul Bloore, 251–252 Rajinikanth, 58 real-time data mining, 281–282 recruiting, by Gerson Lehrman, 266 regulation, of Gerson Lehrman, 267 Rehm, Diane, 78 reinsurance contracts, Craig Miller, 51–52 relational databases, 22 representational state transfer (REST), 41 research and development (R&D) Darko Hrelic, 209 David Kuttler, 289–290 Paul Bloore, 251–252 REST (representational state transfer), 41 reverse image searching, 245 risk technology, 22 S Saba, Danny, 24 SAIC (Science Applications International Corporation) Amy Alving, 1–20 Craig Miller, 49, 51 SAS (Statistical Analysis System), 202 Schatz, Jim, 93 Science Applications International Corporation (SAIC) Amy Alving, 1–20 Craig Miller, 49, 51 screening of experts, by Gerson Lehrman, 263–264 search capabilities, Gerson Lehrman, 274–275 security.

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

MapReduce is neither a declarative query language nor a fully imperative query API, but somewhere in between: the logic of the query is expressed with snippets of code, which are called repeatedly by the processing framework. It is based on the map (also known as collect) and reduce (also known as fold or inject) functions that exist in many functional programming languages. To give an example, imagine you are a marine biologist, and you add an observation record to your database every time you see animals in the ocean. Now you want to generate a report saying how many sharks you have sighted per month. In PostgreSQL you might express that query like this: SELECT date_trunc('month', observation_timestamp) AS observation_month, sum(num_animals) AS total_animals FROM observations WHERE family = 'Sharks' GROUP BY observation_month; The date_trunc('month', timestamp) function determines the calendar month containing timestamp, and returns another timestamp representing the begin‐ ning of that month.

In principle, one type of processing can be emulated on top of the other, although the performance characteristics vary: for example, microbatching may perform poorly on hopping or sliding windows [6]. Maintaining derived state Batch processing has a quite strong functional flavor (even if the code is not written in a functional programming language): it encourages deterministic, pure functions whose output depends only on the input and which have no side effects other than the explicit outputs, treating inputs as immutable and outputs as append-only. Stream processing is similar, but it extends operators to allow managed, fault-tolerant state (see “Rebuilding state after a failure” on page 478).

Subscribing to changes is only just beginning to emerge as a feature (see “API support for change streams” on page 456). i. Explaining a joke rarely improves it, but I don’t want anyone to feel left out. Here, Church is a reference to the mathematician Alonzo Church, who created the lambda calculus, an early form of computation that is the basis for most functional programming languages. The lambda calculus has no mutable state (i.e., no vari‐ ables that can be overwritten), so one could say that mutable state is separate from Church’s work. 506 | Chapter 12: The Future of Data Systems Dataflow: Interplay between state changes and application code Thinking about applications in terms of dataflow implies renegotiating the relation‐ ship between application code and state management.

pages: 471 words: 94,519

Managing Projects With GNU Make by Robert Mecklenburg, Andrew Oram

To diagnose this problem, we examine make's internal database by running make with its —print-data-base option and we see something strange: \$make --print-database | grep ^ls ls_headers = ls.h glob.h ls_sources = ls.c glob.c ls_objects = ls.o glob.o ls.c: ls.o: ls.c ls: ls.o The .h prerequisites for ls.o are missing! There is something wrong with the rule using computed variables. When make parses the eval function call, it first expands the user-defined function, program-variables. The first line of the macro expands to: ls_sources = ls.c glob.c Notice that each line of the macro is expanded immediately as expected. The other variable assignments are handled similarly. Then we get to the rule: \$(\$1_objects): \$(\$1_headers) The computed variables first have their variable name expanded: \$(ls_objects): \$(ls_headers) Then the outer variable expansion is performed, yielding: : Wait!

FUTURE REVISIONS OF THIS LICENSE grep command, variables and, Command Environment H header files, include directory, Finding Files with VPATH and vpath Hello World makefile file, How to Write a Simple Makefile help commands, A Simple Help Command --help option, Running make home directory, ^ (tilde) and, Wildcards hooks, functions, Hooking Functions I IDEs (Integrated Development Environments), Java, IDEs if function, Flow Control ifeq conditional directive, Conditional and include Processing ifneq conditional directive, Conditional and include Processing immediate expansion, When Variables Are Expanded implicit rules, Rules, The Implicit Rules Database, Working with Implicit Rules, Implicit Rules for Source Control, Implicit Rules for Source Control built-in, Working with Implicit Rules source control and, Implicit Rules for Source Control, Implicit Rules for Source Control CVS, Implicit Rules for Source Control include directive, Finding Files with VPATH and vpath, Conditional and include Processing, The include Directive, include and Dependencies, Nonrecursive make dependencies and, include and Dependencies header files, Finding Files with VPATH and vpath optimization, Nonrecursive make include processing, Conditional and include Processing --include-dir option, Running make incrementing, Arithmetic info target, Phony Targets initialization, performance and, Lazy Initialization input files, text printing, Minimizing Rebuilds install target, Phony Targets installers, reference builds and, Reference Builds, Libraries, and Installers interfaces, phony targets and, Phony Targets intermediate files, chaining rules and, Working with Implicit Rules .INTERMEDIATE target modifier, Special Targets invoking make, Invoking make J jar program, Managing Jars, Reference Trees and Third-Party Jars, Reference Trees and Third-Party Jars reference trees, Reference Trees and Third-Party Jars third-party, Reference Trees and Third-Party Jars jars (Java), Managing Jars Java, Java, Java, Java, Ant, Ant, Ant, Ant, Ant, IDEs, A Generic Java Makefile, Compiling with Dependencies, Setting CLASSPATH, Managing Jars, Enterprise JavaBeans Ant, Ant, Ant, Ant, Ant, Ant build file, Ant mkdir program, Ant portability, Ant tasks, Ant Eclipse, Java EJB (Enterprise JavaBeans), Enterprise JavaBeans IDEs, IDEs jars and, Managing Jars make and, Java makefile (generic), A Generic Java Makefile, Compiling with Dependencies, Setting CLASSPATH CLASSPATH variable, Setting CLASSPATH dependecies and, Compiling with Dependencies packages, Java JBuilder, IDEs JIT (just-in-time) optimization, Java join function, Filename Functions --just-print option, Running make --just-print option, debugging, —just-print JVM (Java virtual machine), Java K --keep-going option, Running make killing processes, user-defined functions and, User-Defined Functions L large projects, Managing Large Projects, Automating Builds and Testing libraries, Special Targets, Managing Libraries, Creating and Updating Libraries, Creating and Updating Libraries, Using Libraries as Prerequisites, Using Libraries as Prerequisites, Recursive make, Nonrecursive make, Reference Builds, Libraries, and Installers archive libraries, Managing Libraries circular references, Using Libraries as Prerequisites creating, Creating and Updating Libraries make-library function, Nonrecursive make as prerequisites, Using Libraries as Prerequisites recursion and, Recursive make reference builds and, Reference Builds, Libraries, and Installers .SECONDARY target modifier, Special Targets updating, Creating and Updating Libraries library functions, reusable, Finding Files with VPATH and vpath library management, Managing Libraries, Creating and Updating Libraries, Creating and Updating Libraries, Double-Colon Rules archive libraries and, Managing Libraries creating libraries, Creating and Updating Libraries double-colon rules, Double-Colon Rules updating libraries, Creating and Updating Libraries line termination, Cygwin, Line Termination Linux kernel makefile, The Linux Kernel Makefile, Command-Line Options, Configuration Versus Building, Managing Command Echo, User-Defined Functions command echo, Managing Command Echo command-line options, Command-Line Options configuration versus building, Configuration Versus Building user-defined functions, User-Defined Functions long commands, Continuing Long Commands loops, foreach, Data Structures M m4 macros, book makefile and, XML Preprocessing macros, Macros, Macros, When Variables Are Expanded, When Variables Are Expanded, User-Defined Functions, User-Defined Functions, Advanced User-Defined Functions, eval and value, eval and value debugging and, Advanced User-Defined Functions define directive, Macros defining, When Variables Are Expanded expanding, When Variables Are Expanded implementing, scoping and, User-Defined Functions introduction, Macros invoking from another macro, User-Defined Functions program-variables, eval and value rules in, eval and value make, How to Write a Simple Makefile, How to Write a Simple Makefile, Targets and Prerequisites, Dependency Checking, Invoking make, Basic Makefile Syntax, Basic Makefile Syntax automation and, How to Write a Simple Makefile command execution, Targets and Prerequisites comments, Basic Makefile Syntax dependency checking, Dependency Checking escape character, Basic Makefile Syntax invoking, Invoking make scripts and, How to Write a Simple Makefile make shell command, benchmarking and, Benchmarking make-library function, Nonrecursive make MAKECMDGOALS variable, Standard make Variables, Standard make Variables makedepend, makedepend Programs makefiles, How to Write a Simple Makefile, How to Write a Simple Makefile, Targets and Prerequisites, Targets and Prerequisites, Basic Makefile Syntax, A Generic Java Makefile, The Book Makefile, The Book Makefile, XML Preprocessing, XML Preprocessing, Generating Output, Validating the Source, The Linux Kernel Makefile, Command-Line Options, Configuration Versus Building, Managing Command Echo, User-Defined Functions book makefile, The Book Makefile, The Book Makefile, XML Preprocessing, XML Preprocessing, Generating Output, Validating the Source m4 macros, XML Preprocessing output generation, Generating Output source validation, Validating the Source XML preprocessing, XML Preprocessing command execution, Targets and Prerequisites Hello World, How to Write a Simple Makefile Java, generic for, A Generic Java Makefile Linux kernel, The Linux Kernel Makefile, Command-Line Options, Configuration Versus Building, Managing Command Echo, User-Defined Functions command echo and, Managing Command Echo command-line options, Command-Line Options configuration versus building, Configuration Versus Building user-defined functions, User-Defined Functions syntax, Basic Makefile Syntax targets as command-line arguments, How to Write a Simple Makefile top-down style, Targets and Prerequisites MAKEFILE_LIST variable, Standard make Variables, Standard make Variables MAKEFLAGS variable, command environment and, Command Environment MAKELEVEL variable, command environments, Command Environment MAKE_VERSION variable, Standard make Variables, Standard make Variables matched rules, automatic variables, Automatic Variables members of archive libraries, Managing Libraries miscellaneous functions, Less Important Miscellaneous Functions, Less Important Miscellaneous Functions warning, Less Important Miscellaneous Functions mkdir, Ant (Java), Ant module definition, find command, Nonrecursive make module.mk include files, Nonrecursive make multiline commands, Errors and Interrupts N --new-file option, Running make newline rule, Minimizing Rebuilds no-op commands, Errors and Interrupts nonrecursive make, Nonrecursive make, Nonrecursive make phony targets and, Nonrecursive make notdir function, Filename Functions O object files, updates, Rule Structure --old-file option, Running make options, Errors and Interrupts, Portability Issues commands, errors and, Errors and Interrupts portability and, Portability Issues origin function, Less Important Miscellaneous Functions output, book makefile example, Generating Output P packages, Java, Java parallelism, performance and, Parallel make parameters, User-Defined Functions, Passing Parameters passing to functions, Passing Parameters user-defined functions, User-Defined Functions parentheses, variables and, Variables and Macros, Style note concerning variables and parentheses parsing, eval and value, Parsing Commands, Parsing Commands, Parsing Commands commands, Parsing Commands, Parsing Commands, Parsing Commands command scripts and, Parsing Commands editors and, Parsing Commands eval function and, eval and value partial source trees, Partial Source Trees passing parameters to functions, Passing Parameters passing variables, recursive make and, Passing Variables paths, portability and, Portability Issues patsubst function, String Functions pattern rules, Rules, Rules, Pattern Rules, The Patterns, The Patterns, The Patterns, The Patterns, Static Pattern Rules, Suffix Rules, Suffix Rules % (percent) character, The Patterns implicit rules and, Rules patterns, The Patterns, The Patterns, The Patterns suffixes, The Patterns, The Patterns static pattern rules, Static Pattern Rules suffix rules, Suffix Rules suffixes, deleting, Suffix Rules pattern-specific variables, Target- and Pattern-Specific Variables patterns, Built-in Functions, String Functions as arguments in built-in functions, Built-in Functions filter function, String Functions performance, Improving the Performance of make, Benchmarking, Identifying and Handling Bottlenecks, Simple Variables Versus Recursive, Simple Variables Versus Recursive, Disabling @, Lazy Initialization, Parallel make, Distributed make @ sign and, Disabling @ benchmarking and, Benchmarking bottlenecks, Identifying and Handling Bottlenecks distribution and, Distributed make initialization and, Lazy Initialization introduction, Improving the Performance of make parallelism and, Parallel make recursive variables, Simple Variables Versus Recursive simple variables, Simple Variables Versus Recursive phony targets, Phony Targets, Phony Targets, Phony Targets, Phony Targets, Phony Targets, Phony Targets, Phony Targets, Phony Targets, Special Targets, Nonrecursive make awk command, Phony Targets df command, Phony Targets interfaces and, Phony Targets nonrecursive make and, Nonrecursive make output, Phony Targets, Phony Targets debugging, Phony Targets reading, Phony Targets prerequisites, Phony Targets special targets, Special Targets standard, Phony Targets portability, Portable Makefiles, Portability Issues, Portability Issues, Portability Issues, Portability Issues, Portability Issues, Cygwin, Working with Nonportable Tools, A Standard Shell, Ant Ant (Java), Ant Cygwin, Cygwin nonportable tools, Working with Nonportable Tools options and, Portability Issues paths and, Portability Issues program behavior and, Portability Issues program names and, Portability Issues shell and, Portability Issues, A Standard Shell .PRECIOUS target modifier, Special Targets prefixes on commands, Command Modifiers, Command Modifiers, Command Modifiers + (plus), Command Modifiers - (dash), Command Modifiers @, Command Modifiers prefixes, pattern rules, The Patterns prerequisites, Targets and Prerequisites, Dependency Checking, Phony Targets, Automatic Variables, Special Targets, Special Targets, Using Libraries as Prerequisites, Using Libraries as Prerequisites, Recursive make automatic variables and, Automatic Variables libraries as, Using Libraries as Prerequisites phony targets, Phony Targets rules and, Targets and Prerequisites saving, Using Libraries as Prerequisites targets, Dependency Checking, Special Targets, Special Targets chaining, Dependency Checking .INTERMEDIATE modifier and, Special Targets .SECONDARY modifier, Special Targets updates, ordering and, Recursive make --print-data-base option, Running make program behavior, portability and, Portability Issues program management, Managing Programs and Files program names, portability and, Portability Issues program-variables macro, eval and value R RCS source control, implicit rules and, Implicit Rules for Source Control read-only source, Read-Only Source rebuilds, minimizing, Minimizing Rebuilds recursion, Managing Large Projects recursive make, Recursive make, Recursive make, Command-Line Options, Passing Variables, Error Handling, Building Other Targets, Avoiding Duplicate Code, Nonrecursive make (see also nonrecursive make) build targets and, Building Other Targets code duplication, Avoiding Duplicate Code command-line and, Command-Line Options dependencies and, Recursive make error handling, Error Handling variables, passing, Passing Variables recursive variables, Important Miscellaneous Functions, Simple Variables Versus Recursive performance and, Simple Variables Versus Recursive shell function and, Important Miscellaneous Functions recursively expanded variables, Variable Types reference builds, Reference Builds, Libraries, and Installers, Reference Builds, Libraries, and Installers installers and, Reference Builds, Libraries, and Installers libraries and, Reference Builds, Libraries, and Installers reference trees, jar program, Reference Trees and Third-Party Jars regtool, Setting CLASSPATH relative paths, converting to Java class name, Important Miscellaneous Functions remote-file function, Data Structures reusable library functions, declarations, Finding Files with VPATH and vpath rule chaining, Pattern Rules rules, Targets and Prerequisites, Targets and Prerequisites, Targets and Prerequisites, Targets and Prerequisites, Minimizing Rebuilds, Minimizing Rebuilds, Rules, Rules, Rules, Rules, Rules, Explicit Rules, Empty Targets, Explicit Rules, Phony Targets, Empty Targets, Automatic Variables, Pattern Rules, Static Pattern Rules, Suffix Rules, The Implicit Rules Database, Working with Implicit Rules, Working with Implicit Rules, Rule Structure, Rule Structure, Rule Structure, Implicit Rules for Source Control, Double-Colon Rules, eval and value any character, Minimizing Rebuilds chaining, intermediate files, Working with Implicit Rules customization, variables and, Rule Structure default rule, Targets and Prerequisites dependents, Targets and Prerequisites double-colon, Double-Colon Rules explicit, Rules, Explicit Rules, Empty Targets, Phony Targets, Empty Targets empty targets, Empty Targets phony targets, Phony Targets implicit, Rules, The Implicit Rules Database, Working with Implicit Rules, Implicit Rules for Source Control built-in, Working with Implicit Rules source control and, Implicit Rules for Source Control macros, eval and value matching, automatic variables and, Automatic Variables newline, Minimizing Rebuilds pattern, Rules, Pattern Rules, Suffix Rules suffix rules, Suffix Rules prerequisites and, Targets and Prerequisites static pattern, Rules, Static Pattern Rules structure, Rule Structure suffix, Rules targets, Targets and Prerequisites, Explicit Rules multiple, Explicit Rules variables, customization and, Rule Structure run-make shell script, running book makefile, Managing Examples S SCCS source control, implicit rules and, Implicit Rules for Source Control scoping, macro implementation and, User-Defined Functions scripts, How to Write a Simple Makefile, Parsing Commands command scripts, parsing and, Parsing Commands make and, How to Write a Simple Makefile search and replace functions, strings, String Functions, String Functions substitution references, String Functions searches, Finding Files with VPATH and vpath, Finding Files with VPATH and vpath, Partial Source Trees, Partial Source Trees binary trees, Partial Source Trees source treese, Partial Source Trees VPATH and, Finding Files with VPATH and vpath vpath and, Finding Files with VPATH and vpath .SECONDARY target modifier, Special Targets separators, missing (error messages), missing separator shell, Which Shell to Use, Portability Issues, A Standard Shell command lines, subshells, Which Shell to Use portability and, Portability Issues, A Standard Shell shell commands, sequences, Continuing Long Commands shell function, Important Miscellaneous Functions, Important Miscellaneous Functions variables, Important Miscellaneous Functions simple variables, Important Miscellaneous Functions, Simple Variables Versus Recursive performance and, Simple Variables Versus Recursive shell function and, Important Miscellaneous Functions simply expanded variables, Variable Types sort function, Important Miscellaneous Functions source, Finding Files with VPATH and vpath, Separating Source and Binary, The Hard Way, Validating the Source binary tree separation, Separating Source and Binary, The Hard Way src directory, Finding Files with VPATH and vpath validation, book makefile, Validating the Source source trees, Source Tree Layout, Read-Only Source, Partial Source Trees, Partial Source Trees layout, file management and, Source Tree Layout partial, Partial Source Trees read-only, Read-Only Source searches, Partial Source Trees source-to-object function, Nonrecursive make sources of variables, Where Variables Come From space-to-question function, Managing Programs and Files special targets, Special Targets src directory, source files, Finding Files with VPATH and vpath static pattern rules, Rules, Static Pattern Rules status code, commands, Errors and Interrupts stderr file descriptor, Command Environment stdin file descriptor, Command Environment stdout file descriptor, Command Environment string functions, String Functions, String Functions, String Functions, String Functions, String Functions, String Functions, String Functions, String Functions, String Functions, String Functions filter, String Functions filter-out, String Functions findstring, String Functions firstword, String Functions patsubst, String Functions search and replace functions, String Functions subst, String Functions wordlist, String Functions words, String Functions strip function, Conditional and include Processing, Less Important Miscellaneous Functions whitespace removal, Conditional and include Processing structure of rules, Rule Structure subshells, command lines and, Which Shell to Use subst function, String Functions substitution references, string functions, String Functions suffix function, Filename Functions suffix rules, Rules, Suffix Rules implicit rules and, Rules suffixes, The Patterns, Suffix Rules, Suffix Rules, Filename Functions filenames, functions, Filename Functions pattern rules, The Patterns, Suffix Rules deleting, Suffix Rules targets, Suffix Rules syntax, Basic Makefile Syntax, Target- and Pattern-Specific Variables, Conditional and include Processing, Built-in Functions, Parsing Commands, Syntax Errors built-in functions, Built-in Functions conditional directives, Conditional and include Processing editors, Parsing Commands errors, debugging and, Syntax Errors makefile, Basic Makefile Syntax target-specific variables, Target- and Pattern-Specific Variables T tab character, error message, commands commence before first target TAGS target, Phony Targets target-specific variables, Target- and Pattern-Specific Variables, Target- and Pattern-Specific Variables syntax, Target- and Pattern-Specific Variables targets, How to Write a Simple Makefile, Targets and Prerequisites, Dependency Checking, Rules, Explicit Rules, Phony Targets, Empty Targets, Automatic Variables, Pattern Rules, Static Pattern Rules, Suffix Rules, Special Targets, Special Targets, Special Targets, Special Targets, Special Targets, Special Targets, Special Targets, Using Libraries as Prerequisites, Deleting and preserving target files, Building Other Targets, Overriding Commands for Target automatic variables and, Automatic Variables build targets, recursive make and, Building Other Targets as command-line arguments, How to Write a Simple Makefile commands, overriding, Overriding Commands for Target deleting, Deleting and preserving target files empty, Empty Targets modifiers, Special Targets, Special Targets, Special Targets, Special Targets, Special Targets .DELETE_ON_ERROR, Special Targets .INTERMEDIATE, Special Targets .PRECIOUS, Special Targets .SECONDARY, Special Targets phony targets, Phony Targets, Special Targets special targets, Special Targets prerequisites, Dependency Checking, Using Libraries as Prerequisites chaining, Dependency Checking saving, Using Libraries as Prerequisites rules, Targets and Prerequisites, Rules, Explicit Rules explicit rules, Rules multiple, Explicit Rules special targets, Special Targets static pattern rules, Static Pattern Rules suffixes, Suffix Rules updating, rule chaining and, Pattern Rules tasks (Ant), Ant text expansion, foreach function and, Flow Control timestamps, Empty Targets, Important Miscellaneous Functions empty files and, Empty Targets filenames and, Important Miscellaneous Functions top-down style, makefiles, Targets and Prerequisites --touch option, Running make U updates, Pattern Rules, Rule Structure, Creating and Updating Libraries, Recursive make libraries, Creating and Updating Libraries object files, rules, Rule Structure prerequisites, ordering and, Recursive make targets, rule chaining, Pattern Rules user-defined functions, Variables and Macros, User-Defined Functions, User-Defined Functions, User-Defined Functions, User-Defined Functions, Advanced User-Defined Functions, Passing Parameters, User-Defined Functions advanced, Advanced User-Defined Functions, Passing Parameters killing processes and, User-Defined Functions Linux kernel makefile, User-Defined Functions parameters and, User-Defined Functions variables and, Variables and Macros V validating source, book makefile, Validating the Source .VARIABLES variable, Standard make Variables variables, Empty Targets, Variables, Automatic Variables, Finding Files with VPATH and vpath, Static Pattern Rules, Rule Structure, Variables and Macros, Variables and Macros, Variables and Macros, Variables and Macros, Variables and Macros, Variables and Macros, Variables and Macros, Variables and Macros, What Variables Are Used For, Variable Types, Variable Types, Other Types of Assignment, Other Types of Assignment, Macros, When Variables Are Expanded, Target- and Pattern-Specific Variables, Target- and Pattern-Specific Variables, Target- and Pattern-Specific Variables, Where Variables Come From, Where Variables Come From, Where Variables Come From, Where Variables Come From, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Standard make Variables, Important Miscellaneous Functions, Flow Control, Style note concerning variables and parentheses, Less Important Miscellaneous Functions, Advanced User-Defined Functions, Advanced User-Defined Functions, Command Environment, Command Environment, Command Environment, Passing Variables, Supporting Multiple Binary Trees, Setting CLASSPATH, Enterprise JavaBeans, Benchmarking, Simple Variables Versus Recursive, Simple Variables Versus Recursive, unterminated variable reference, Data Structures \$(OBJECTS), Static Pattern Rules += (append) operator, Other Types of Assignment ALL_TREES, Supporting Multiple Binary Trees assigning, speed, Benchmarking automatic, Empty Targets, Automatic Variables, Where Variables Come From empty targets and, Empty Targets built-in rules, Rule Structure case-sensitivity, Variables and Macros characters allowed, Variables and Macros CLASSPATH, Java makefile, Setting CLASSPATH computed, assert function and, Flow Control constants, user-customized, Variables and Macros CPPFLAGS, Target- and Pattern-Specific Variables CURDIR, Standard make Variables, Standard make Variables debug-enter, Advanced User-Defined Functions debug-leave, Advanced User-Defined Functions development environment, Where Variables Come From EJBS, Enterprise JavaBeans error messagess, unterminated variable reference expanding, Variables and Macros, When Variables Are Expanded curly braces and, Variables and Macros exporting, Where Variables Come From functions, user-defined, Variables and Macros grep command, Command Environment introduction, Variables and Macros macros and, Macros MAKECMDGOALS, Standard make Variables, Standard make Variables MAKEFILE_LIST, Standard make Variables, Standard make Variables MAKEFLAGS, command environment and, Command Environment MAKELEVEL, Command Environment MAKE_VERSION, Standard make Variables, Standard make Variables operators, Other Types of Assignment ?

pages: 544 words: 96,029

Practical C Programming, 3rd Edition by Steve Oualline

An apprentice builder does not start out building the Empire State Building, but rather starts on a one-room house. In this chapter, we will concentrate on constructing simple one-function programs. Basic Program Structure The basic elements of a program are the data declarations, functions, and comments. Let’s see how these can be organized into a simple C program. The basic structure of a one-function program is: /**************************************************** * ...Heading comments... * ****************************************************/ ...Data declarations... int main() { ...Executable statements... return (0); } Heading comments tell the programmer about the program, and data declarations describe the data that the program is going to use.

Exploring ES6 - Upgrade to the next version of JavaScript by Axel Rauschmayer

At the end, I’ll use the algorithm to explain the difference between the following two function declarations. function move({x=0, y=0} = {}) { ··· } function move({x, y} = { x: 0, y: 0 }) { ··· } 11.11.1 The algorithm A destructuring assignment looks like this: Destructuring 144 «pattern» = «value» We want to use pattern to extract data from value. I’ll now describe an algorithm for doing so, which is known in functional programming as pattern matching (short: matching). The algorithm specifies the operator ← (“match against”) for destructuring assignment that matches a pattern against a value and assigns to variables while doing so: «pattern» ← «value» The algorithm is specified via recursive rules that take apart both operands of the ← operator.

We read the contents of a text file via an asynchronous call to fs.readFile(): // Node.js fs.readFile('myfile.txt', { encoding: 'utf8' }, function (error, text) { // (A) if (error) { // ... } console.log(text); }); Asynchronous programming (background) 439 If readFile() is successful, the callback in line A receives a result via the parameter text. If it isn’t, the callback gets an error (often an instance of Error or a sub-constructor) via its first parameter. The same code in classic functional programming style would look like this: // Functional readFileFunctional('myfile.txt', { encoding: 'utf8' }, function (text) { // success console.log(text); }, function (error) { // failure // ... }); 24.3.3 Continuation-passing style The programming style of using callbacks (especially in the functional manner shown previously) is also called continuation-passing style (CPS), because the next step (the continuation) is explicitly passed as a parameter.

pages: 1,331 words: 183,137

Programming Rust: Fast, Safe Systems Development by Jim Blandy, Jason Orendorff

The Big Picture Rust’s enums may be new to systems programming, but they are not a new idea. Traveling under various academic-sounding names, like algebraic data types, they’ve been used in functional programming languages for more than 40 years. It’s unclear why so few other languages in the C tradition have ever had them. Perhaps it is simply that for a programming language designer, combining variants, references, mutability, and memory safety is extremely challenging. Functional programming languages dispense with mutability. C unions, by contrast, have variants, pointers, and mutability—but are so spectacularly unsafe that even in C, they’re a last resort.

The closure’s return value is taken as the new running total. The last value it returns is what fold itself returns—in this case, the total of the entire sequence. This may look strange if you’re used to for and while loops, but once you’ve gotten used to it, fold is a legible and concise alternative. This is pretty standard fare for functional programming languages, which put a premium on expressiveness. But Rust’s iterators were carefully designed to ensure that the compiler can translate them into excellent machine code as well. In a release build of the second definition shown before, Rust knows the definition of fold, and inlines it into triangle.

Terraform: Up and Running: Writing Infrastructure as Code by Yevgeniy Brikman

You can build an AMI from this template by running packer build web server.json, and once the build completes, you can deploy that AMI across all of your AWS servers, tell each one to fire up Apache on boot (you’ll see an example of this in the next section), and they will all run exactly the same way. Server templating is a key component of the shift to immutable infrastructure. This idea is inspired by functional programming, where variables are immutable, so once you’ve set a variable to a value, you can never change that variable again. If you need to update something, you create a new variable. Since variables never change, it’s a lot easier to reason about your code. The idea behind immutable infrastructure is similar: once you’ve deployed a server, you never make changes to it again.

pages: 211 words: 37,094

JQuery Pocket Reference by David Flanagan

These features are at the heart of jQuery’s power and utility: An expressive syntax (CSS selectors) for referring to elements in the document An efficient query method for finding the set of document elements that match a CSS selector A useful set of methods for manipulating selected elements Powerful functional programming techniques for operating on sets of elements as a group, rather than one at a time A succinct idiom (method chaining) for expressing sequences of operations This book begins with an introduction to jQuery that shows how to make simple queries and work with the results. The chapters that follow explain: How to set HTML attributes; CSS styles and classes; HTML form values; and element content, geometry, and data How to alter the structure of a document by inserting, replacing, wrapping, and deleting elements How to use jQuery’s cross-browser event model How to produce animated visual effects with jQuery jQuery’s Ajax utilities for making scripted HTTP requests jQuery’s utility functions The full syntax of jQuery’s selectors, and how to use jQuery’s advanced selection methods How to extend jQuery by using and writing plugins The jQuery UI library The end of this book is a quick reference to all of jQuery’s methods and functions.

pages: 194 words: 36,223

Smart and Gets Things Done: Joel Spolsky's Concise Guide to Finding the Best Technical Talent by Joel Spolsky

Sadly, despite the fact that I think that all good programmers should be able to handle recursion and pointers, and that this is an excellent way to tell if someone is a good programmer, the truth is that these days, programming languages have almost completely made that specific art unnecessary. Whereas ten years ago it was rare for a computer science student to get through college without learning recursion and functional programming in one class and C or Pascal with data structures in another class, today it’s possible in many otherwise reputable schools to coast by on Java alone.4 4. Joel Spolsky, “The Perils of JavaSchools,” published at www.joelonsoftware.com on December 29, 2005 (search for “JavaSchools”). The Guerrilla Guide to Interviewing 111 A lot of programmers whom you might interview these days are apt to consider recursion, pointers, and even data structures to be a silly implementation detail that has been abstracted away by today’s many happy programming languages.

pages: 924 words: 196,343

JavaScript & jQuery: The Missing Manual by David Sawyer McFarland

The result is something like the bottom image in Figure 11-6. In this example, the callback function was defined outside of the get() function; however, you can use an anonymous function (see Anonymous Functions) if you want to keep all of the Ajax code together: \$.get('file.php', data, function(data,status) { // callback function programming goes here }); For example, you could rewrite line 4 on Processing Data from the Server to use an anonymous function like this: \$.get('rate.php', querystring, function(data) { var newHTML; newHTML = '<h2>Your vote is counted</h2>'; newHTML += '<p>The average rating for this movie is '; newHTML += data + '.

Add one last line to the end of the keyup event function (line 10), so the completed script for the page looks like this: 1 <script> 2 \$(document).ready(function() { 3 console.log('READY'); 4 \$('#comments').keyup(function() { 5 console.log('Event: keyup'); 6 var text = \$(this).val(); 7 console.log('Contents of comments: %s',text); 8 var chars = text.length; 9 console.log('Number of characters: %d',chars); 10 \$('#count').text(chars + " characters"); 11 }); // end keyup 12 }); // end ready 13 </script> Save the file, and preview it in Firefox. Make sure Firebug is open, and the page and console should now look something like Figure 15-5. You’ll find a finished version of this tutorial—complete_console.html—in the chapter15 folder in the tutorials folder. Note Once you have a functioning program, you should remove all console.log() code from your script. The log() function will generate errors in some browsers. Figure 15-5. The Firebug console is a great way to print out diagnostic information as a program is running. You can also group together a series of log entries (for example, to group all the log messages printed during a loop) by adding console.group() before the first console.log() message in the group, and console.groupEnd() after the last message.

Fortunately, Firebug includes a powerful JavaScript debugger. It lets you step through a script line by line so you can see what’s happening at each step of the program. Note You’ll also find JavaScript debuggers with similar functionality in Chrome, Opera, Safari, and Internet Explorer 9. Debugging is the process of fixing an incorrectly functioning program—getting the bugs out. To really understand how a program is functioning (or malfunctioning), you need to see how the program works, step-by-step. To use the debugger, you mark certain lines of code as breakpoints. A breakpoint is a spot where the JavaScript interpreter stops running and waits.

pages: 273 words: 46,214

JavaScript: the good parts by Douglas Crockford

It is unfortunate that Java failed in that environment; if it hadn't, there could be a choice for people desiring a strongly typed classical language. But Java did fail and JavaScript is flourishing, so there is evidence that JavaScript did something right. The other answer is that, despite its deficiencies, JavaScript is really good. It is lightweight and expressive. And once you get the hang of it, functional programming is a lot of fun. But in order to use the language well, you must be well informed about its limitations. I will pound on those with some brutality. Don't let that discourage you. The good parts are good enough to compensate for the bad parts. 1.3. A Simple Testing Ground If you have a web browser and any text editor, you have everything you need to run JavaScript programs.

pages: 199 words: 47,154

Gnuplot Cookbook by Lee Phillips

He implemented the server-side scripting engine in the scheme-based SUnet web server, hosted the Learning-Classifier-System workshops in Tübingen. He has been the reviewer for numerous scientific articles, research proposals, and books, and has been a judge in the German Federal Competition in Computer Science on several occasions. His main interests are functional programming and machine-learning algorithms. David Millán Escrivá was 8 years old when he wrote his first program on 8086 PC with Basic language. He has more than 10 years of experience in IT. He has worked on computer vision, computer graphics, and pattern recognition. Currently he is working on different projects about computer vision and AR.

pages: 249 words: 45,639

Learn Python the Hard Way by Zed Shaw

What's the relationship between dir(something) and the "class" of something? If you do not have any idea what I'm talking about do not worry. Programmers like to feel smart so they invented Object Oriented Programming, named it OOP, and then used it way too much. If you think that's hard, you should try to use "functional programming". © Copyright 2010, Zed A. Shaw. Last updated on Jun 24, 2011. Exercise 40: Dictionaries, Oh Lovely Dictionaries Now I have to hurt you with another container you can use, because once you learn this container a massive world of ultra-cool will be yours. It is the most useful container ever: the dictionary.

pages: 309 words: 54,839

Attack of the 50 Foot Blockchain: Bitcoin, Blockchain, Ethereum & Smart Contracts by David Gerard

There were some smart contract experiments on Bitcoin, but Ethereum was pretty much the first practical platform for writing and running computer programs on a blockchain. Humans are bad at tasks requiring perfection. But when programming errors have drastic consequences, the usual approach is to make it harder to shoot yourself in the foot: functional programming languages, formal methods, mathematical verification of the code, don’t use a full computer language (avoid Turing completeness), and so on. Szabo wrote up some requirements and a simple example language in 2002.344 This is particularly important when you have multiple smart contracts interacting with each other – massively concurrent programming, with unknown possibly-hostile programs calling into functions of yours.

pages: 211 words: 58,677

Philosophy of Software Design by John Ousterhout

There has been considerable discussion about software development processes such as agile development and about development tools such as debuggers, version control systems, and test coverage tools. There has also been extensive analysis of programming techniques such as object-oriented programming and functional programming, and of design patterns and algorithms. All of these discussions have been valuable, but the core problem of software design is still largely untouched. David Parnas’ classic paper “On the Criteria to be used in Decomposing Systems into Modules” appeared in 1971, but the state of the art in software design has not progressed much beyond that paper in the ensuing 45 years.

pages: 504 words: 89,238

Natural language processing with Python by Steven Bird, Ewan Klein, Edward Loper

Processing Raw Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 Accessing Text from the Web and from Disk Strings: Text Processing at the Lowest Level Text Processing with Unicode Regular Expressions for Detecting Word Patterns Useful Applications of Regular Expressions Normalizing Text Regular Expressions for Tokenizing Text Segmentation Formatting: From Lists to Strings 80 87 93 97 102 107 109 112 116 v 3.10 Summary 3.11 Further Reading 3.12 Exercises 121 122 123 4. Writing Structured Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 Back to the Basics Sequences Questions of Style Functions: The Foundation of Structured Programming Doing More with Functions Program Development Algorithm Design A Sample of Python Libraries Summary Further Reading Exercises 130 133 138 142 149 154 160 167 172 173 173 5. Categorizing and Tagging Words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 5.10 Using a Tagger Tagged Corpora Mapping Words to Properties Using Python Dictionaries Automatic Tagging N-Gram Tagging Transformation-Based Tagging How to Determine the Category of a Word Summary Further Reading Exercises 179 181 189 198 202 208 210 213 214 215 6.

. >>> list(permutations(['police', 'fish', 'buffalo'])) [['police', 'fish', 'buffalo'], ['fish', 'police', 'buffalo'], ['fish', 'buffalo', 'police'], ['police', 'buffalo', 'fish'], ['buffalo', 'police', 'fish'], ['buffalo', 'fish', 'police']] The permutations function uses a technique called recursion, discussed later in Section 4.7. The ability to generate permutations of a set of words is useful for creating data to test a grammar (Chapter 8). Higher-Order Functions Python provides some higher-order functions that are standard features of functional programming languages such as Haskell. We illustrate them here, alongside the equivalent expression using list comprehensions. Let’s start by defining a function is_content_word() which checks whether a word is from the open class of content words. We use this function as the first parameter of filter(), which applies the function to each item in the sequence contained in its second parameter, and retains only the items for which the function returns True. 4.5 Doing More with Functions | 151 >>> def is_content_word(word): ... return word.lower() not in ['a', 'of', 'the', 'and', 'will', ',', '.'] >>> sent = ['Take', 'care', 'of', 'the', 'sense', ',', 'and', 'the', ...

Racing the Beam: The Atari Video Computer System by Nick Montfort, Ian Bogost

Warshaw told an interviewer that he had planned to use this method from the start rather than working it out as a solution to a problem that came up: “It was just a cheap way to get the effect I wanted. I didn’t have the time or space to do it any other way.”13 Still, by making the game’s code into an important visual component of Yars’ Revenge, Warshaw showed how a functioning program could shine aesthetically. When the player looks at the neutral zone on the screen, he is also literally looking at the code. Yars’ Revenge may not have had any direct inﬂuence on the spectacular movie Tron released the summer after the game, but the multicolored Master Control Program is cast in a different light by the neutral zone, actually drawn again and again by its own image, a liminal code-and-data Janus.

pages: 485 words: 74,211

Developing Web Applications with Haskell and Yesod by Michael Snoyman

As a real-life example, Yesod and Hamlet (the default templating language) use blaze-builder for textual content generation. This choice was made because blaze provides the fastest interface for generating UTF-8 data. Anyone who wants to use one of the other great libraries out there, such as text, should have no problem dropping it in. Introduction to Haskell Haskell is a powerful, fast, type-safe, functional programming language. This book takes as an assumption that you are already familiar with most of the basics of Haskell. There are two wonderful books for learning Haskell, both of which are available for reading online: Learn You a Haskell for Great Good! Real World Haskell Yesod relies on a few features in Haskell that most introductory tutorials do not cover.

Learning Node.js: A Hands-On Guide to Building Web Applications in JavaScript by Marc Wandschneider

param) throw new Error("Invalid Argument"); } One case where type comparisons can be tricky is if you use object constructors for values instead of just using primitives: > var x = 234; undefined > var x1 = new Number(234); undefined > typeof x1 'object' > typeof x 'number' > x1 == x true > x1 === x false > The object constructors are functionally equivalent to the primitive types; all the same operations, operators, and functions produce the same results, but the precise equality operator === and typeof operator produce different results. For this reason, it is recommended to just use the primitive types whenever possible. Functions Although it does not look like it at first glance (the name doesn’t help either), JavaScript is a functional programming language, wherein functions are fully typed objects that can be manipulated, extended, and passed around as data. Node.js takes advantage of this capability, and you will use it extensively in your network and web applications. Basics The simplest kind of function is exactly as you would expect: function hello(name) { console.log("hello " + name); } > hello("marc"); hello marc undefined > To declare parameters for a function in JavaScript, you simply list them in the parentheses.

pages: 681 words: 64,159

Numpy Beginner's Guide - Third Edition by Ivan Idris

Having learned about the basics, it's tme to move on to the study of commonly used functons in Chapter 3 , Getng Familiar with Commonly Used Functons , which includes basic statstcal and mathematcal functons. 3 Getting Familiar with Commonly Used Functions In this chapter, we will have a look at common NumPy functions. In particular, we will learn how to load data from files by using an example involving historical stock prices. Also, we will get to see the basic NumPy mathematical and statistical functions. We will learn how to read from and write to files. Also, we will get a taste of the functional programming and linear algebra possibilities in NumPy. In this chapter, we shall cover the following topics:  Functons working on arrays  Loading arrays from fles  Writng arrays to fles  Simple mathematcal and statstcal functons File I/O First, we will learn about fle I/O with NumPy. Data is usually stored in fles.

pages: 834 words: 180,700

The Architecture of Open Source Applications by Amy Brown, Greg Wilson

Riak consists of many complex applications, so this chapter should not be interpreted as a complete guide. It should be seen as an introduction to OTP where examples from the Riak source code are used. The figures and examples have been abbreviated and shortened for demonstration purposes. 15.1. An Abridged Introduction to Erlang Erlang is a concurrent functional programming language that compiles to byte code and runs in a virtual machine. Programs consist of functions that call each other, often resulting in side effects such as inter-process message passing, I/O and database operations. Erlang variables are single assignment, i.e., once they have been given values, they cannot be updated.

Riak was cleanly restarting each of these subsystems on demand, and the overall system simply continued to function. That experience shows exactly the sort of resilience enabled by Erlang/OTP's approach to building programs. 15.7.1. Acknowledgments This chapter is based on Francesco Cesarini and Simon Thompson's 2009 lecture notes from the central European Functional Programming School held in Budapest and Komárno. Major contributions were made by Justin Sheehy of Basho Technologies and Simon Thompson of the University of Kent. A special thank you goes to all of the reviewers, who at different stages in the writing of this chapter provided valuable feedback. The Architecture of Open Source Applications Amy Brown and Greg Wilson (eds.)

pages: 317 words: 76,169

The Perfect House: A Journey With Renaissance Master Andrea Palladio by Witold Rybczynski

While the deployment of these details formed the basis of Palladio’s style, the manner of deployment varied greatly. Sometimes he re-created entire parts of ancient buildings, such as the Villa Barbaro temple front, sometimes he merely sketched in a molding or two. The quantity and intensity of detail varied from abundant to minimal, depending on the circumstances of the commission—the site, the functional program, the budget, and the client. The last was a particularly important consideration, for Palladio believed that houses should not only be functional, well-built, and beautiful, but that they should also express what he called convenienza, or suitability. One must describe as suitable a house which will be appropriate to the status of the person who will have to live in it and of which the parts will correspond to the whole and to each other.

Microsoft Office Outlook 2010 QuickSteps by Malestrom

Enter the file name for the form, click Save, and close the form. 190 190 Microsoft Ofﬁce Outlook 2010 PC QuickSteps Getting to QuickSteps Know Your PCUsing Forms, Labels, and Mail Merge 1 USE THE DEVELOPER TAB Adding code and programming a form and working with add-ins are beyond the scope of this book. 2 NOTE The Developer tab and ribbon in the Form Design window allow you to perform the following functions: Program small scripts and macros to automate a form. Publish the form to a server so that you or anyone else with access can use it. 3 View Visual Basic script code you have added to the form. Display or rename a page. Create a new form region or rename a current one. Choose to edit the page as the sender or the reader will see it. 4 • • • • • • • • • Open and close the Field Chooser and the Control toolbox.

pages: 550 words: 84,515

Vue.js 2 Cookbook by Andrea Passaglia

Getting Started with Vue.js In this chapter the following recipes will be covered: Writing Hello World with Vue.js Writing lists Creating a dynamic and animated list Reacting to events such as clicks and keystrokes Choosing a development environment Formatting your text with filters Debugging your application with mustaches (for example, a JSON filter) X-raying your application with Vue developer tools Upgrading to Vue.js 2 Introduction Vue is a very powerful framework but one of its strengths is that it is very lightweight and easy to pick up. As a matter of fact, in the first recipe you will build a simple but functioning program in minutes, with no setup required. In this chapter, you will learn lists which will help you create web pages where an element is repeated (like a catalog). Furthermore, you will build an interactive page with event listeners. Some development environments are presented so you can choose the one that suits you better; you will use some debugging tricks that will give you a head start when developing your own code and better insight to kill bugs in your apps.

pages: 237 words: 74,109

Uncanny Valley: A Memoir by Anna Wiener

I tried to imagine a life in which I was simply her and the CEO’s third wheel. We could sit on the sidelines of the basketball court in Potrero Hill and watch him play pickup. She could teach me how to blow out my hair, and not just in the front. I pictured us going on vacations together, the three of us drinking seltzer and discussing functional programming. Perhaps I, too, could become an executive if I hung out with present and future executives. I would have access to the inside track. We could go on weekend getaways to Sonoma, rent entire houses on the home-sharing platform and stand around marble kitchen islands sipping biodynamic wines and sharing our business ideas.

pages: 1,409 words: 205,237

Architecting Modern Data Platforms: A Guide to Enterprise Hadoop at Scale by Jan Kunigk, Ian Buss, Paul Wilkinson, Lars George

Although superseded by newer engines, such as Apache Spark and Apache Flink, it is still worth understanding, given that many higher-level frameworks compile their inputs into MapReduce jobs for execution. These include: Apache Hive Apache Sqoop Apache Oozie Apache Pig Note The terms map and reduce are borrowed from functional programming, where a map applies a transform function to every element in a collection, and a reduce applies an aggregation function to each element of a list, combining them into fewer summary values. Essentially, MapReduce divides a computation into three sequential stages: map, shuffle, and reduce.

Coding Whereas the typical analyst or statistician understands methods and models mathematically, a good data scientist also has a solid background in parallel algorithms to build large-scale distributed applications around such models. As we already mentioned, the data scientist is well versed in coding in third-generation and functional programming languages, such as Scala, Java, and Python, in addition to the domain-specific languages of the classic analytics world. In this function, the data scientist collaborates with development departments to build fully fledged distributed applications that can be productively deployed to Hadoop.

The Art of Scalability: Scalable Web Architecture, Processes, and Organizations for the Modern Enterprise by Martin L. Abbott, Michael T. Fisher

Art of scalability, 2–3 Artificial Intelligence, 427–428 Assessing your situation, 502 Asynchronous chat room communication, crisis management, 157–158 Asynchronous coordination, 397–398 Asynchronous design AMI (asynchronous method invocation), 395–396 architectural principles, 202, 205–206 asynchronous coordination, 397–398 asynchronous scaling, vs. synchronous, 396–398 asynchronous systems, example, 398–401 avoiding session storage, 403–404, 405 centralizing session storage, 404, 405 Christmas tree lights analogy, 400–401 cyclomatic complexity, 400 decentralizing session storage, 404, 405 declarative programming, 402 defining state, 401 dining philosophers problem, 394 functional programming, 402 imperative programming, 402 logical programming, 402 Mealy machines, 401–402 Moore machines, 401–402 multiplicative effect of failures, 400–401 mutex synchronization, 394 mutual exclusion synchronization, 394 537 538 I NDEX Asynchronous design (continued) object-oriented programming, 402 procedural programming, 402 session environments, saving, 403–404 state, saving, 403–404 structured programming, 402 synchronization process, description, 393–394 synchronous calls, example, 395 synchronous calls vs. asynchronous, 395–401 synchronous systems, scaling issues, 398–401 Asynchronous method invocation (AMI), 395–396 Asynchronous scaling, vs. synchronous, 396–398 Asynchronous systems, example, 398–401 Atomicity, Consistency, Isolation, Durability (ACID) database properties, 383 Autonomic Computing Manifesto (IBM), 427–428 Availability fault isolation, 312–315 TAA effects, 306 TAD effects, 306 Availability, calculating customer complaints, 515–516 hardware uptime, 514–515 overview, 513–514 portion of site down, 516–517 third-party monitoring, 517–518 traffic graphs, 518–519 Axes, AKF Scale Cube.

See Cost, of scalability failure. detection, 249 likelihood, 249 multiplicative effect of, 400–401 risk management, 249 severity, 249 stress testing, 265 Failure Mode and Effects Analysis (FMEA), 249–251 Fault isolation design checklist, 321 markdown functionality, 313–314 poddings, definition, 310 pods, definition, 310, 311 pools, definition, 311 sharding, definition, 311 shards, definition, 311 slivers, definition, 311 terminology, 310–311 testing, 321–322 x-axis splits, 343 y-axis splits, 345 z-axis splits, 346 Fault isolation, approaches to along natural barriers, 320–321 by the biggest sources of incidents, 320 design checklist, 321 isolating the money-maker, 320 Fault isolation, benefits of availability, 312–315 cost, 316–317 effects on revenue, 317 incident detection, 315 incident resolution, 315 scalability, 315 time to market, 315–316 Fault isolation, design principles design checklist, 321 nothing crosses a swim lane boundary, 319 nothing is shared, 318 transactions occur along swim lanes, 319 Fault isolation, swim lanes along natural barriers, 320–321 545 546 I NDEX Fault isolation, swim lanes (continued) by the biggest sources of incidents, 320 by customer boundaries, 312–313 definition, 310, 311 isolating the money-maker, 320 by service boundaries, 313–314 Feature selection, ARB (Architecture Review Board), 228 Feature significance, JAD (Joint Architecture Design), 217 Feedback from teams, business processes, 131 Feeding teams, 98 Final design, documenting in JAD (Joint Architecture Design), 218–219 Fisher, Mike, 506, 507–508 Flexibility, cloud computing benefit, 442 FMEA (Failure Mode and Effects Analysis), 249–251 Follow up communication, crisis management, 162 Formal training, leadership, 68 Forward proxy caches. See Proxy caches. Foster, Ian, 428 Functional organization. See Team structure, functional organization. Functional programming, 402 middleware providers, 429 public vs. private networks, 429 Grid computing, uses for back office grid, 464 build grid, 462–463 data warehouse grid, 463–464 MapReduce, 464 production grid, 461–462 SETI@home project, 429 Grids, cons complexity, 459–460 monolithic applications, 459 not shared simultaneously, 459 summary of, 460 Grids, pros cost, 457–458 high computational rates, 456–457 shared infrastructure, 457 summary of, 458 utilization of unused capacity, 457 Grids, vs. clouds, 434–436 Guidelines.

RDF Database Systems: Triples Storage and SPARQL Query Processing by Olivier Cure, Guillaume Blin

To apprehend the full potential of this approach, this also has Database Management Systems to come with methods to process this data efficiently—that is, to perform the processing on the servers and to limit the transfer of data between machines to its minimum. ­MapReduce, a programming model that has been proposed by engineers at Google in 2004 (Dean and Ghemawat, 2004), is such a framework. It’s based on two operations that have existed for decades in functional programming: the map and reduce functions. In a MapReduce framework, the user programs the map and reduce functions in a given programming language, such as Java or C++. But abstractions to program these two functions are available using an SQL-like query language, such as PIG LATIN. When writing these programs, one does not need to take care about the data distribution and parallelism aspects.

Data and the City by Rob Kitchin,Tracey P. Lauriault,Gavin McArdle

Notes 1 McLuhan’s work, famously stating that ‘the medium is the message’, can be read as an early intervention into this predominant framing of media as a passive carrier (McLuhan 1994 [1964]). 2 Latour makes an analogous argument regarding sociologists’ various efforts to come to an arrangement between interaction- and structure-based perspectives: ‘The combination of two artifacts could only produce a third, yet more annoying, one’ (Latour 1996: 234). Situating data infrastructures 167 3 Notably, some functional programming languages (e.g. Lisp) follow the principle of homoiconicity, that is, they allow any piece of code to be handled like data, and vice versa. 4 For a more encompassing discussion of the assemblage in the social sciences and geography more specifically, see Marcus and Saka (2006) and Anderson and McFarlane (2011), respectively.

pages: 377 words: 110,427

The Boy Who Could Change the World: The Writings of Aaron Swartz by Aaron Swartz, Lawrence Lessig

For djb’s programs are not great machines to be admired from a distance, vast powerhouses of elegant accomplishment. They are also tools meant to be used by man, perfectly fitted to one’s hand. Like a great piece of industrial design, they bring joy to the user every time they are used. What other field combines all these arts? Language, math, art, design, function. Programming is clearly in a class of its own. And, when it comes to programmers, who even competes with djb? Who else has worked to realize these amazing possibilities? Who else even knows they are there? Oddly, there are many people who profess to hate djb. Some of this is just the general distaste of genius: djb clearly has a forceful, uncompromising vision, which many misinterpret as arrogance and rudeness.

pages: 446 words: 102,421

Network Security Through Data Analysis: Building Situational Awareness by Michael S Collins

The goal of any conversion process should be to reduce the amount of gratuitous data in the record; read the section The Characteristics of a Good Log Message in Chapter 3 for further discussion on how to reduce record sizes. A Brief Introduction to NoSQL Systems The major advance in big data in the past decade has been the popularization of NoSQL big data systems, particularly the MapReduce paradigm introduced by Google. MapReduce is based around two concepts from functional programming: mapping, which is the independent application of a function to all elements in a list, and reducing, which is the combination of consecutive elements in a list into a single element. Example 4-1 clearly shows how these elements work. Example 4-1. Map and reduce functions in Python >>> # Map works by applying a function to every element in an array, for example, we ... # create a sample array of 1 to 10 >>> sample = range(1,11) >>> # We now define a doubling function ... >>> def double(x): ... return x * 2 ... >>> # We now apply the doubling function to the sample data ... # This results in a list whose elements are double the ... # original's ... >>> map(double, sample) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] >>> # Now we create a 2-parameter function which adds two elements ... >>> def add(a, b): ... return a + b ... >>> # We now run reduce with add and the sample, add is applied ... # to every element in turn, so we get add(1,2) which produces ... # 3, the list now looks like [3,3,...] as opposed to ... # [1,2,3....], and the process is repeated, 3 is added to 3 ... # and the list now looks like [6,4,...] until everything is ... # added ... >>> reduce(add, sample) 55 MapReduce is a convenient paradigm for parallelization.

Python Geospatial Development - Second Edition by Erik Westra

Python has been used to write web-based systems, desktop applications, games, scientific programming, and even utilities and other higher-level parts of various operating systems. Python supports a wide range of programming idioms, from straightforward procedural programming to object-oriented programming and functional programming. While Python is generally considered to be an "interpreted" language, and is occasionally criticized for being slow compared to "compiled" languages such as C, the use of byte-compilation and the fact that much of the heavy lifting is done by library code means that Python's performance is often surprisingly good.

pages: 461 words: 106,027

Zero to Sold: How to Start, Run, and Sell a Bootstrapped Business by Arvid Kahl

If there are a lot of tutorials and the technology seems well-documented at first glance, it will likely be around for quite a while. Look for a vibrant community. I've noticed that in the Elixir/Phoenix community developers are very engaged, and they love spending time educating other developers about the intricacies of this functional programming language and the ecosystem. When you're new to a programming language or just not as advanced as you need to be to solve your problem, you will have to learn the lay of the land before you can dive into building your product: what are the libraries you will need to use for certain parts?

pages: 470 words: 109,589

Apache Solr 3 Enterprise Search Server by Unknown

He's worked in dot-coms on almost everything related to web application development, from architecture to user experience. He's very active in the open source community, having contributed to several projects and started many projects of his own. In 2007 he wrote SolrNet, a popular open source Solr interface for the .NET platform. Currently he's also researching the application of functional programming to web development as part of his Master's thesis. He blogs at http://bugsquash.blogspot.com. www.PacktPub.com This book is published by Packt Publishing. You might want to visit Packt's website at www.PacktPub.com and take advantage of the following features and offers: Discounts Have you bought the print copy or Kindle version of this book?

pages: 429 words: 114,726

The Computer Boys Take Over: Computers, Programmers, and the Politics of Technical Expertise by Nathan L. Ensmenger

Although these languages benefited from ALGOL, they only detracted from its efforts to emerge as a standard. With a few noticeable exceptions—the ACM continued to use it as the language of choice in its publications, for example—ALGOL was generally regarded in the United States as an intellectual curiosity rather than a functional programming language. The real question of historical interest, of course, is not so much why specific individual programming languages were created but rather why so many. In the late 1940s and early 1950s there was no real programming community per se, only particular projects being developed at various institutions.

pages: 1,064 words: 114,771

Tcl/Tk in a Nutshell by Paul Raines, Jeff Tranter

For subtle details, you will sometimes want to consult the official Tcl reference documentation, but for most tasks you should find the answer you need in this volume. We hope that this guide will become an invaluable desktop reference for the Tcl user. Conventions This desktop quick reference uses the following typographic conventions: Italic Used for commands, methods, functions, programs, and options. All terms shown in italic are typed literally. Italic is also used for filenames and URLs, and to highlight terms under discussion. Constant width Used for code in program listings and for data structures and values to be entered exactly as shown. Also used for special variables, global variables, options showing resource and class names, and subwidget names.

pages: 394 words: 118,929

Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software by Scott Rosenberg

Anderson mocked up the first crude version of a user interface in wxWidgets and wxPython. Hertzfeld whipped up a quick rendition of an address book or contacts manager. But without knowing how the program would store its data, nobody wanted to write too much; it felt like throwing walls up before you had even picked a site for a foundation. A functioning program still seemed like a mirage: No matter how many meetings the developers held or how many decisions they thought they had made, the goal moved no closer. Part of the problem was that although Kapor was the ultimate arbiter of all things Chandler, he felt out of his depth in the repository debate and didn’t want to dictate one approach over another.

pages: 385 words: 123,168

Bullshit Jobs: A Theory by David Graeber

Most of the time, the needs I am trying to fill are either my own need for a box ticker or a duct taper, or the needs of other managers, sometimes to hire people for non-BS work or to hire their ration of goons and flunkies. The reason I need duct tapers is usually because I have to compensate for poorly functioning program-management systems (both automated and human workflows) and, in some cases, a poorly functioning box ticker and even a non-BS-job subordinate who has job tenure and twenty-five years of outstanding performance ratings from a succession of previous bosses. This last is important. Even in corporate environments, it is very difficult to remove an underling for incompetence if that underling has seniority and a long history of good performance reviews.

pages: 960 words: 125,049

Mastering Ethereum: Building Smart Contracts and DApps by Andreas M. Antonopoulos, Gavin Wood Ph. D.

delegatecall method, Raw call, delegatecall deleting, Life Cycle of a Smart Contract EOAs compared to, Smart Contracts and Solidity ether and, Introducing the World Computer gas considerations, Gas Considerations-Estimating Gas Cost inheritance, Contract Inheritance-Contract Inheritance life cycle of, Life Cycle of a Smart Contract on-platform libraries, Contract Libraries security, Smart Contract Security-Conclusions Solidity and, Building a Smart Contract with Solidity-Compiling with the Solidity Compiler (solc) test frameworks, Testing Smart Contracts-Ganache: A Local Test Blockchain transmitting data payload to, Transmitting a Data Payload to an EOA or Contract-Transmitting a Data Payload to an EOA or Contract transmitting value to, Transmitting Value to EOAs and Contracts using Truffle to deploy, Using truffle to deploy a contract Vyper and (see Vyper) smartphones (see mobile (smartphone) wallets) Snowden, Edward, Ethereum’s Cryptographic Hash Function: Keccak-256 Software Guard eXtensions (SGX), Data Authentication solc (Solidity compiler), Compiling with the Solidity Compiler (solc) Solidity, Introduction to Ethereum High-Level Languagesadding constructor/selfdestruct to faucet example, Adding a Constructor and selfdestruct to Our Faucet Example building a smart contract with, Building a Smart Contract with Solidity-Conclusions calling other contracts from within a contract, Calling Other Contracts (send, call, callcode, delegatecall)-Raw call, delegatecall class inheritance, Class Inheritance compiling source file to EVM bytecode, Compiling Solidity to EVM Bytecode-Compiling Solidity to EVM Bytecode contract constructor function, Contract Constructor and selfdestruct contract definition, Contract Definition contract destruction, Contract Constructor and selfdestruct contract inheritance, Contract Inheritance-Contract Inheritance data types, Data Types-Data Types default visibility specifier problem, Default Visibilities-Real-World Example: Parity Multisig Wallet (First Hack) defined, Quick Glossary development environment, Development Environment downloading/installing, Download and Install error handling, Error Handling (assert, require, revert) event objects, Events-Catching events faucet.sol and, A Simple Contract: A Test Ether Faucet function modifiers, Function Modifiers function ordering, Function and Variable Ordering function overloading, Function Overloading function syntax, Functions functions, Functions-Functions gas considerations, Gas Considerations-Estimating Gas Cost modifiers, Modifiers oracle client interfaces in, Oracle Client Interfaces in Solidity-Oracle Client Interfaces in Solidity predefined global variables/functions, Predefined Global Variables and Functions-Built-in functions programming with, Programming with Solidity-Raw call, delegatecall selecting compiler and language version, Selecting a Solidity Compiler and Language Version selecting version of, Selecting a Version of Solidity selfdestruct function, Contract Constructor and selfdestruct smart contracts and, Building a Smart Contract with Solidity-Compiling with the Solidity Compiler (solc) variable ordering, Function and Variable Ordering variable typecasting, Variable Typecasting Vyper compared to, Comparison to Solidity-Preconditions and Postconditions writing a simple program in, Writing a Simple Solidity Program Solidity compiler (solc), Compiling with the Solidity Compiler (solc) Solidity inline assembly, Quick Glossary, Inline Assembly Spurious Dragon, Quick Glossary, Ethereum’s Four Stages of Development, Transaction Signing in Practice SputnikVM, SputnikVM Standards for Efficient Cryptography Group (SECG), Generating a Public Key Status (mobile wallet), Mobile (Smartphone) Wallets storage (see data storage) storage pointers, uninitialized, Uninitialized Storage Pointers-Real-World Examples: OpenAddressLottery and CryptoRoulette Honey Pots stub, Contract Definition submarine sends, Preventative Techniques SUICIDE (see SELFDESTRUCT opcode) Swarm, Swarmdefined, Quick Glossary installing and initializing, Preparing Swarm resolving a name to a Swarm hash, Resolving a Name to a Swarm Hash (Content) storing Auction DApp on, Storing the Auction DApp on Swarm-Uploading Files to Swarm uploading files to, Uploading Files to Swarm-Uploading Files to Swarm Swarm hash, resolving a name to, Resolving a Name to a Swarm Hash (Content) synchronization (see fast synchronization) (see first synchronization) szabo, defined, Quick Glossary Szabo, Nick, What Is a Smart Contract?

The Trade Lifecycle: Behind the Scenes of the Trading Process (The Wiley Finance Series) by Robert P. Baker

Quants also make heavy use of published papers and articles which could come from pure or applied mathematics, economics, finance and other disciplines, such as engineering and quantum physics. There is still widespread use of old-fashioned paper and pencil together with the more sophisticated spreadsheets and algorithm generator tools, such as Mathcad. 270 THE TRADE LIFECYCLE Nowadays most quants also do programming. Often they like the older, more functional programming languages such as C and Fortran, although the object-oriented C++ has become more commonly accepted. Quants want a language that allows them to write mathematics in programmatic code and that will run fast and be easy to debug if there are problems. They also want to be able to reuse common functions.

pages: 752 words: 131,533

Python for Data Analysis by Wes McKinney

= b True if a is not equal to b a <= b, a < b True if a is less than (less than or equal) to b a > b, a >= b True if a is greater than (greater than or equal) to b a is b True if a and b reference same Python object a is not b True if a and b reference different Python objects Strictness versus laziness When using any programming language, it’s important to understand when expressions are evaluated. Consider the simple expression: a = b = c = 5 d = a + b * c In Python, once these statements are evaluated, the calculation is immediately (or strictly) carried out, setting the value of d to 30. In another programming paradigm, such as in a pure functional programming language like Haskell, the value of d might not be evaluated until it is actually used elsewhere. The idea of deferring computations in this way is commonly known as lazy evaluation. Python, on the other hand, is a very strict (or eager) language. Nearly all of the time, computations and expressions are evaluated immediately.

pages: 303 words: 67,891

Advances in Artificial General Intelligence: Concepts, Architectures and Algorithms: Proceedings of the Agi Workshop 2006 by Ben Goertzel, Pei Wang

This section deals mainly with the former two; and the next section deals mainly with the latter two. 1.1. NCE Knowledge Representation The NCE utilizes a knowledge representation in which declarative knowledge is represented using weighted, labeled hypergraphs; procedural knowledge is represented using programs in a customized functional programming language called Combo; and mechanisms are in place for freely converting between declarative and procedural knowledge. Nodes and links in the declarative-knowledge hypergraph are grouped together into the category of “Atoms.” Atoms are quantified with truth values (see Fig. 1) that, in their simplest form, have two components, one representing probability (“strength”) and the other representing “weight of evidence”; and also with “attention values” (see Fig. 2) that have two components, short-term and long-term importance, representing the estimated value of the Atom on immediate and long-term time-scales.

pages: 525 words: 149,886

Higher-Order Perl: A Guide to Program Transformation by Mark Jason Dominus

Mark Foster also arrived from nowhere in the nick of time to suggest the title for this book just when I thought all was lost. This book was directly inspired by two earlier books: ML for the Working Programmer, by Lawrence Paulson, and Structure and Interpretation of Computer Programs, by Harold Abelson and Gerald Jay Sussman. Other important influences were Introduction to Functional Programming, by Richard Bird and Philip Wadler, and Paradigms of Artificial Intelligence Programming, by Peter Norvig. The official technical reviewers had a less rewarding job than they might have on other projects. This book took a long time to write, and although I wanted to have long conversations with the reviewers about every little thing, I was afraid that if I did that, I would never ever finish.

pages: 560 words: 135,629

Eloquent JavaScript: A Modern Introduction to Programming by Marijn Haverbeke

Then you’ll learn about error handling and bug fixing, modularity, and asynchronous programming before moving on to programming web browsers. As you build projects such as a browser game, a simple programming language, and a paint program, you’ll learn how to: Understand the essential elements of programming, including syntax, control, and data Organize and clarify your code with object-oriented and functional programming techniques Script the browser and make basic web applications Use the DOM effectively to interact with browsers Harness Node.js to build servers and utilities Isn’t it time you became fluent in the language of the web? About the Author Marijn Haverbeke is a programming language enthusiast and polyglot.

Principles of Protocol Design by Robin Sharp

This text was originally written for third or fourth year students in Computer Science or Electrical Engineering, and is intended to be suitable for most final-year undergraduate or postgraduate courses on advanced data communications or computer networks. The reader is expected to have a software background, in particular including a basic knowledge of functional programming and parallel programming, combined with some knowledge of computer systems architecture and data transmission. Knowledge of formal methods, for example based on languages such as VDM or Z, is not essential, but to get the most out of the book you should know about the sort of discrete mathematics which is used in computer science, and be aware of the basic concepts of mathematical proof.

pages: 696 words: 143,736

The Age of Spiritual Machines: When Computers Exceed Human Intelligence by Ray Kurzweil

However, in a discussion I had with Murray Campbell, head of the Deep Blue team, just weeks prior to its 1997 historic victory, Campbell agreed that Deep Blue’s evaluation method was more simple minded than complicated minded. MATH LESS “PSEUDO CODE” FOR THE RECURSIVE ALGORITHM Here is the basic schema for the recursive algorithm. Many variations are possible, and the designer of the system needs to provide certain critical parameters and methods, detailed below. The Recursive Algorithm Define a function (program), “PICK BEST NEXT STEP.” The function returns a value of “SUCCESS” (we’ve solved the problem) or “FAILURE” (we didn’t solve it). If it returns with a value of SUCCESS, then the function also returns the sequence of selected steps that solved the problem. PICK BEST NEXT STEP does the foliowing: PICK BEST NEXT STEP: • Determine if the program can escape from continued recursion at this point.

pages: 603 words: 141,814

Python for Unix and Linux System Administration by Noah Gift, Jeremy M. Jones

Hybrid Kudzu Design Pattern: Wrapping a Tool in Python, and Then Changing the Behavior In our last example, we made snmpdf quite a bit easier to use, but we didn’t change the basic behavior of the tool. The output of both tools was identical. Another approach we can use is to not only engulf a Unix tool, but to then change the basic behavior of the tool with Python as well. In the next example, we use Python’s generators in a functional programming style to filter the results of our snmpdf command to search for critical information, and then append a "CRITICAL" flag to it. Example 13-11 shows what it looks like. Example 13-11. Altering the SNMPDF command with generators #!/usr/bin/env python import optparse from subprocess import Popen, PIPE import re def main(): p = optparse.OptionParser(description="Python wrapped snmpdf command", prog="pysnmpdf", version="0.1a", usage="%prog machine") p.add_option("-c", "--community", help="snmp community string") p.add_option("-V", "--Version", help="snmp version to use") p.set_defaults(community="public",Version="2c") options, arguments = p.parse_args() SNMPDF = "snmpdf" if len(arguments) == 1: machine = arguments[0] #We create a nested generator function def parse(): """Returns generator object with line from snmpdf""" ps = Popen([SNMPDF, "-c", options.community, "-v",options.Version, machine], stdout=PIPE, stderr=PIPE) return ps.stdout #Generator Pipeline To Search For Critical Items pattern = "9[0-9]%" outline = (line.split() for line in parse()) #remove carriage returns flag = (" ".join(row) for row in outline if re.search(pattern, row[-1])) #patt search, join strings in list if match for line in flag: print "%s CRITICAL" % line #Sample Return Value #Real Memory 2067636 1974120 93516 95% CRITICAL else: p.print_help() if __name__ == '__main__': main() If we run our new “altered” version of snmpdf we get this output on test machine: [ngift@Macintosh-8][H:10486][J:0]# python snmpdf_alter.py localhost Real Memory 2067636 1977208 90428 95% CRITICAL We now have a completely different script that will only generate output if a value in snmpdf is 90 percent or higher, which we have signified as critical.

pages: 757 words: 193,541

The Practice of Cloud System Administration: DevOps and SRE Practices for Web Services, Volume 2 by Thomas A. Limoncelli, Strata R. Chalup, Christina J. Hogan

It is similar to Perl and Python in syntax, but adds features that make it easy to create mini-languages, purpose-built for a specific task. More programs can then be written in that mini-language. Scripting languages are more flexible and versatile than shell scripts. They are more expressive, permit better code organization, scale better, and encourage more modern coding practices such as object-oriented coding and functional programming. Better testing tools are available, and there are more prewritten libraries. Scripting languages have the ability to access networks, storage, and databases more easily than shell scripts. Better error checking is also available. Perl, Python, and Ruby all have large libraries of modules that perform common system administration tasks such as file manipulation, date and time handling, transactions using protocols such as HTTP, and database access.

HBase: The Definitive Guide by Lars George

There are a variety of ways to include HBase as a source and target for MapReduce jobs. Native Java The Java-based MapReduce API for HBase is discussed in Chapter 7. Clojure The HBase-Runner project (https://github.com/mudphone/hbase-runner/) offers support for HBase from the functional programming language Clojure. You can write MapReduce jobs in Clojure while accessing HBase tables. Hive The Apache Hive project[76] offers a data warehouse infrastructure atop Hadoop. It was initially developed at Facebook, but is now part of the open source Hadoop ecosystem. Hive offers an SQL-like query language, called HiveQL, which allows you to query the semistructured data stored in Hadoop.

Algorithms in C++ Part 5: Graph Algorithms by Robert Sedgewick

to the same tree in this forest. Figure 19.28 illustrates this fact for our example, and we will prove it in a moment. Therefore, we can assign component numbers as we did for undirected graphs, incrementing the component number each time that the recursive function returns to the top-level search function. Program 19.10 is a full implementation of the method. Property 19.14 Kosaraju’s method finds the strong components of a graph in linear time and space. Proof: The method consists of minor modifications to two DFS procedures, so the running time is certainly proportional to V2 for dense graphs and V + E for sparse graphs (using an adjacency-lists representation), as usual.

pages: 619 words: 210,746

Reversing: Secrets of Reverse Engineering by Eldad Eilam

The general idea is that a Trojan horse is an innocent artifact openly delivered through the front door when it in fact contains a malicious element hidden somewhere inside of it. In the software world, this translates to seemingly innocent files that actually contain some kind of malicious code underneath. Most Trojans are actually functional programs, so that the user never becomes aware of the problem; the functional element in the program works just fine, while the malicious element works behind the user’s back to promote the attacker’s interests. It’s really quite easy to go about hiding unwanted functionality inside a useful program.

PostGIS in Action by Regina O. Obe, Leo S. Hsu

We also think they’re pretty cool languages in their own right. They’re favorites among geostatisticians and GIS programmers. PL/Python and PL/R only come in the untrusted form; PL/V8 only comes trusted. Python is a dynamically typed, all-purpose procedural language. It has elegant approaches for creating and navigating objects, and it supports functional programming, object-oriented programming, the building of classes, metaprogramming, reflection, map reduce, and all those chic programming paradigms you’ve probably heard of. R, on the other hand, is more of a domain language. R is specifically designed for statistics, graphing, and data mining, so it draws a large following from research institutions.

pages: 1,085 words: 219,144

Solr in Action by Trey Grainger, Timothy Potter

In fact, the need to build a web-scale inverted index led to the invention of MapReduce. MapReduce is a programming model that distributes large-scale data-processing operations across a cluster of commodity servers by formulating an algorithm into two phases: map and reduce. With its roots in functional programming, MapReduce was adapted by Google for building its massive inverted index to power web search. Using MapReduce, the map phase produces a unique term and document ID where the term occurs. In the reduce phase, terms are sorted so that all term/docID pairs are sent to the same reducer process for each unique term.

pages: 933 words: 205,691

Hadoop: The Definitive Guide by Tom White

A natural question to ask is: can you do anything useful or nontrivial with it? The answer is yes. MapReduce was invented by engineers at Google as a system for building production search indexes because they found themselves solving the same problem over and over again (and MapReduce was inspired by older ideas from the functional programming, distributed computing, and database communities), but it has since been used for many other applications in many other industries. It is pleasantly surprising to see the range of algorithms that can be expressed in MapReduce, from image analysis, to graph-based problems, to machine learning algorithms.[8] It can’t solve every problem, of course, but it is a general data-processing tool.

pages: 761 words: 231,902

The Singularity Is Near: When Humans Transcend Biology by Ray Kurzweil

Sam Williams, "When Machines Breed," August 12,2004, http://www.salon.com/tech/feature/2004/08/12/evolvable_hardware/index_np.html. 177. Here is the basic scheme (algorithm description) of recursive search. Many variations are possible, and the designer of the system needs to provide certain critical parameters and methods, detailed below. THE RECURSIVE ALGORITHM Define a function (program) "Pick Best Next Step." The function returns a value of "SUCCESS" (we've solved the problem) or "FAILURE" (we didn't solve it). If it returns with a value of SUCCESS, then the function also returns the sequence of steps that solved the problem. PICK BESTNEXT STEP does the following: · Determine if the program can escape from continued recursion at this point.

PostGIS in Action, 2nd Edition by Regina O. Obe, Leo S. Hsu

We also think they’re pretty cool languages in their own right. They’re favorites among geostatisticians and GIS programmers. PL/Python and PL/R only come in the untrusted form; PL/V8 only comes trusted. Python is a dynamically typed, all-purpose procedural language. It has elegant approaches for creating and navigating objects, and it supports functional programming, object-oriented programming, the building of classes, metaprogramming, reflection, map reduce, and all those chic programming paradigms you’ve probably heard of. Licensed to tracy moore <nordick.an@gmail.com> www.it-ebooks.info 418 CHAPTER 16 Extending PostGIS with pgRouting and procedural languages R, on the other hand, is more of a domain language.

pages: 903 words: 235,753

The Stack: On Software and Sovereignty by Benjamin H. Bratton

Cars with Apps, medical devices with Apps, or any machine with Apps also suggest design assignments for modular forms of bottom-up artificial intelligence. Any machine, whether general or highly specific, could be imbued with the narrowly focused intelligence of the App linked to a wider Cloud and could download any particular sensing, sensory, storing, calculative, or transmission function programmed for it. Each can do that without addressing humans or requesting our interference in the communication flow between machine User and Cloud. The most important, viable, and effective Apps and App market platforms may serve the nonhuman Users that interface across scales and systems—manufacturing, logistics, healthcare, transportation, agriculture, retail service—by linking and delinking modular functions of component machines working in interoperable concert.44 In this economy, the universal flexibility of the “hand” dissipates into a more open field of tactical computation animating all programmable platform components more equally.

pages: 1,156 words: 229,431

The IDA Pro Book by Chris Eagle

If for some reason you fail to specify an index when you want to delete a single element, you may end up deleting an entire array. Similar functions exist to delete supval, charval, and hashval data. Useful SDK Datatypes IDA’s API defines a number of C++ classes designed to model components typically found in executable files. The SDK contains classes to describe functions, program sections, data structures, individual assembly language instructions, and individual operands within each instruction. Additional classes are defined to implement the tools that IDA uses to manage the disassembly process. Classes falling into this latter category define general database characteristics, loader module characteristics, processor module characteristics, and plug-in module characteristics, and they define the assembly syntax to be used for each disassembled instruction.

The Dream Machine: J.C.R. Licklider and the Revolution That Made Computing Personal by M. Mitchell Waldrop

In other words, Lisp could be written in Lisp, with only a very small kernel of machine code to keep it moored to the physical operation of the com- puter. That Lisp kernel, known as apply, thus provided a particularly elegant example of a uni- versal Turing machine: it was the universal function that took the definition of any other function as input and then executed that function. By no coincidence, McCarthy imple- mented this kind of functional programming in Lisp using the notation of the "lambda calcu- lus," which Alonzo Church had created twenty years earlier to solve the decidabihty problem, and which had allowed him to beat Alan Turing to the punch. THE TALE OF THE FIG TREE AND THE WASP 173 run it all, and he even had everything in place to run the world's first demon- stration of that scheme-everything, that is, except the blasted interrupt handler, which IBM still hadn't delivered.

pages: 923 words: 516,602

The C++ Programming Language by Bjarne Stroustrup

[UNIX,1985] UNIX Time-Sharing System: Programmer’s Manual. Research Version, Tenth Edition. AT&T Bell Laboratories, Murray Hill, New Jersey. February 1985. [Wilson,1996] Gregory V. Wilson and Paul Lu (editors): Parallel Programming Using C++. The MIT Press. Cambridge. Mass. 1996. ISBN 0-262-73118-5. [Wikström,1987] Åke Wikström: Functional Programming Using ML. Prentice-Hall. Englewood Cliffs, New Jersey. 1987. [Woodward,1974] P. M. Woodward and S. G. Bond: Algol 68-R Users Guide. Her Majesty’s Stationery Office. London. England. 1974. References to books relating to design and larger software development issues can be found at the end of Chapter 23.