Illustrator CS4 For Dummies or Programming ERLANG

Illustrator CS4 For Dummies

Author: Ted Alspach

Have more fun and get more done with Illustrator—here’s how to free your creativity!
Illustrator is the artist’s choice for creating spectacular graphics, and here’s the fast and easy way to get up to speed on all the coolest features. This full-color guide gives you the scoop on the newest tools; tips on color control and path editing; ways to organize graphics; and how to create for print, the Web, or mobile devices.

• Colorful choices — learn when to choose RGB instead of CMYK and how to get perfect color when printing
• Follow the path — compare path and pixel documents, adjust points on a path, and learn to use the versatile Pen and Pencil tools
• Just your type — use the Character and Paragraph panels and get creative with type on a path
• The artistic Web — work in pixel preview mode, create Web-specific vector graphics, and use Flash with Illustrator
• Get it out there — set up your pages for printing and work with separations, or save files in Web friendly formats

Open the book and find:

• How to work with Illustrator’s panels and menus
• The newest tools and how to use them
• Ways to create basic shapes and bring them together
• Simple steps for tweaking color
• How to create straight lines and precise curves
• What to do with styles and effects
• How to organize with the Layers panel
• How Illustrator works with the rest of Adobe’s Creative Suite

Book review: Democratic Institutions of Undemocratic Individuals or Eugene McCarthy

Programming ERLANG: Software for a Concurrent World

Author: Joe Armstrong

Erlang solves one of the most pressing problems facing developers today: how to write reliable, concurrent, high-performance systems. It's used worldwide by companies who need to produce reliable, efficient, and scalable applications. Invest in learning Erlang now.

Moore's Law is the observation that the amount you can do on a single chip doubles every two years. But Moore's Law is taking a detour. Rather than producing faster and faster processors, companies such as Intel and AMD are producing multi-core devices: single chips containing two, four, or more processors. If your programs aren't concurrent, they'll only run on a single processor at a time. Your users will think that your code is slow.

Erlang is a programming language designed for building highly parallel, distributed, fault-tolerant systems. It has been used commercially for many years to build massive fault-tolerated systems that run for years with minimal failures.

Erlang programs run seamlessly on multi-core computers: this means your Erlang program should run a lot faster on a 4 core processor than on a single core processor, all without you having to change a line of code.

Erlang combines ideas from the world of functional programming with techniques for building fault-tolerant systems to make a powerful language for building the massively parallel, networked applications of the future.

This book presents Erlang and functional programming in the familiar Pragmatic style. And it's written by Joe Armstrong, one of the creators of Erlang.

It includes example code you'll be able to build upon. In addition, the book contains the full source code for two interesting applications:

ASHOUTcastserver which you can use to stream music to every computer in your house, and a full-text indexing and search engine that can index gigabytes of data.

Learn how to write programs that run on dozens or even hundreds of local and remote processors. See how to write robust applications that run even in the face of network and hardware failure, using the Erlang programming language.

Table of Contents:

