This book is a detailed and authoritative introduction to all aspects of Lua programming, by Lua’s chief architect.

Programming in Lua gives a solid base for any programmer who wants to use Lua. It covers all aspects of Lua—from the basics to its API with C—explaining how to make good use of its features and giving numerous code examples. The book is targeted at people with some programming background, but it does not assume any prior knowledge about Lua or other scripting languages.

Chapters include:

• Chunks
• Global Variables
• Some Lexical Conventions
• The Stand-Alone Interpreter
• Nil
• Booleans
• Numbers
• Strings
• Tables
• Functions
• Userdata and Threads
• Arithmetic Operators
• Relational Operators
• Logical Operators
• Concatenation
• Precedence
• Table Constructors
• Assignment
• Local Variables and Blocks
• Control Structures
• break and return
• Multiple Results
• Variable Number of Arguments
• Named Arguments
• Closures
• Non-Global Functions
• Proper Tail Calls
• Iterators and the Generic for
• Compilation, Execution, and Errors
• Coroutine Basics
• Pipes and Filters
• Coroutines as Iterators
• Non-Preemptive Multithreading
• Complete Examples
• Arrays
• Linked Lists
• Matrices and Multi-Dimensional Arrays
• Queues and Double Queues
• Sets and Bags
• String Buffers
• Data Files and Persistence
• Arithmetic Metamethods
• Relational Metamethods
• Library-Defined Metamethods
• Table-Access Metamethods
• Accessing Global Variables with Dynamic Names
• Declaring Global Variables
• Non-Global Environments
• Packages
• Object-Oriented Programming
• Weak Tables
• The Mathematical Library
• The Table Library
• The String Library
• The I/O Library
• The Operating System Library
• The Debug Library
• An Overview of the C API
• Extending your Application
• Calling C from Lua
• Techniques for Writing C Functions
• User-Defined Types in C
• Managing Resources

http://www.lua.org/pil/

JavaScript is one of the easiest, most straightforward ways to enhance a Web site with interactivity.

Sams Teach Yourself JavaScript in 24 Hours serves as an easy-to-understand tutorial on both scripting basics and JavaScript itself. The book is written in a clear and personable style with an extensive use of practical, complete examples.

Readers will learn how to use JavaScript to enhance Web pages with interactive forms, objects, and cookies. They will also discover how to use JavaScript to work with games, animation, and multimedia.

Chapters include:

• Understanding JavaScript
• Creating a Simple Script
• How JavaScript Programs Work
• Using Functions and Variables
• Using Strings and Arrays
• Testing and Comparing Values
• Repeating Yourself: Using Loops
• Using Math and Date Functions
• Working with the Document Object Model
• Responding to Events
• Using Windows and Frames
• Getting Data with Forms
• Using Graphics and Animation
• Creating Cross-Browser Scripts
• Creating Custom Objects
• Working with Sounds and Plug-Ins
• Debugging JavaScript Applications
• Working with Style Sheets
• Using Dynamic HTML (DHTML)
• Using Advanced DOM Features
• Improving a Web Page with JavaScript
• Creating a JavaScript Game
• Creating DHTML Applications
• JavaScript Tips and Tricks

http://www.informit.com/library/library.aspx?b=STY_JavaScript_24_hours

Bash is the shell, or command language interpreter, for the GNU operating system. The name is an acronym for the ‘Bourne-Again SHell’, a pun on Stephen Bourne, the author of the direct ancestor of the current Unix shell /bin/sh, which appeared in the Seventh Edition Bell Labs Research version of Unix.

Bash is largely compatible with sh and incorporates useful features from the Korn shell ksh and the C shell csh. It is intended to be a conformant implementation of the IEEE POSIX Shell and Tools specification (IEEE Working Group 1003.2). It offers functional improvements over sh for both interactive and programming use.

