the rest

markup langs:

SQL
http://www.w3schools.com/sql/default.asp

XML

go do the xml thing first
1. http://www.w3schools.com/xhtml/xhtml_intro.asp
2. http://www.w3schools.com/xsl/xsl_languages.asp
3. http://www.w3schools.com/xpath/default.asp
4. http://www.w3schools.com/xslfo/default.asp

5. sgml
-------------------------------

others:
go:
-http://golang.org/doc/go_tutorial.html
-http://blog.golang.org/2010/07/gos-declaration-syntax.html
-http://golang.org/doc/go_tutorial.html


scala:
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-1
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-2
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-3
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-4
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5


So far the documentation is anoying; every time I read a document it has jargon that is either java PL buzzwords or scala specific.

The most important things in scala seem to be:
pattern matching
first class functions
case classes
- http://www.scala-lang.org/node/107
- http://webcache.googleusercontent.com/search?q=cache:45KFeYN40gEJ:www.codecommit.com/blog/scala/case-classes-are-cool+what+are+case+classes&hl=en&client=firefox-a&gl=us&strip=1

new operator syntax for embedded dsls
type inference
implicits
- http://patricklogan.blogspot.com/2007/06/scala-implicits.html
structural (duck) typing
import syntax
collections
actors
- http://www.scala-lang.org/node/242
traits
- http://www.scala-lang.org/node/126
problems with scala:
http://warpedjavaguy.wordpress.com/2010/08/02/the-scala-is-too-complex-conspiracy-1/
http://michid.wordpress.com/2010/08/24/so-scala-is-too-complex/
http://www.infoq.com/news/2009/07/scala-replace-java
http://blog.ericdaugherty.com/2010/07/is-scala-too-complex.html
http://jaxenter.com/is-scala-too-complex-30645.html


weird:
http://www.hermetic.ch/pca/algorithms.htm

dumbing down the programmer:
http://en.wikipedia.org/wiki/Component-based_software_engineering

Ruby

Ruby:
http://yonkeltron.com/2010/05/13/creating-a-ruby-dsl/
DSL. DSL. DSL! http://en.wikipedia.org/wiki/Domain-specific_language
Think in terms of DSLS and blocks. Everything in terms of blocks and defining
a langugage to fit the problem!
metaprogramming
http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html
http://mislav.uniqpath.com/poignant-guide/book/chapter-2.html
http://www.contextualdevelopment.com/articles/2008/ruby-singleton
http://ruby-metaprogramming.rubylearning.com/
dsl:
http://www.rubyinside.com/how-to-build-a-dsl-domain-specific-language-in-ruby-356.html
http://yonkeltron.com/2010/05/13/creating-a-ruby-dsl/
http://themomorohoax.com/2009/02/25/how-to-write-a-clean-ruby-dsl-rails
http://www.themomorohoax.com/2009/02/25/how-to-write-a-clean-ruby-dsl-part-2-line-by-line-with-machinist-rails
http://jroller.com/rolsen/entry/building_a_dsl_in_ruby
http://jroller.com/rolsen/entry/building_a_dsl_in_ruby1
http://jroller.com/obie/entry/the_magic_of_ruby_dsl

http://www.infoq.com/news/2007/06/dsl-or-not

C/C++

All languages use libraries, so that isn’t really quite a distinguishing feature. However you should probably pay attention to the *quality* of libraries available.
Java and Python have the best general libraries, hands down. C++ is good with QT.

http://olvemaudal.wordpress.com/2008/11/27/c-idioms-by-example/
http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms
http://www2.research.att.com/~bs/bs_faq2.html (bjarne’s style/idioms faq)
http://stackoverflow.com/questions/1759613/what-c-idioms-should-c-programmers-use

- qt smart ptrs:
http://stackoverflow.com/questions/2884202/qt-and-auto-ptr
http://labs.qt.nokia.com/2009/08/25/count-with-me-how-many-smart-pointer-classes-does-qt-have/

PIMPL (pointer to implementation idiom)
http://en.wikipedia.org/wiki/Opaque_pointer
http://www.c2.com/cgi/wiki?PimplIdiom
http://www.gotw.ca/gotw/028.htm (fast pimpl)

RAII
http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization

Patterns:
http://en.wikibooks.org/wiki/C++_Programming/Code/Design_Patterns
http://en.wikipedia.org/wiki/Singleton_pattern
http://en.wikipedia.org/wiki/Observer_pattern
http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
http://en.wikipedia.org/wiki/Decorator_pattern
http://en.wikipedia.org/wiki/Delegation_pattern
http://en.wikipedia.org/wiki/Factory_method_pattern
http://en.wikipedia.org/wiki/Reactor_pattern