Begin     1
Road Map     2
Begin Again     5
Acknowledgments     6
Getting Started     7
Overview     7
Installing Erlang     10
The Code in This Book     12
Starting the Shell     13
Simple Integer Arithmetic     14
Variables     16
Floating-Point Numbers     21
Atoms     22
Tuples     24
Lists     27
Strings     29
Pattern Matching Again     30
Sequential Programming     33
Modules     33
Back to Shopping     39
Functions with the Same Name and Different Arity     42
Funs     42
Simple List Processing     48
List Comprehensions     51
Arithmetic Expressions     54
Guards     55
Records     59
Case and if Expressions     62
Building Lists in Natural Order     63
Accumulators     64
Exceptions     67
Exceptions     67
Raising an Exception     68
Try...catch     69
Catch     72
Improving Error Messages     73
Programming Style with try...catch     73
Catching Every Possible Exception     74
Old- and New-Style Exception Handling     75
Stack Traces     75
Advanced Sequential Programming     77
BIFs     78
Binaries     78
The Bit Syntax     80
Miscellaneous Short Topics     89
Compiling and Running Your Program     109
Starting and Stopping the Erlang Shell     109
Modifying the Development Environment     110
Different Ways to Run Your Program     113
Automating Compilation with Makefiles     118
Command Editing in the Erlang Shell     121
Getting Out of Trouble     122
When Things Go Wrong     122
Getting Help     125
Tweaking the Environment     126
The Crash Dump     127
Concurrency     129
Concurrent Programming     133
The Concurrency Primitives     134
A Simple Example     135
Client-Server-An Introduction     136
How Long Does It Take to Create a Process?     140
Receive with a Timeout     142
Selective Receive     145
Registered Processes     146
How Do We Write a Concurrent Program?     148
A Word About Tail Recursion     148
Spawning with MFAs     149
Problems     150
Errors in Concurrent Programs     151
Linking Processes     151
An on_exit Handler     152
Remote Handling of Errors     154
The Details of Error Handling     154
Error Handling Primitives     162
Sets of Linked Processes     164
Monitors     164
A Keep-Alive Process     165
Distributed Programming     167
The Name Server     169
The Distribution Primitives     174
Libraries for Distributed Programming     177
The Cookie Protection System     178
Socket-Based Distribution     179
IRC Lite     183
Message Sequence Diagrams     185
The User Interface     186
Client-Side Software     187
Server-Side Software     191
Running the Application     195
The Chat Program Source Code     196
Exercises      203
Interfacing Techniques     205
Ports     206
Interfacing an External C Program     207
Open_port     213
Linked-in Drivers     214
Notes     218
Programming with Files     219
Organization of the Libraries     219
The Different Ways of Reading a File     220
The Different Ways of Writing to a File     228
Directory Operations     232
Finding Information About a File     233
Copying and Deleting Files     234
Bits and Pieces     234
A Find Utility     235
Programming with Sockets     239
Using TCP     240
Control Issues     249
Where Did That Connection Come From?     252
Error Handling with Sockets     253
UDP     254
Broadcasting to Multiple Machines     257
A SHOUTcast Server     259
Digging Deeper     266
ETS and DETS: Large Data Storage Mechanisms     267
Basic Operations on Tables     268
Types of Table     269
ETS Table Efficiency Considerations     270
Creating an ETS Table      271
Example Programs with ETS     273
DETS     278
What Haven't We Talked About?     281
Code Listings     282
OTP Introduction     285
The Road to the Generic Server     286
Getting Started with gen_server     295
The gen_server Callback Structure     299
Code and Templates     303
Digging Deeper     306
Mnesia: The Erlang Database     307
Database Queries     307
Adding and Removing Data in the Database     311
Mnesia Transactions     313
Storing Complex Data in Tables     317
Table Types and Location     319
Creating the Initial Database     322
The Table Viewer     323
Digging Deeper     323
Listings     325
Making a System with OTP     329
Generic Event Handling     330
The Error Logger     333
Alarm Management     340
The Application Servers     342
The Supervision Tree     345
Starting the System     348
The Application     352
File System Organization     354
The Application Monitor     355
Digging Deeper     355
How Did We Make That Prime?     357
Multicore Prelude     359
Programming Multicore CPUs     361
How to Make Programs Run Efficiently on a Multicore CPU     362
Parallelizing Sequential Code     366
Small Messages, Big Computations     369
Mapreduce and Indexing Our Disk     373
Growing Into the Future     383
Documenting Out Program     385
Erlang Type Notation     386
Tools That Use Types     389
Erlang on Microsoft Windows     391
Erlang     391
Fetch and Install MinGW     391
Fetch and Install MSYS     392
Install the MSYS Developer Toolkit (Optional)     392
Emacs     392
Resources     395
Online Documentation     395
Books and Theses     396
Link Collections     396
Blogs     396
Forums, Online Communities, and Social Sites     397
Conferences     397
Projects     397
Bibliography     398
A Socket Application     399
An Example      399
How lib_chan Works     402
The lib_chan Code     405
Miscellaneous     415
Analysis and Profiling Tools     415
Debugging     418
Tracing     427
Dynamic Code Loading     431
Module and Function Reference     435
Module: application     435
Module: base64     436
Module: beam_lib     437
Module: c     437
Module: calendar     439
Module: code     440
Module: dets     441
Module: dict     444
Module: digraph     445
Module: digraph_utils     446
Module: disk_log     447
Module: epp     448
Module: erl_eval     449
Module: erl_parse     449
Module: erl_pp     450
Module: erl_scan     450
Module: erl_tar     450
Module: erlang     451
Module: error_handler     460
Module: error_logger     460
Module: ets     461
Module: file     464
Module: file_sorter     466
Module: filelib     467
Module: filename      467
Module: gb_sets     468
Module: gb_trees     470
Module: gen_event     471
Module: gen_fsm     472
Module: gen_sctp     473
Module: gen_server     474
Module: gen_tcp     474
Module: gen_udp     475
Module: global     475
Module: inet     476
Module: init     477
Module: io     477
Module: io_lib     478
Module: lib     479
Module: lists     479
Module: math     483
Module: ms_transform     483
Module: net_adm     483
Module: net_kernel     484
Module: os     484
Module: proc_lib     485
Module: qlc     485
Module: queue     486
Module: random     487
Module: regexp     488
Module: rpc     488
Module: seq_trace     490
Module: sets     490
Module: shell     491
Module: slave     491
Module: sofs     492
Module: string     496
Module: supervisor     497
Module: sys     497
Module: timer     498
Module: win32reg     499
Module: zip     500
Module: zlib     500
Index     503