While the GNU operating system provides other shells, including a version of csh, Bash is the default shell. Like other GNU software, Bash is quite portable. It currently runs on nearly every version of Unix and a few other operating systems – independently-supported ports exist for MS-DOS, OS/2, Windows 95/98, and Windows NT.

Chapters include:

• Introduction
• Definitions
• Basic Shell Features
• Shell Syntax
• Shell Operation
• Shell Commands
• Shell Functions
• Shell Parameters
• Shell Expansions
• Redirections
• Executing Commands
• Shell Builtin Commands
• Shell Variables
• Bash Features
• Invoking Bash
• Bash Startup Files
• Interactive Shells
• Bash Conditional Expressions
• Shell Arithmetic
• Aliases
• Arrays
• The Directory Stack
• Controlling the Prompt
• The Restricted Shell
• Bash POSIX Mode
• Job Control
• Command Line Editing
• Readline Interaction
• Readline Init File
• Bindable Readline Commands
• Readline vi Mode
• Programmable Completion
• Using History Interactively
• Installing Bash

http://www.linuxtopia.org/online_books/bash_reference_guide/index.html

The primary reason for this document is that a lot of readers feel the existing HOWTO to be too short and incomplete, while the Bash Scripting guide is too much of a reference work. There is nothing in between these two extremes. It was also written on the general principal that not enough free basic courses are available, though they should be.

This is a practical guide which, while not always being too serious, tries to give real-life instead of theoretical examples. It was partly written because the author doesn’t get excited with stripped down and over-simplified examples written by people who know what they are talking about, showing some really cool Bash feature so much out of its context that you cannot ever use it in practical circumstances. You can read that sort of stuff after finishing this book, which contains exercises and examples that will help you survive in the real world.

From the author’s experience as a UNIX/Linux user, system administrator and trainer, he knows that people can have years of daily interaction with their systems, without having the slightest knowledge of task automation. Thus they often think that UNIX is not user friendly, and even worse, they get the impression that it is slow and old-fashioned. This problem is another one that can be remedied by this guide.

Chapters include:

• Introduction
• Bash and Bash scripts
• Writing and debugging scripts
• The Bash environment
• Regular expressions
• The GNU sed stream editor
• The GNU awk programming language
• Conditional statements
• Writing interactive scripts
• Repetitive tasks
• More on variables
• Functions
• Catching signals

http://www.linuxtopia.org/online_books/bash_guide_for_beginners/index.html

This book is for anyone who has an interest in SQL Server 2012 and wants to understand its capabilities. In a book of this size, we cannot cover every feature that distinguishes SQL Server from other databases or previous versions, and consequently we assume you have some   familiarity with SQL Server already. You might be a database administrator (DBA), an application developer, a business intelligence solution architect, a power user, or a technical decision maker. Regardless of your role, we hope you can use this book to discover the features in SQL Server 2012 that are most beneficial to you.

Chapters include:

• SQL Server 2012 Editions and Engine Enhancements
• High-Availability and Disaster-Recovery Enhancements
• Performance and Scalability
• Security Enhancements
• Programmability and Beyond-Relational Enhancements
• Integration Services
• Data Quality Services
• Master Data Services
• Analysis Services and PowerPivot
• Reporting Services

http://blogs.msdn.com/b/microsoft_press/archive/2012/03/15/free-ebook-introducing-microsoft-sql-server-2012.aspx

Java Look and Feel Design Guidelines, second edition, provides essential information for anyone involved in creating cross-platform GUI (graphical user interface) applications and applets in the JavaTM programming language. In particular, this book offers design guidelines for software that uses the Swing classes together with the Java look and feel.

This revised and expanded edition contains a collection of toolbar graphics, lists of terms localized for European and Asian languages, and an appendix on look and feel switching. New and revised guidelines are provided throughout, and new sections discuss smooth interaction, the use of badges in button graphics, and revised standards for window titles.