COM:
http://msdn.microsoft.com/en-us/library/ms680573%28v=vs.85%29.aspx
http://en.wikipedia.org/wiki/Component_Object_Model

Look at the syllabi:
Basic

1. Introduction to the STL
• purpose and structure of the STL: containers, algorithms, and iterators
• review: class and function templates
• container classification, characteristics, and content
• iterator classification and behavior
• generic algorithms and iterators
• design of generic algorithms and performance guarantees
• iostream iterators
2. Generic Algorithms
• review: generic algorithms and helper templates
• interaction between algorithms and iterators
• generic algorithm goals, documentation, and design
• sequences, subsequences, and sequence errors
• descriptions of STL algorithms
3. Containers
• properties, insertion and deletion effects, specific functionality
• vectors
• lists
• maps
• containers and exceptions
• choosing an appropriate container
• container adapters
4. Function Objects
• functions and generic algorithms
• function objects and generic algorithms
• algorithm families
• function objects and containers, strict weak ordering
• standard function objects

Advanced:

1. Adapters
• function object adapters
• binders and negaters
• helper tempates and template argument deduction
• pointer to function adapters
• composing new function objects
• designing function object adapters
• container adapters
• priority_queues and heaps
2. Iterator Design
• the iterator base class and iterator traits
• review: class template specialization and partial specialization
• iterators and const_iterators
• accessing iterator information in generic algorithms
• versioning of generic algorithms based on iterator class
• reverse iterators and iterator adapters
• insert iterators, adapters, and helpers
• raw storage iterators, adapters, and helpers
• designing new iterators
3. Container Design
• containers vs. STL containers
• STL container requirements
• design of a simple STL container
• design of a more complex STL container
• containers, iterators, and const_iterators
• basic STL components
4. Allocator Design
• containers and memory management
• allocators and the standard allocator
• allocator portability problems
• container use of allocators
• design of a special-purpose allocator
• allocator hacking techniques

"i'm used to writing async code already and this is all neatly tied to the posix layer, which makes non-blocking network stuff ridiculously easy. there's also the package system (npm), async test suites, no worries about messing up the global namespace, etc. you gotta OOP tho if you just throw literals around you can't have or protect a local scope"

Javascript (node.js) http://nodejs.org/ review:

http://www.w3schools.com/js/js_howto.asp
http://www.w3schools.com/xml/xml_whatis.asp
http://www.w3schools.com/dom/dom_intro.asp

NODE

• downside, requires libssl-dev (fixed with -no-ssl)
• install with “git clone https://github.com/joyent/node” (ryan is now joyent)

Use Prototype Programming, Delegation.
prototype based programming -http://coweb.cc.gatech.edu/cs2340/4288

// Example of true prototypal inheritance style in JavaScript.
// "ex nihilo" object creation employing the literal object notation {}.
var foo = {one: 1, two: 2};
// Another "ex nihilo" object.
var bar = {three: 3};
// Gecko and Webkit JavaScript engines can directly
// manipulate the internal prototype link.
// For the sake of simplicity, let's just pretend
// that the following line works regardless of the
// engine used:
bar.__proto__ = foo; // foo is now the parent of bar.
// If we try to access foo's properties from bar
// from now on, we'll succeed.
bar.one // Resolves to 1.
// The child object's properties are also accessible.
bar.three // Resolves to 3.

Don’t bother with Normal OOP. tho you can :

• http://msdn.microsoft.com/en-us/magazine/cc163419.aspx
• http://en.wikipedia.org/wiki/Prototype_based_programming
• delegation http://en.wikipedia.org/wiki/Delegation_%28programming%29

Docs:

• http://www.w3schools.com/JS/js_intro.asp (javascript)
• http://nodejs.org/docs/v0.4.1/api/all.html#__filename (node api)

operator overloading (not supported, this spec is fake)
http://www.mozilla.org/js/language/js20-2000-07/libraries/operator-overloading.html

https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript
node examples:
http://blog.osbutler.com/categories/node-by-example/?page=3
https://github.com/nodejitsu/nexpect/blob/master/demo.js (uses spawned procs)

“DOn’t bother with OOP, just learn the DOM”
http://en.wikipedia.org/wiki/Document_Object_Model

look at the GOOG custom search API, it’s in JSON:
http://code.google.com/apis/customsearch/v1/overview.html
http://www.w3schools.com/ajax/default.asp