Although an application’s human interface designer and software developer might well be the same person, the two jobs involve different tasks and require different skills and tools. Primarily, this book addresses the designer who chooses the interface elements, lays them out in a set of components, and designs the user interaction model for an application. (Unless specified otherwise, this book uses "application" to refer to both applets and applications.) This book should also prove useful for developers, technical writers, graphic artists, production and marketing specialists, and testers who participate in the creation of Java applications and applets.

Java Look and Feel Design Guidelines focuses on design issues and human-computer interaction in the context of the Java look and feel. It also attempts to provide a common vocabulary for designers, developers, and other professionals.

The guidelines provided in this book are appropriate for GUI applications and applets that run on personal computers and network computers. They do not address the needs of software that runs on consumer electronic devices.

Chapters include:

• The Java Look and Feel
• The Java Foundation Classes
• Design Considerations
• Visual Design
• Application Graphics
• Behavior
• Windows and Panes
• Dialog Boxes and Alert Boxes
• Menus and Toolbars
• Basic Controls
• Text Components
• Selectable Lists, Tables, and Tree Components
• Keyboard Shortcuts, Mnemonics, and Other Keyboard Operations
• Graphics Repository
• Localization Word Lists
• Switching Look and Feel Designs

http://java.sun.com/products/jlf/ed2/book/index.html

Creating a Java program is a bit like making a movie or putting on a play. Every theatrical production needs actors (in Java these are objects), roles the actors play (classes), and scenes the actors play out (methods). In a movie or play, actors step into one of their scenes when given a cue; in a Java program, objects enter one of their methods when cued to do so by another object. The Java interpreter, which runs each Java program, is like a combination stage manager and producer—it creates the set, casts the actors, and teaches them their roles. We, as Java programmers, are like playwrights (or screenwriters) and directors put together, we specify the roles the actors will play. Our program’s users are the audience.

Just as a stage manager and a producer read a play or movie script to find out what sets to create and what kinds of actors to audition, the Java interpreter reads each of the classes that we as programmers write to find out how objects of that class must behave (their role). Unlike temperamental actors, however, each Java object does exactly as its class tells it, so each object is the personification of a single role. Real actors can play many roles; Java objects are all role. A play’s script usually specifies the actions of many characters in lots of different roles: butlers, tycoons, girl scouts, lone gunmen. A Java class, however, only specifies the actions of one quite specific type of character; that is, one role. So a simple Java program might be the equivalent of an extremely boring play about a butler forever polishing silverware, or a snoozer about a tennis pro playing exactly one round of a game of tennis. A complex program, however, might describe a universe of thousands of roles for its objects to play, all working together to run a sophisticated game, a nuclear power station, a national telephone service, or an orbital telescope.

Chapters include:

• Setting the Stage
• Introducing the Players
• Behind the Scenes
• Character Study
• Stage Direction
• All Together Now
• It Takes All Types
• What’s in a Name?
• Think Like an Object
• Let the Games Begin
• The Play’s the Thing
• Networking
• Defensive Programming
• Design Patterns
• Navel Gazing
• Satori
• Avoiding Style Crime
• Java’s Flaws
• Book Recommendations
• The Rest of Java

http://www.roxie.org/books/bleeding/tableofcontents.html

Dive Into Python 3 covers Python 3 and its differences from Python 2. Compared to Dive Into Python, it’s about 20% revised and 80% new material.

Chapters include:

• What’s New in “Dive Into Python 3”
• Installing Python
• Your First Python Program
• Native Datatypes
• Comprehensions
• Strings
• Regular Expressions
• Closures & Generators
• Classes & Iterators
• Advanced Iterators
• Unit Testing
• Refactoring
• Files
• XML
• Serializing Python Objects
• HTTP Web Services
• Case Study: Porting chardet to Python 3
• Packaging Python Libraries
• Porting Code to Python 3 with 2to3
• Special Method Names
• Where to Go From Here
• Troubleshooting

http://diveintopython3.ep.io/

Dive Into Python is a free Python book for experienced programmers. It was originally hosted at DiveIntoPython.org, but the author has pulled down all copies. It is being mirrored here.

Chapters include:

• Installing Python
• Your First Python Program
• Native Datatypes
• The Power Of Introspection
• Objects and Object-Orientation
• Exceptions and File Handling
• Regular Expressions
• HTML Processing
• XML Processing
• Scripts and Streams
• HTTP Web Services
• SOAP Web Services
• Unit Testing
• Test-First Programming
• Refactoring
• Functional Programming
• Dynamic functions
• Performance Tuning

http://www.diveintopython.net/

‘A Byte of Python’ is a free book on programming using the Python language. It serves as a tutorial or guide to the Python language for a beginner audience. If all you know about computers is how to save text files, then this is the book for you. 

Chapters include:

• Introduction
• Installation
• First Steps
• Basics
• Operators and Expressions
• Control Flow
• Functions
• Modules
• Data Structures
• Problem Solving
• Object Oriented Programming
• Input Output
• Exceptions
• Standard Library
• More
• What Next

http://www.swaroopch.com/notes/Python

Free Software projects are changing the software landscape in impressive ways with dedicated users and innovative management. Each person contributes something to the movement in their own way and to their abilities and knowledge. This personal commitment and the power of collaboration over the internet is what makes Free Software great and what brought the authors of this book together.

This book is the answer to "What would you have liked to know when you started contributing?". The authors give insights into the many different talents it takes to make a successful software project, coding of course but also design, translation, marketing and other skills. We are here to give you a head start if you are new. And if you have been contributing for a while already, we are here to give you some insight into other areas and projects.

Chapters include:

• Ideas and Innovation
• Code First
• Everyone Else Might Be Wrong, But Probably Not
• Out of the Lab, into the Wild
• Prepare for the Future: Evolution of Teams in FLOSS
• You’ll Eventually Know Everything They’ve Forgotten
• University and Community
• Being Allowed to Do Awesome
• Love the Unknown
• Backups to Maintain Sanity
• The Art of Problem Solving
• Cross-Project Collaboration
• Writing Patches
• Given Enough Eyeballs, Not All Bugs are Shallow
• Kick, Push
• Test-Driven Enlightenment
• Life-Changer Documentation for Novices
• Good Manners Matter
• Documentation and My Former Self
• Stop Worrying and Love the Crowd
• My Project Taught Me how to Grow Up
• Learn from Your Users
• Software that Has the Quality Without A Name
• Don’t Be Shy
• Use of Color and Images in Design Practices
• How Not to Start a Community
• Hindsight is Almost 20/20
• Things I’m Happy I Didn’t Know
• From Beginner to Professional
• Packaging – Providing a Great Route into Free Software
• Where Upstream and Downstream Meet
• Finding Your Feet in a Free Software Promotion Team
• Big Plans Don’t Work
• Who are You, What are You Selling, and Why Should I Care?
• People are Everything
• Getting People Together
• We’re Not Crazy . . . We’re Conference Organizers!
• How to Ask for Money
• Free Software in Public Administrations
• Underestimating the Value of a Free Software Business Model
• Free and Open Source-Based Business Models
• On being a Lawyer in FOSS
• Building Bridges

http://open-advice.org/

The book is written assuming no prior programming knowledge on the part of the readers. However, we make certain other assumptions that we shall explain now.

Many a times, on a clear night when we look up at the stars, we can’t help but wonder whether there is intelligent life out there – or are they just like us?

For we don’t believe that intellect is a quality that we are born with. In fact we are going to share a secret with you. It is the secret of success given to us by an old gypsy woman. This magic mantra has worked with many and we assume you would also use it in your life. In fact this is the only assumption we make in this book.

The secret is in persistence – nothing in the world can take place of persistence. Talent will not, nothing is more common than unsuccessful people with talent. Genius will not, unrewarded genius is almost a proverb. Education will not, the world is full of educated derelicts. Persistence and determination alone are omnipotent. We hope you agree with the old gypsy apply the maxim while learning C#.

Chapters include:

• Getting Started
• Namespaces
• Constructors and Destructors 
• Components and Databases
• Web Enabling Data
• Function Overloading and Inheritance
• Modifiers
• Virtual Functions – new, override
• Properties and Indexers 
• Interfaces and Structures
• Operator Overloading
• Collection Objects
• Attributes, The Reflection API and Conditionals 
• Unsafe code

http://www.vijaymukhi.com/documents/books/csbasics/csharp1.html

The primary goal of this book is to promote object-oriented design using C# and to illustrate the use of the emerging object-oriented design patterns. Experienced object-oriented programmers find that certain ways of doing things work best and that these ways occur over and over again. The book shows how these patterns are used to create good software designs. In particular, the following design patterns are used throughout the text: singleton, container, enumeration, adapter and visitor.

Virtually all of the data structures are presented in the context of a single, unified, polymorphic class hierarchy. This framework clearly shows the relationships between data structures and it illustrates how polymorphism and inheritance can be used effectively. In addition, algorithmic abstraction is used extensively when presenting classes of algorithms. By using algorithmic abstraction, it is possible to describe a generic algorithm without having to worry about the details of a particular concrete realization of that algorithm.

A secondary goal of the book is to present mathematical tools just in time. Analysis techniques and proofs are presented as needed and in the proper context. In the past when the topics in this book were taught at the graduate level, an author could rely on students having the needed background in mathematics. However, because the book is targeted for second- and third-year students, it is necessary to fill in the background as needed. To the extent possible without compromising correctness, the presentation fosters intuitive understanding of the concepts rather than mathematical rigor.

Chapters include:

• Colophon
• Dedication
• Preface
• Contents
• Introduction
• Algorithm Analysis
• Asymptotic Notation
• Foundational Data Structures
• Data Types and Abstraction
• Stacks, Queues, and Deques
• Ordered Lists and Sorted Lists
• Hashing, Hash Tables, and Scatter Tables
• Trees
• Search Trees
• Heaps and Priority Queues
• Sets, Multisets, and Partitions
• Garbage Collection and the Other Kind of Heap
• Algorithmic Patterns and Problem Solvers
• Sorting Algorithms and Sorters
• Graphs and Graph Algorithms
• C# and Object-Oriented Programming
• Class Hierarchy Diagrams
• Character Codes
• References

http://www.brpreiss.com/books/opus6/

This tutorial was given at the Microsoft .NET Crash Course in Cambridge on March 25-28, 2002. It is intended for programmers who are already familiar with Java or similar languages. It starts out with basic C# features such as types, expressions, statements and object-orientation and continues with more advanced features such as threads, attributes, namespaces and assemblies. It also provides a short glimpse into .NET’s base class library.

Contents include:

• Part 1: Introduction to C#
• Part 2: Advanced C#

http://www.ssw.uni-linz.ac.at/Teaching/Lectures/CSharp/Tutorial/

Is this book for you? If you’re a programmer in a language other than C++ and you want to upgrade your skills, then you shouldn’t have much difficulty figuring that out for yourself by reading a few pages. But what if you have no previous programming experience? In that case, here’s a little quiz that may help you decide:
1. Do you want to know how the programs in your computer work inside and how to write some of your own?
2. Are you willing to exert yourself mentally to learn a complex technical subject?
3. Do you have a sense of humor?
If you’ve answered yes to these questions and follow through with the effort required, then you will get a lot out of this book.

Chapters include:

• Introduction to Programming
• Hardware Fundamentals
• Basics of Programming
• More Basics
• Functional Literacy
• Taking Inventory
• Creating a Homegrown string class
• Finishing Our homegrown string class
• Inheritance
• Polymorphism
• The Home Inventory Project
• More on the Home Inventory Project
• Analyzing the Home Inventory Project

http://www.steveheller.com/cppad/cppad.htm