Software Development

Software development and consultant agencies
Articles
Resources
Quotes
Conferences
Open-sourced projects
Frameworks
History
Code search
Studios / Agencies
Blogs
logging
monitoring
deployment
graphing
General Coding Guide
Programming Practices
Design Patterns
Agile Development
Code Search
Code Review
APIs
Core Data

html
css
javascript

nodejs
rails
java
scala
groovy
python

Other programming languages

Concurrency
Callback hell
Thread pool hell

Guava

TDD
REST
SOA

http://www.opencompute.org/

WebRTC

REPL: read–eval–print loop
serverless microservices using AWS Lambda or Google Cloud Functions
Ava and Enzymem and React
GridFS

Functional programming
Object oriented programming

Start with designing the schema. You can specify constraints (column size), validation rules, etc. Each time that a column is added or removed, the tool can automatically generate a database migration script. We can also use the constraints and validation rules for both front-end and back-end validation. I got this idea when I was learning meteor.

We should use proper ORM
We should use server side validation
We should implement a mechanism to prevent robot from trashing our database.

Release engineering

https://twitter.com/electronjs
https://asana.com
https://www.datadoghq.com/lpg/
https://stamplay.com/
https://www.codemontage.com/
http://sourcebits.com/future-of-wearables/

Some time ago, I needed to develop a tool that do something with a web page. I needed to do this using Visual Basic, and the interface or library that Microsoft made available for embedding IE inside the Visual Basic application. With VisualBasic, you drag and drop the controls (input fields, or buttons) onto the canvas. VisualBasic automatically generate all the stub methods, and all I had to do was to go down the list, provide implementation (fill in the blank) for the methods that I need to implement. When I reach the end of the list, I know that I am done. Writing software should be this easy.

I also interviewed at a company and their product: you describe the attribute of the objects in your application, and their product generate the application code for you, or something like this. I can't recall this exactly. There is also something called the Wolf Framework, and another thing (look at the mysql-tools page).

Separate front-end development from back-end development using JSON. Front-end developers can work with designer, use stubbed or mocked JSON to create the application. The job of the back-end developers become just "fill in the blanks" (go down the list of stubbed or mocked JSON and implement them one by one). Of course the back-end developers still have to database modeling and all the things that they normally need to do, and front-end developers still have to do all the things that they need to do, but this ability to decouple front-end development from back-end development does give us some freedom, such as front-end developers can start their work while you hire back-end developers. Look into http://hood.ie/

For healthcare and financial application, avoid Java or any language that support multi-threading. Use languages that does not support multi-threading, or run them in a multi-processes manner. The database must be ACID compliance. If the database must use multi-threading, that is fine because database vendors usually test their product for ACID compliance. Think of those HIPPA violations or financial issues that could have been avoided if multi-threading was not used. This does not mean that we are HIPPA-bullet-proof if we are not using multi-threading. There are other requirements that we must implement, but not using multi-threading would save us a lot of time and trouble. If we must use multi-threading, we should use CheckThread or other tools that test for concurrency issues as part of our build / deploy process.

Server push events versus client poll. What are the advantages of server push? What is the impact on the infrastructure (number of servers required, load balancers, firewalls)? Why is server push better than client poll now rather than in the past?

REPL: Read-eval-print loop

Use JSON as the data exchange format. Move application / business logic to the client-side. Use separate library or component for rendering (dealing with different browser or device). The back-end code is to handle server side validation, security, and persistence (storing and retrieving data). I am not sure if this is a good idea (competitor can easily look at the front-end code and re-construct the back-end code), but it seems that some libraries are moving this way. This is food for thought.

Static content should be served using a separate domain, using CDN if practical, compressed and minified.

How can we allow users to choose a different format for the response? Some API users may prefer that we send the response using JSON. Some API users may prefer that we send the response using XML. How can we support this? Which framework offer this capability?

BeanStalk is a private GitHub with deployment

http://www.impressivewebs.com/my-talk-slides-from-fitc-toronto-2015/
http://www.sitepoint.com/drowning-in-tools-web-development-industry

http://semver.org/
http://community.sitepoint.com/t/do-you-use-semantic-versioning/109822

http://www.sitepoint.com/important-software-development-trends-2015

https://koding.com/
topcoder.com
http://apiary.io/
http://cozy.io/

http://www.sitepoint.com/automotive-trends-app-developers/

https://github.com/alabid/flylatex
https://geekli.st/home

https://habitrpg.com/static/front

Sublime Text2

Git-tower.com

https://codeship.com/

https://www.documentcloud.org/home

http://vschart.com/compare/tower-js/vs/flatiron/vs/socketstream/vs/derbyjs - An example of how to compare libraries. The row header has a tooltip that explain the meaning. The column header should have position:fixed. Need to add a row for "getting started" tutorial, video tutorials. Why does Node default to MongoDB? Do all apps now run on NoSQL? Need to see if it supports NoSQL. Need to see if it support RDBMS. Data integrity? Download size. Performance benchmark.

http://kafka.apache.org/ - A high-throughput distributed messaging system.

http://www.eecs.berkeley.edu/~rcs/research/interactive_latency.html
http://mmcgrana.github.io/2010/07/threaded-vs-evented-servers.html

http://cometd.org/
http://docs.cometd.org/
https://github.com/cometd
http://camel.apache.org/cometd.html

Server-sent event

playframework
http://engineering.linkedin.com/play/play-framework-linkedin
https://www.playframework.com/documentation/2.1.0/ScalaWebSockets

http://www.sitepoint.com/radar-advent-calendar-internet-addiction/
http://www.sitepoint.com/syntax-taste-refactoring-conditionals/
http://www.sitepoint.com/2014-review-niches-become-mainstream/
http://blog.codinghorror.com/
http://www.sitepoint.com/developing-cross-platform-applications-qt/
http://www.sitepoint.com/radar-week-firefox-mv-frameworks-go
http://www.sitepoint.com/introducing-appmaker-teaching-coding-app-design
http://www.sitepoint.com/mozilla-introduces-firefox-developer-edition
http://www.sitepoint.com/introduction-wai-aria/
http://www.siliconvalley-codecamp.com/
http://domaindrivendesign.org/

http://www.sitepoint.com/contributing-open-source-updating-phalconphp-com
http://www.sitepoint.com/5-innovative-ways-use-web-data
http://www.sitepoint.com/javascript-beyond-web-2014
http://www.sitepoint.com/replacing-radio-buttons-without-replacing-radio-buttons
http://www.sitepoint.com/supercharge-slack-powerful-workplace-collaboration
http://www.sitepoint.com/satisficing-mean-web-forms
http://www.sitepoint.com/good-developer
http://radar.oreilly.com/2014/10/its-time-to-call-time-on-nerd-culture.html
http://codeascraft.com/2014/09/30/building-a-better-build-our-transition-from-ant-to-sbt
http://www.sitepoint.com/long-live-web-app/
http://www.sitepoint.com/understanding-empty-pseudo-class
http://www.sitepoint.com/introduction-html-imports-tutorial
http://www.sitepoint.com/thought-responsive-text-just-fad
http://www.sitepoint.com/5-innovative-ways-use-web-data
http://davidwalsh.name/top-20-tools-resources-creating-website
https://www.academia.edu/8513964/Scrum_A_New_Delusion

http://www.sitepoint.com/building-pull-quote-custom-element-polymer
https://www.youtube.com/watch?v=VfNPLS9VFSo
http://www.sitepoint.com/introduction-to-web-components-and-polymer-tutorial
http://www.webperformancetoday.com/2014/09/17/progressive-image-rendering-good-evil
http://www.sitepoint.com/quick-tip-install-zephir-phalcon-2-vagrant/
http://www.sitepoint.com/legacy-code-cancer/
http://www.sitepoint.com/8-essential-skills-developers-can-learn-in-a-weekend
http://www.sitepoint.com/what-learn-front-end-development-8-2014/
http://www.sitepoint.com/mvc-problem-solution/
http://www.sitepoint.com/semantic-versioning-why-you-should-using
http://www.sitepoint.com/6-tips-for-writing-better-code
http://www.sitepoint.com/set-up-development-machine
http://www.sitepoint.com/repository-design-pattern-demystified
http://www.sitepoint.com/googles-bigquery-provides-free-access-gdelt
http://www.sitepoint.com/flow-based-programming-noflo
http://www.sitepoint.com/time-complexity-algorithms
https://www.kickstarter.com/projects/627324241/release-the-game
http://blog.httpwatch.com/2014/05/22/beware-your-cloud-server-may-have-some-ip-related-baggage
http://devops.com/blogs/bridget-kromhouts-devops-humanity-goes-viral
http://www.sitepoint.com/code-kata
http://www.sitepoint.com/look-devdocs-io/
http://www.sitepoint.com/getting-started-assetic/
http://www.sitepoint.com/learning-to-focus
http://aosabook.org/en/selenium.html
http://www.sitepoint.com/refactoring-workout-relentlessly-green
https://www.tbray.org/ongoing/When/201x/2014/01/01/Software-in-2014
http://www.performancebydesign.co.uk/how-and-why-to-move-performance-testing-earlier-in-the-development-cycle-wopr22/
http://www.sitepoint.com/how-set-up-my-development-machine-windows/

How to store users' private and sensitive data in the database so that the data is not compromised even in the case where our database is compromised or our employees are tempted to see the data?

Database vendors / software do offer features that allow us to store the data encrypted on disk. We should investigate these options first.

Alternatively, we can use something similar to multi-factor authentication. After the user log into the application, we ask the user to enter a PIN. We do not store this PIN in the database. However, we store an hash (MD5, SHA1, or other implementation) of this PIN. After the user provides the PIN, we performs the hash and compare the result with the stored hash string. If the two hash strings equal to each other, the user is validated. We can also use this PIN as the encryption key or decryption key. This way, our employees do not know the key to decrypt the data, unless our employee modify the code to log the PIN to the log file. This approach also has some one draw back. All private and sensitive data has to be serialized as a JSON string before encryption. Perhaps, in our model, we can declare that a particular column requires encryption and decryption, and the model automatically do JSON encoding before encryption, and JSON decoding after decryption.

jQuery Defer

Supporting the back button for one-page web application:
http://jqueryfordesigners.com/enabling-the-back-button/
See the jquery-plugins page and search for History

Web Accessibility:
http://whatsock.com/bootstrap/

Frameworks:
http://www.wakanda.org/
Play
http://jersey.java.net/
http://www.wolfframeworks.com/
https://c9.io/

Wolf Framework:
http://www.wolfframeworks.com/
http://www.youtube.com/user/WolfFrameworks
http://www.crunchbase.com/company/wolf-frameworks
http://venturebeatprofiles.com/company/profile/wolf-frameworks
http://www.jamcracker.com/cloud-catalog/wolf-frameworks
http://www.indianweb2.com/2009/02/wolf-framework-is-web-application-designing-development-platform-as-a-service-paas/
http://en.wikipedia.org/wiki/Wolf_Frameworks
http://jtonedm.com/2010/01/25/first-look-wolf-frameworks-paas/

Miscellaneous Articles and Best Practices:
http://www.youtube.com/watch?v=_EANG8ZZbRs
http://www.youtube.com/watch?v=5WXYw4J4QOU
http://www.sitepoint.com/change-your-apis-without-losing-customers/
http://programming.oreilly.com/2013/10/making-systems-operable.html
http://programming.oreilly.com/2013/09/efficient-effective-communication-still-often-elusive.html
List of important publications in computer science
http://www.miketheman.net/2013/08/11/the-importance-of-dependency-testing
http://www.codeproject.com/Articles/10103/Refactoring-to-Adaptive-Object-Modeling-Property-P
http://www.linkedin.com/today/post/article/20130717220743-94530-peer-to-peer-models-like-herding-cats
http://www.richardnichols.net/2009/08/using-bottom-up-iterative-object-database-layer-with-hbm2java-and-warp-persist/
http://www.richardnichols.net/2009/08/add-package-or-class-filtering-to-your-findbugs-ant-task/
http://20bits.com/articles/introduction-to-dynamic-programming/
http://20bits.com/articles/facebook-job-puzzles-korn-shell/
http://20bits.com/articles/facebook-job-puzzles-prime-bits/
http://www.fastcodesign.com/1670019/10-steps-to-designing-an-amazing-infographic
Gears and the Mashup problem
Dion Almaer of Ajaxian and Google on Gears, App Engine, and More
http://www.smashingapps.com/2010/04/08/the-truth-about-top-supercomputers-in-the-world-infographic.html
5 Things You Need to Know About Raytracing
YQL Geo Library and Introduction to Geo Hacking talk
http://davidwalsh.name/facebook-modal-mootools
http://www.space.com/17906-physics-supersonic-skydive.html
http://techcrunch.com/2012/10/06/evolution-and-big-bang-are-lies-says-congressman-from-house-committee-on-science/
http://www.paperplanes.de/2012/7/10/on-resilience-in-automated-systems-failures-and-human-factor.html
http://www.fastcompany.com/1841145/patent-patrol-microsoft-may-be-planning-a-bigger-mobile-device-future
http://www.infosecisland.com/blogview/21597-Software-Security-is-a-Business-Problem.html
http://www.readwriteweb.com/archives/how_google_warps_time_to_keep_its_computers_runnin.php
http://uxdesign.smashingmagazine.com/2012/02/23/redefining-hicks-law/
Tien Tzuo, CTO of salesforce.com spoke on enterprise software
http://www.sitepoint.com/write-3d-soft-engine-scratch-part-1/
http://codahale.com/
https://github.com/codahale
http://simpleprogrammer.com/2013/04/14/what-makes-code-readable-not-what-you-think
http://www.techworld.com.au/article/459054/taking_pain_debugging_live_programming/
http://caines.ca/blog/programming/the-node-js-community-is-quietly-changing-the-face-of-open-source/
http://henrikwarne.com/2013/05/05/great-programmers-write-debuggable-code/
http://henrikwarne.com/2013/03/26/what-do-programmers-want/
http://www.agiledata.org/essays/relationalDatabases.html
http://www.agiledata.org/essays/impedanceMismatch.html
http://www.agiledata.org/essays/enterpriseArchitecture.html
http://www.sitepoint.com/technical-debt/
http://victorsavkin.com/
http://en.wikipedia.org/wiki/Aspect-oriented_programming
http://benalman.com/news/2012/09/partial-application-in-javascript/
http://sourcemaking.com/antipatterns
http://en.wikipedia.org/wiki/Anti-pattern
http://en.wikibooks.org/wiki/Introduction_to_Software_Engineering/Architecture/Anti-Patterns
http://c2.com/cgi/wiki?AntiPattern
http://www.antipatterns.com
http://5whys.com/blog/12-behavior-anti-patterns-you-will-face-as-a-software-team-l.html
http://www.devx.com/Java/Article/29162
http://www.designpatternsfor.net/Presentations/AntiPatternsInSoftwareProjects.TheHumanFactor.V2.pdf
http://www.ambysoft.com/essays/brokenTriangle.html
http://www.infoq.com/articles/ddd-in-practice
http://tratt.net/laurie/tech_articles/articles/programming_languages_and_the_speed_of_light
http://rubysource.com/code-metrics-and-you/
http://agile2009.agilealliance.org/taxonomy/term/203/
http://agile2009.agilealliance.org/node/494/
http://37signals.com/svn/
http://rubysource.com/dci-the-evolution-of-the-object-oriented-paradigm/
http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
http://net.tutsplus.com/tutorials/other/base-what-a-practical-introduction-to-base-encoding/
http://net.tutsplus.com/tutorials/php/understanding-hash-functions-and-keeping-passwords-safe/
http://net.tutsplus.com/tutorials/php/creating-an-api-centric-web-application/
http://net.tutsplus.com/articles/news/the-increasing-importance-of-apis-in-web-development/
http://coderhaven.wordpress.com/2011/02/21/how-to-become-a-better-developer-architect/
http://net.tutsplus.com/tutorials/tools-and-tips/understanding-the-principles-of-algorithm-design/
http://net.tutsplus.com/tutorials/php/wrangling-with-the-facebook-graph-api/
http://net.tutsplus.com/tutorials/organizing-enterprise-level-applications/
http://steve-yegge.blogspot.com/2006/03/blog-or-get-off-pot.html
http://steve-yegge.blogspot.com/2006/03/math-for-programmers.html
http://steve-yegge.blogspot.com/2006/03/moores-law-is-crap.html
http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html
http://www.infoq.com/presentations/Functional-Programming-A-Pragmatic-Introduction
http://www.infoq.com/presentations/Best-Practices-eBay
http://www.youtube.com/watch?v=1xUz1fp23TQ&feature=related (Design Patterns, roughly 1 hour)
http://www.youtube.com/watch?v=EEjNb9yUv1k&feature=relmfu (Pattern Matching, 54 minutes)
http://www.youtube.com/watch?v=zZdQ6HXXDiE&feature=relmfu (Software Testing, 55 minutes)
http://www.youtube.com/watch?v=fJaPlsVIzio&feature=relmfu (Lecture 12, Data Modelling - ER Diagrams, Mapping 58 minutes)
http://www.youtube.com/watch?v=WSNqcYqByFk&feature=related (Lecture 11, Data Modelling - ER Diagrams, Mapping, 1 hour)
http://www.youtube.com/watch?v=3VW9ujdB-jM&feature=related (Lecture 41, Case Study - Part One Database Design 53 minutes)
http://www.youtube.com/watch?v=w23fiSVWyM8&feature=related (Data Modeling and Conceptual Sketching in the Design Process, 1 hour 25 minutes)
http://www.youtube.com/watch?v=EUzsy3W4I0g&feature=related (Introduction to Database Management, 53 minutes)
http://www.youtube.com/watch?v=yIFxN8eXfe4&feature=related (The Theory of Normalization, 55 minutes)
http://www.youtube.com/watch?v=C2hSJOS9pks&feature=related (Introduction to UML)
http://www.youtube.com/watch?v=Xxvpwmc-7io&feature=related (The Observer Design Pattern, 7 minutes)
http://www.youtube.com/watch?v=sXLP5SLRrgQ&feature=related (Google I/O 2008 - Design Patterns in an Expressive Language, 44 minutes)
http://www.youtube.com/watch?v=Dtd0njgo4s8&feature=related (10 Things Every Software Architect Should Know, 50 minutes)
http://www.youtube.com/watch?v=gPCUAcbbQ-Q&feature=related (Data Modeling for the Database Developer, Designer & Admin, 58 minutes)
http://www.youtube.com/watch?v=abDEmGtcjkk&feature=relmfu (Cloud Computing, The Next Frontier for OS, 55 minutes)
http://www.youtube.com/watch?v=OFkgSjRnay4&feature=related (Git in One Hour, 1 hour)
http://www.youtube.com/watch?v=Z6-iUNfJsJw&feature=related (Writing LINQ Queries with LINQPad)
http://www.sitepoint.com/write-3d-soft-engine-scratch-part-1/
http://www.sitepoint.com/write-3d-soft-engine-scratch-part-2/
http://programming.oreilly.com/2013/09/the-brain-at-work.html

Tutorials:
http://www.sitepoint.com/creating-a-notepad-app-with-indexeddb/

Other:
http://codeforamerica.org/2013/05/15/michal-migurski-why-i’m-coding-for-america/

Guice:
http://www.richardnichols.net/2009/06/the-5-minute-guice-primer/
http://code.google.com/p/google-guice/
http://www.richardnichols.net/2010/08/session-replication-with-guice-java-web-applications/
http://www.richardnichols.net/2010/09/guice-java-ioc-best-practices-annotation-configuration/
http://www.richardnichols.net/2010/05/aop-annotation-based-caching-solution-for-guice-projects/
http://www.richardnichols.net/2011/12/writing-reflective-unit-tests-to-improve-code-quality/
http://www.richardnichols.net/2009/07/unfortunately-interesting-java-generics/

Building highly distributed concurrent application:
http://akka.io/
http://netty.io/
http://kafka.apache.org/
https://github.com/codahale/metrics
http://metrics.codahale.com/

Erlang:
http://www.bluegraybox.com/blog/2011/09/18/erlang-your-new-favorite-scripting-language/

Scala:
http://www.scala-lang.org/
http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaOverview.pdf
http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaTutorial.pdf
http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaByExample.pdf
http://scala-ide.org/
http://typesafe.com/technology/scala
http://typesafe.com/stack

Scala versus Node.js:
http://stackoverflow.com/questions/15623992/scala-versus-nodejs-as-a-language-framework-for-async-platform-developement
http://blog.appfog.com/node-js-is-taking-over-the-enterprise-whether-you-like-it-or-not/
http://blog.nelsonsilva.eu/2010/12/14/go-vs-scala-vs-nodejs
https://news.ycombinator.com/item?id=3547476
https://groups.google.com/forum/#!topic/nodejs/cBiwwgA61Mg
https://groups.google.com/forum/#!topic/scala-user/oCkhY-0g5g4
http://www.reddit.com/r/node/comments/19agym/nodejs_vs_scala_vs_clojure_what_for_an_api_with_a/
http://grokbase.com/t/gg/scala-user/132v3n28bc/scala-vs-node-js-vs-clojure-what-for-an-api-with-a-we-love-java-we-dont-even-know-why-business-component-in-the-company-x-post-from-nodejs
http://blog.vasilrem.com/nodejs-and-scala-without-mediators
https://groups.google.com/forum/?fromgroups=#!topic/nodejs/cBiwwgA61Mg

Languages:
http://en.wikipedia.org/wiki/Curl_%28programming_language%29
http://en.wikipedia.org/wiki/Lisp_programming_language
http://en.wikipedia.org/wiki/Python_%28programming_language%29
http://en.wikipedia.org/wiki/Incremental_computing

Static code analysis:
http://www.viva64.com/en/t/0046/
https://www.owasp.org/index.php/Static_Code_Analysis
http://searchwindevelopment.techtarget.com/definition/static-analysis
http://www.veracode.com/security/static-code-analysis
http://www.theregister.co.uk/2011/05/14/static_code_analysis_101/
http://www.altdevblogaday.com/2011/12/24/static-code-analysis/
http://stellar.cleanscape.net/programming-solutions/code-analysis/lintfaq/what-is-code-analysis.html
http://msdn.microsoft.com/en-us/magazine/hh335064.aspx

Multi-tenant Database Designs

SPARSQL and Linked Data Structures:
https://github.com/Graphity
http://semanticreports.com/

Logging:
http://netlogger.lbl.gov/
http://docs.splunk.com/Documentation/Splunk/latest/Knowledge/UnderstandandusetheCommonInformationModel
http://www.google.com/search?q=common%20information%20model%20site:splunk.com&ie=utf-8&oe=utf-8

Conferences:
Distributed Management Task Force

References:
http://www.youtube.com/user/GoogleDevelopers
http://www.youtube.com/user/GoogleBusiness
http://www.youtube.com/user/googleanalytics
http://www.youtube.com/user/GoogleECommerce
http://www.youtube.com/user/Google
http://www.youtube.com/user/websiteoptimizer

http://net.tutsplus.com/tutorials/domain-driven-design/

Does Java NIO (non-blocking IO) use event?

When implementing a high performance web server, if a request involve a slow IO operation (perhaps it is making another request to another remote resources), we can create a worker thread, which make the remote request and send the result back to the browser. The current web thread can go back to serving other request. See how Netty is implemented.

What make event-driven programming faster than multi-thread programming? What make Node much faster than PHP or Rails or Java?

Event programming with Java.

If event-driven programming does not use threads, then what make Node (which is event-driven) fast?

GWT

http://www.slideshare.net/johnny_zebra/leanstartupresearch-is-cheaper-than-development
http://robbwolf.com/2011/09/14/framework-matters/
https://twitter.com/robbwolf
http://twitter.com/SPLDebDecisions
http://www.pbell.com/index.cfm/2007/1/24/Bottom-Up-Programming
http://speakrightframework.blogspot.com/2007/12/stringtemplate-template-engine.html
http://speakrightframework.blogspot.com/2007/12/matt-raible-has-fascinating-video.html

ActiveMQ
RabbitMQ
Design Patterns
OOP / OOD
Ruby on Rails
Rule Engines
Decision Support Systems
Business Intelligence
Data Mining
Data Analysis
Data Warehousing
Data Modeling
Big Data
Hadoop
Data Warehousing
Machine Learning
Mobile
NoSQL
HTML5
Security
Oracle
ZooKeeper
NoSQL
Riak
Cassandra
MongoDB
monitoring tools such as Nagios, Scout, Zabbix
automation tools such as puppet, ansible, cuisine, fabric
automation frameworks such as Puppet, Chef
monitoring systems such as Ganglia, Nagios and/or icinga
with chef, cfengine or puppet
automation tools such as puppet, ansible, cuisine, fabric
PHP, Zend, Cake, CodeIgniter, Symfony
Git, Subversion, Perforce
CruiseControl, Apache Ant, Apache Maven, Phing.info
Java, Apache Tomcat, Struts, Hibernate, Doctrine, Spring
Hadoop
PostgreSQL
Sphinx
memcache
Open source SWIG + STAF (Software Testing Automation Framework) staf.sourceforge.net
Google Test Automation Framework
How to type Vietnamese
SAS
jEdit
snagIt
Aspell
Pervasive
NetWaiting
What is executeScripts=false ?
WSO2
OpenStack
HBase
CouchDB
Algorithmic trading
Apply compiler techniques to iterate at blazing speed
Tornado and Twisted framework (Python)
AMQP messaging protocol
Redis distributed KVS
P3P
SVG
XForms
XML-RPC
Xprint
XSL
XSLT
RDF
XUL
XPCOM, XPConnect, XPInstall, XPNet
Web GL
3D CSS
HAProxy
Nginx
Heartbeat
Nagios
Hyperic
Monit
Akamai
Limelight
Panther
Opcode Chef
Puppet
Fabric
Capistrano
CruiseControl
Hudson
ActiveMQ
AMQP
RabbitMQ
JMeter
Grinder
Django
Celery
Mercurial
gunicorn
memcached
Redis
virtualenv +pip
Tomcat
HTA Javascript write file:
Sign script
DVD MP3 converter
Optical Pattern Recognition
Natural Language Processing (NLP)
RDF
RDFS
OWL
SPARQL
GRDDL

Suppose that I need to author a piece of software as a firefox plugin, and this plugin needs to be able to write to a file via javascript. How do I do this?

http://en.wikipedia.org/wiki/Z_notation
http://en.wikipedia.org/wiki/Business_Process_Execution_Language
http://en.wikipedia.org/wiki/Business_Process_Modeling_Notation
http://en.wikipedia.org/wiki/YAWL
JBI (Java Business Integration)
DDS (Data Distribution Service)
VTD-XML
http://en.wikipedia.org/wiki/EMML
http://en.wikipedia.org/wiki/Open_ESB
http://en.wikipedia.org/wiki/Service-oriented_analysis_and_design
http://en.wikipedia.org/wiki/Service-oriented_architecture_implementation_framework

Event Driven Programming versus Multi-threading versus event driven programming combined with multi-threading:
http://www.scss.com.au/family/andrew/pdas/psion/toolbox/tutorial/eventdp/
http://www.progress.com/en/event-driven-programming.html
http://www.progress.com/en/complex-event-processing.html
http://www.progress.com/en/event-driven.html
http://blog.verbum.org/2012/07/28/on-asynchronousevent-driven-programming-and-why-it-lies-at-the-heart-of-gtk-and-thus-gnome/
http://qt-project.org/wiki/Threads_Events_QObjects
http://en.wikipedia.org/wiki/Event-driven_programming
http://c2.com/cgi/wiki?EventDrivenProgramming
http://static.usenix.org/event/hotos05/final_papers/full_papers/cunningham/cunningham_html/
http://berb.github.com/diploma-thesis/original/055_events.html
http://stackoverflow.com/questions/10467087/main-loop-in-event-driven-programming-and-alternatives
http://www.gnu-darwin.org/www001/src/ports/devel/ocaml-equeue/work/equeue-2.1.4/doc/users-guide/html/c494.html
http://stackoverflow.com/questions/10323681/what-is-event-driven-programming

Neural Network / AI / Data Mining / Business Intelligence / Data Visualization:
http://leenissen.dk/fann/wp/
http://www.cs.waikato.ac.nz/ml/weka/
http://cran.r-project.org/web/views/MachineLearning.html
http://www.mathworks.com/products/neural-network/index.html
http://flowingdata.com/2009/09/03/what-visualization-toolsoftware-should-you-use-getting-started/
http://www.r-project.org/
http://www.pypes.org/
http://www.jstatsoft.org/v40/i01
http://plyr.had.co.nz/

MVVM:
http://addyosmani.com/blog/understanding-mvvm-a-guide-for-javascript-developers/
http://msdn.microsoft.com/en-us/magazine/dd419663.aspx
http://en.wikipedia.org/wiki/Model_View_ViewModel
http://msdn.microsoft.com/en-us/library/gg405484%28v=pandp.40%29.aspx
http://msdn.microsoft.com/en-us/library/gg430869%28v=pandp.40%29.aspx
http://mvvmlight.codeplex.com/
http://coderhaven.wordpress.com/2011/01/08/mvvm-smackdown-mvvm-frameworks-mvvmlight-caliburn-jounce-prism/

Data mining / Business Intelligence services:

http://sqlserverpedia.com/blog/sql-server-tutorial/data-mining-the-stackoverflow-database/
http://jtonedm.com/2010/01/13/first-look-data-applied/
http://jtonedm.com/2009/07/13/first-look-clario-analytics/

Tablix:
http://www.reportbuildertutorial.com/tablix/
http://www.tablix.org/articles/about/
http://blogs.msdn.com/b/robertbruckner/archive/2009/03/05/tablix-the-matrix-revolution.aspx
http://technet.microsoft.com/en-us/library/dd220587.aspx
http://msdn.microsoft.com/en-us/library/bb934258%28v=sql.100%29.aspx
http://www.databasejournal.com/features/mssql/article.php/3854031/Introducing-the-Tablix-Data-Region-Basic-Grouping-Concepts.htm
http://www.midnightdba.com/Jen/2012/01/ssrs-tip-hide-a-tablix-if-no-rows-returned/

Thrift:
http://thrift.apache.org/

Java MVC
http://stackoverflow.com/questions/309254/best-java-mvc-framework-implementation-for-web-apps
http://www.inductionframework.org/
http://struts.apache.org/
http://orangeslate.com/2007/11/27/six-best-web-frameworks-in-java/
http://code.google.com/p/java-simple-mvc/
http://code.google.com/p/microservlet/
http://www.springsource.org/
http://www.javaworld.com/javaworld/jw-10-2005/jw-1003-mvc.html
http://www.roseindia.net/struts/mvc-architecture.shtml
http://www.darwinsys.com/jwf/report.pdf
http://www.dzone.com/tutorials/java/struts/struts-tutorial/struts-mvc-architecture-tutorial.html
http://www.dzone.com/tutorials/java/spring/spring-mvc-tutorial-1.html
Scala
Stripes(MVC)
SpringMVC
Glassfish

Hungarian notation
http://en.wikipedia.org/wiki/Hungarian_notation
http://stackoverflow.com/questions/111933/why-shouldnt-i-use-hungarian-notation
http://c2.com/cgi/wiki?HungarianNotation
http://www.joelonsoftware.com/articles/Wrong.html
http://web.mst.edu/~cpp/common/hungarian.html
http://www.learncpp.com/cpp-tutorial/29-hungarian-notation/
http://ootips.org/hungarian-notation.html

Domain Driven Design:

http://www.slideshare.net/yrgo/domain-driven-design-3910831
http://en.wikipedia.org/wiki/Domain-driven_design
http://msdn.microsoft.com/en-us/magazine/dd419654.aspx
http://domaindrivendesign.org/
http://domaindrivendesign.org/resources/what_is_ddd
http://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
http://www.infoq.com/domain-driven-design/
http://codebetter.com/iancooper/2008/06/26/the-criticism-of-the-entity-framework-is-not-just-around-domain-driven-design/
http://blogs.msdn.com/b/marblogging/archive/2011/05/23/domain-drive-design-n-layered-net-4-0-architecture-guide.aspx

Rule Engines:

http://blog.moove-it.com/rules-engine-java-drools-ruby-ruleby/
http://www.slideshare.net/martincabrera/rules-engine-java-rails
http://en.wikipedia.org/wiki/Business_rules_approach
http://www.e-journal-of-pbr.info/downloads/sixviewsonthebusinessrulemanagementsystemresch.pdf
http://en.wikipedia.org/wiki/Semantics_of_Business_Vocabulary_and_Business_Rules
http://en.wikipedia.org/wiki/BRMS
http://www.decisions.com/rule-engine.aspx?utm_campaign=Decisions-Rule-Engine
http://en.wikipedia.org/wiki/Business_rules_engine
http://www.infoq.com/articles/Rule-Engines
http://simpleruleengine.tripod.com/
http://martinfowler.com/bliki/RulesEngine.html
http://www.bizrulesengine.com/index.cfm
http://stackoverflow.com/questions/1596073/what-can-rules-engines-accomplish
http://msdn.microsoft.com/en-us/library/aa561216.aspx
Gathering business rules is also called rules harvesting or business rule mining.
http://www.adempiere.com/Rule_Engine_Implementation
http://www.ibm.com/developerworks/java/library/j-drools/
http://msdn.microsoft.com/en-us/library/aa964135%28v=sql.90%29.aspx
http://social.msdn.microsoft.com/Forums/en-US/biztalkgeneral/thread/b9224567-e2f1-4cf1-8743-cbc75f7a32b2/
http://www.theserverside.com/news/thread.tss?thread_id=28211
http://www.w3.org/2004/12/rules-ws/paper/107/
http://searchsoa.techtarget.com/definition/business-rules-engine-BRE
http://www.businessrulesgroup.org/brmanifesto.htm
http://openrules.com/ruleengine.htm
http://today.java.net/pub/a/today/2005/11/08/implementing-validation-rules-with-aspects.html
http://www.pleus.net/articles/grules/grules.pdf
http://www.bplogix.com/technology/business-rules-engine.aspx
http://www.munichre.com/en/reinsurance/business/health/rule-engine/default.aspx
http://www.infoq.com/articles/business-rules-processes
http://www.cs.cmu.edu/~dg/papers/cmu-cs-09-139.pdf
http://arxiv.org/ftp/cs/papers/9301/9301104.pdf
http://arxiv.org/ftp/cs/papers/0609/0609120.pdf
http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=1715490&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D1715490
http://www.doc.ic.ac.uk/~sgc/teaching/pre2012/v231/lecture4.html
http://bmir.stanford.edu/file_asset/index.php/901/BMIR-1975-0014.pdf
http://silk.semwebcentral.org/talk-silk-warren-lp-symp-2012.pdf
http://www.math-info.univ-paris5.fr/~moraitis/webpapers/Moraitis-JAAMAS05.pdf
http://en.wikipedia.org/wiki/Rete_algorithm
http://www.punksinscience.org/kleanthes/courses/UCY04F/PLA/CLASS_03PC.pdf
http://www.lifl.fr/~djeraba/JournalMTAP.pdf
http://reference.kfupm.edu.sa/content/k/n/knowledge_discovery_in_databases__a_rule_429316.pdf

Decision tables:
http://en.wikipedia.org/wiki/Decision_table
http://sourceforge.net/projects/decisiontablecr/
http://it.toolbox.com/blogs/enterprise-solutions/building-decision-tables-15903
http://pic.dhe.ibm.com/infocenter/rtsohelp/v7r1/index.jsp?topic=%2Fcom.ibm.websphere.ilog.jrules.doc%2FContent%2FBusiness_Rules%2FDocumentation%2F_pubskel%2FRule_Team_Server%2Fps_Rule_Team_Server_OH73.html
http://www.cems.uwe.ac.uk/jharney/table.html
http://www.methodsandtools.com/archive/archive.php?id=39
http://fitnesse.org/FitNesse.UserGuide.SliM.DecisionTable
http://www.debatabledecisions.com/tables
http://docs.oracle.com/cd/E21043_01/integration.1111/e10228/decision.htm

Decision tree:
http://en.wikipedia.org/wiki/Decision_tree
http://en.wikipedia.org/wiki/Decision_tree_learning
http://www.mindtools.com/dectree.html
http://www.public.asu.edu/~kirkwood/DAStuff/decisiontrees/index.html
http://support.sas.com/publishing/pubcat/chaps/57587.pdf
http://thedecisiontree.com/blog/
http://www.investopedia.com/terms/d/decision-tree.asp#axzz28Ivcx2Sc
http://www.cs.cmu.edu/afs/cs.cmu.edu/project/theo-20/www/mlbook/ch3.pdf
http://www-01.ibm.com/software/analytics/spss/products/statistics/decision-trees/
http://research.microsoft.com/pubs/152645/dtf.pdf
http://www.autonlab.org/tutorials/dtree.html
http://code.google.com/p/interactive-decision-tree/
http://en.wikipedia.org/wiki/Decision_tree_model
http://www.lumenaut.com/download/decision_tree_primer_v5.pdf

Rule Engines for Ruby:
Rool
Ruleby
Video presentation on Ruleby
http://www.adaruby.com/2007/12/07/ruleby-the-rule-engine-for-ruby/
Treetop - You can define your DSL as a Parsing Expression Grammar and then parse it to create your rules in whatever format you like.
wongi-engine
Ambition
state_machine
Ruby Rules
http://stackoverflow.com/questions/12162305/ruby-rules-engine

Rule Engines for Java:
http://java-source.net/open-source/rule-engines
http://www.jboss.org/drools/
http://java-source.net/open-source/rule-engines/drools
http://java-source.net/open-source/rule-engines/openrules
http://java-source.net/open-source/rule-engines/mandarax
http://java-source.net/open-source/rule-engines/sweetrules
http://java-source.net/open-source/rule-engines/take
http://java-source.net/open-source/rule-engines/termware
http://java-source.net/open-source/rule-engines/jlisa
http://java-source.net/open-source/rule-engines/jeops-the-java-embedded-object-production-system
http://java-source.net/open-source/rule-engines/prova-language
http://java-source.net/open-source/rule-engines/open-lexicon
http://java-source.net/open-source/rule-engines/zilonis
http://java-source.net/open-source/rule-engines/hammurapi-rules
http://java-source.net/open-source/rule-engines/openl-tablets
http://java-source.net/open-source/rule-engines/dtrules
http://java-source.net/open-source/rule-engines/roolie

Rule Engines for PHP:

Rule Engines for JavaScript:

Rule Engines for .NET:
http://simpleruleengine.tripod.com/
http://msdn.microsoft.com/en-us/library/system.workflow.activities.rules.ruleengine.aspx
http://www.inrule.com/
http://geekswithblogs.net/MarkPearl/archive/2011/12/22/inrule-basics.aspx
http://stackoverflow.com/questions/7296598/net-rules-engines
http://stackoverflow.com/questions/208659/looking-for-simple-rules-engine-library-in-net
http://csharp-source.net/open-source/rule-engines
http://msdn.microsoft.com/en-us/library/aa561216.aspx
http://lostechies.com/chrispatterson/2012/04/11/odoyule-rules-engine-for-net/
http://karlreinsch.com/2010/10/18/wf-rules-unleashing-the-rule-engine-within-dot-net/
http://sourceforge.net/apps/trac/nxbre/wiki
http://rule.codeeffects.com/

Workflow Engines:
http://en.wikipedia.org/wiki/Workflow_patterns

Workflow Engines for JavaScript

Orchestration Engines:

http://en.wikipedia.org/wiki/Orchestration_%28computing%29
http://linkedin.github.com/glu/docs/latest/html/orchestration-engine.html
http://msdn.microsoft.com/en-us/library/aa995577%28v=bts.20%29.aspx
http://msdn.microsoft.com/en-us/library/aa561431%28v=bts.10%29.aspx
http://msdn.microsoft.com/en-us/library/ee268249%28v=bts.10%29.aspx
http://msdn.microsoft.com/en-us/library/aa547090.aspx
http://www.caylx.com.au/products_lo_processorch.html
http://blog.cloupia.com/2011/04/05/cloud-automation-using-cloupia-orchestration-engine/
http://help.sap.com/saphelp_nwmobile71/helpdata/en/7f/c9391404c74fabb8ccc321bac64e8d/content.htm

State machine:

http://www.skorks.com/2011/09/why-developers-never-use-state-machines/

ActiveRecord vs ORM
http://kore-nordmann.de/blog/why_active_record_sucks.html
http://www.mehdi-khalili.com/orm-anti-patterns-part-1-active-record
http://merbist.com/2012/02/23/quick-dive-into-ruby-orm-object-initialization/

ActiveRecord / ORM for JavaScript:
http://www.jazzrecord.org/

MDE / MDA / MDD / UML:

http://code.google.com/p/becontent/
http://en.wikipedia.org/wiki/Model_transformation
http://en.wikipedia.org/wiki/Domain-specific_modeling
http://en.wikipedia.org/wiki/Domain-driven_design
http://en.wikipedia.org/wiki/Framework-specific_modeling_language
http://en.wikipedia.org/wiki/General-purpose_modeling
http://en.wikipedia.org/wiki/Software_factories
http://en.wikipedia.org/wiki/Service-oriented_modeling#Discipline-specific_modeling
http://www.methodsandtools.com/archive/archive.php?id=26
http://en.wikipedia.org/wiki/Domain-specific_multimodeling
http://en.wikipedia.org/wiki/Domain-specific_language
http://en.wikipedia.org/wiki/Model-based_testing
http://en.wikipedia.org/wiki/Software_factory
http://en.wikipedia.org/wiki/Modeling_Maturity_Level
http://en.wikipedia.org/wiki/Service-oriented_Modeling
http://en.wikipedia.org/wiki/Eclipse_Modeling_Framework
i.cmpnet.com/embedded/europe/esesep04/esesep04p36.pdf
http://en.wikipedia.org/wiki/Model-Driven_Architecture
http://msdn.microsoft.com/en-us/library/aa964145.aspx
http://www.theenterprisearchitect.eu/archive/2009/06/25/8-reasons-why-model-driven-development-is-dangerous
http://blogs.msdn.com/b/stuart_kent/archive/2011/04/07/is-model-driven-development-feasible.aspx
http://www.ibm.com/developerworks/library/ar-mdd3/
http://www.redbooks.ibm.com/abstracts/sg247105.html

Model-Driven Engineering (MDE) is a software development methodology which focuses on creating and exploiting domain models (abstract representations of the knowledge and activities that govern a particular application domain), rather than on the computing (or algorithmic) concepts. The MDE approach is meant to increase productivity by maximizing compatibility between systems (via re-use of standardized models), simplifying the process of design (via models of recurring design patterns in the application domain), and promoting communication between individuals and teams working on the system.

MDE is considered effective if its models make sense from the point of view of a user that is familiar with the domain, and if they can serve as a basis for implementation systems.

Model-Driven Architecture (MDA) is an alternative to MDE. MDA is similar to MDE. MDA is an initiative from the Object Management Group (OMG).

The main problem with most MDA / MDE tools: the model gets out of sync with the application.

Model Driven Engineering (MDE) -> Unified Modeling Language (UML)

MDA / MDE Tools:

http://en.wikipedia.org/wiki/Acceleo
http://en.wikipedia.org/wiki/Actifsource
http://www.atomweaver.com/
http://www.cs.ioc.ee/cocovila/
http://www.softfluent.com/products/codefluent-entities (.NET)
http://en.wikipedia.org/wiki/ECO_%28Domain_Driven_Design%29
http://en.wikipedia.org/wiki/Eclipse_Modeling_Framework
http://www.generatexy.org/
http://en.wikipedia.org/wiki/Generic_Eclipse_Modeling_System
http://en.wikipedia.org/wiki/Graphical_Modeling_Framework
http://en.wikipedia.org/wiki/MagicDraw
http://en.wikipedia.org/wiki/ManyDesigns_Portofino
http://en.wikipedia.org/wiki/Telelogic_Rhapsody
http://en.wikipedia.org/wiki/RISE_Editor
http://www.modelingsoft.com/ (.NET)
http://en.wikipedia.org/wiki/Simulink
http://en.wikipedia.org/wiki/Uniface
http://en.wikipedia.org/wiki/Rational_Rose#Second-generation_products

UML:
PHP How to generate code from uml class diagram
First create the UML class diagram so that other people can visualize how the system should work. Generate the stub-code. Implement all the methods.
http://stackoverflow.com/questions/61487/do-you-use-uml-in-agile-development-practices
http://www.stickyminds.com/sitewide.asp?Function=edetail&ObjectType=ART&ObjectId=11861
http://agilescout.com/agile-modeling-and-uml/
http://www.omg.org/mda/presentations.htm
http://www.agilemodeling.com/
http://www.agilemodeling.com/essays/amdd.htm
http://www.agilemodeling.com/essays/bestPractices.htm
http://www.agilemodeling.com/essays/agileArchitecture.htm
http://www.agilemodeling.com/essays/agileRequirements.htm
http://www.agilemodeling.com/essays/agileAnalysis.htm
http://www.agilemodeling.com/essays/agileDesign.htm
http://www.agilemodeling.com/essays/agileDocumentation.htm
http://www.agilemodeling.com/artifacts/
http://www.agilemodeling.com/style/
http://www.agilemodeling.com/faq.htm
http://www.agilemodeling.com/essays/modelingTechniques.htm
http://www.agilemodeling.com/essays/umlDiagrams.htm
http://www.agilemodeling.com/artifacts/classDiagram.htm
http://www.visual-paradigm.com/product/
https://www.ibm.com/developerworks/mydeveloperworks/blogs/ambler/?lang=en

http://stackoverflow.com/questions/393603/php-uml-generator
http://uml.sourceforge.net/index.php
http://pear.php.net/package/PHP_UML/
http://search.cpan.org/~teejay/Autodia-2.14/lib/Autodia.pm
http://directory.fsf.org/wiki/AutoDia
http://tech.motion-twin.com/php_php2xmi.html
http://www.jetbrains.com/phpstorm/whatsnew/
http://www.sparxsystems.com.au/platforms/php_uml.html
http://www.thiagomata.com/codetodiagram/svn/public2/index.php
http://www.bouml.fr/ (Commercial)
http://www.sparxsystems.com.au/products/ea/index.html (Commercial)

UML Tools:

http://staruml.sourceforge.net/en/
http://argouml.tigris.org/
http://www.sparxsystems.com.au/
http://yuml.me/
http://cruise.site.uottawa.ca/umple/
http://modeling-languages.com/uml-tools/#textual
http://www.visual-paradigm.com/product/vpuml/

UML tools for Rails:

http://rubyforge.org/projects/ruby-uml/
https://github.com/preston/railroady#readme
http://blog.nelsonsilva.eu/2009/05/22/create-ror-model-diagrams-with-yumlmerails/
Umlify
http://railroady.prestonlee.com/
http://rubyforge.org/projects/ruby-uml/

http://stackoverflow.com/questions/3705995/a-tool-to-automatically-generate-a-uml-diagram-for-a-rails-application
http://kaibo2.com/typo/articles/2007/03/01/umlrails/
http://www.rubyflow.com/items/4818
http://www.ruby-forum.com/topic/81824
http://blog.eizesus.com/2009/01/uml-for-rails-applications-2/
http://jstorimer.com/ruby/2009/03/24/uml-vs-rails-simplicity.html

WSDL (Web Services Description Language):

http://www.w3.org/TR/wsdl
http://www.w3schools.com/wsdl/default.asp
http://www.w3schools.com/wsdl/wsdl_intro.asp
http://en.wikipedia.org/wiki/Web_Services_Description_Language
http://msdn.microsoft.com/en-us/library/ms996486.aspx
http://oreilly.com/catalog/webservess/chapter/ch06.html
http://www.tutorialspoint.com/wsdl/index.htm

XML Digital Signature:

http://msdn.microsoft.com/en-us/library/ms996502.aspx

SOAP:

http://en.wikipedia.org/wiki/SOAP
http://www.w3.org/TR/soap/
http://ws.apache.org/soap/
http://www.ajaxonomy.com/2008/xml/web-services-part-1-soap-vs-rest
http://www.infoq.com/articles/rest-soap-when-to-use-each
http://www.w3schools.com/soap/default.asp

REST:

http://programmers.stackexchange.com/questions/23386/pros-and-cons-of-restful-architecture
https://forums.aws.amazon.com/message.jspa?messageID=50707
http://en.wikipedia.org/wiki/Representational_state_transfer
http://www.infoq.com/articles/rest-introduction
http://www.xfront.com/REST-Web-Services.html
http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm
http://phpmaster.com/rest-can-you-do-more-than-spell-it-1
http://phpmaster.com/rest-can-you-do-more-than-spell-it-2/
http://phpmaster.com/rest-can-you-do-more-than-spell-it-3/
http://phpmaster.com/rest-can-you-do-more-than-spell-it-4/
http://www.infoq.com/articles/rest-introduction
http://www.xfront.com/REST-Web-Services.html
http://bitworking.org/news/373/An-Introduction-to-REST
http://en.wikipedia.org/wiki/Representational_State_Transfer
http://www.infoq.com/articles/webber-rest-workflow
Architectural Styles and the Design of Network-based Software Architectures
Building Web Services the REST Way
RESTful Rails Development
http://java.dzone.com/articles/restful-development
http://timothyfisher.javadevelopersjournal.com/what_is_restful_development.htm
A Beginner’s Introduction to HTTP and REST
http://www.infoq.com/news/2011/06/RestAPIs
http://www.infoq.com/news/2011/12/graphapi

SOAP vs REST:
http://www.ajaxonomy.com/2008/xml/web-services-part-1-soap-vs-rest
http://ajaxonomy.com/2008/xml/web-services-part-2-wsdl-and-wadl
http://maxivak.com/rest-vs-xml-rpc-vs-soap/
http://javapeople.blogspot.com/2009/05/resr-vs-soap-webservices.html
http://www.itbusinessedge.com/cm/blogs/lawson/the-pros-and-cons-of-web-oriented-architecture-explained/?cs=16197
http://www.infoq.com/articles/RESTSOAFuture/
http://dret.net/netdret/docs/soa-rest-www2009/
http://rest.elkstein.org/2008/02/roa-vs-soa-rest-vs-soap.html
RESTful Web Services vs. Big Web Services: Making the Right Architectural Decision
http://www.infoq.com/articles/rest-anti-patterns
REST for the Rest of Us
SOAP vs REST @IONCANNON
Web Services, Part 1: SOAP vs REST at Ajaxonomy
Giving SOAP a REST by DevX
Roots of REST/SOAP Debate
http://www.theserverside.com/discussions/thread.tss?thread_id=47003
http://www.infoq.com/articles/rest-soap-when-to-use-each
http://www.infoq.com/articles/rest-soap
http://www.infoq.com/news/2011/06/Is-REST-Successful
http://www.infoq.com/articles/RESTSOAFuture/
http://www.infoq.com/news/2008/08/rest-vs-soap-stack
http://www.infoq.com/presentations/SOAP-REST-Christian-Weyer
http://www.infoq.com/presentations/Attacking-Defending-Web-Services
http://www.infoq.com/news/REST-VS-SOAP
http://www.infoq.com/news/2007/12/rest-ws-payback
http://www.infoq.com/news/2011/07/unrest
http://www.infoq.com/bycategory/contentbycategory.action?idx=3&ct=2&alias=SOAP
http://www.infoq.com/rest/
http://www.infoq.com/news/2007/05/is-rest-winning
http://www.infoq.com/presentations/rest-vinoski

SOAP was designed as a transport independence, so essentially you should be able to use it over TCP, MSMQ, etc., REST only deals with HTTP

Microsoft's WCF was designed specifically to make SOAP over any transport medium to be as easy as a value in a config file.

SOAP(using WSDL) is a heavy-weight XML standard that is centered around document passing. The advantage with this is that your requests and responses can be very well structured, and can even use a DTD. The downside is it is XML, and is very verbose. However, this is good if two parties need to have a strict contract(say for inter-bank communication). SOAP also lets you layer things like WS-Security on your documents. SOAP is generally transport-agnostic, meaning you don't necessarily need to use HTTP.

REST is very lightweight, and relies upon the HTTP standard to do it's work. It is great to get a useful web service up and running quickly. If you don't need a strict API definition, this is the way to go. Most web services fall into this category. You can version your API so that updates to the API do not break it for people using old versions(as long as they specify a version). REST essentially requires HTTP, and is format-agnostic(meaning you can use XML, JSON, HTML, whatever).

SOAP is good though if you want computers to understand your webservice using a WSDL.

SOAP was designed for a distributed computing environment where as REST was designed for a point to point environment.

Probably the most cited pro for REST is that it is "light-weight" or tends to be more "human readable". At one level this is certainly true, REST does have a lower barrier to entry - there is less required structure than SOAP (though I agree with those who have said that good tooling is largely the answer here - too bad much of the SOAP tooling is pretty dreadful).

Beyond that initial entry cost however, I think the REST impression comes from a combination of the form of the request URLs and the complexity of the data exchanged by most REST services. REST tends to encourage simpler, more human readable request URLs and the data tends to be more digestable as well. To what extent however are these inherent to REST and to what extent are they merely accidental. The simpler URL structure is a direct result of the architecture - but it could be equally well applied to SOAP based services. The more digestable data is more likely to be a result of the lack of any defined structure. This means you'd better keep your data formats simple or you are going to be in for a lot of work. So here SOAP's additional structure, which should be a benefit is actually enabling sloppy design and that sloppy design then gets used as a dig against the technology.

If I were building a distributed, information processing system I would gravitate to SOAP as the communication mechanism (also because of the tranmission and application protocol layering and flexibility that it affords as has been mentioned above).

REST seems more appropriate. AJAX between the client and its server (regardless of payload) is one major example. I don't have much care for the longevity of this type of connection and ease of use and flexibility are at a premimum. Similarly if I needed quick access to some external service and I didn't think I was going to care about the maintainability of the interaction over time (again I'm assuming this is where REST is going to end up costing me more, one way or another), then I might choose REST just so I could get in and out quickly.

Anyway, they are both viable technologies and depending on what tradeoffs you want to make for a given application they can serve you well (or poorly).

If HTTP is available and applicable, use REST. Otherwise use SOAP.

Miscellaneous:

http://en.wikipedia.org/wiki/Code_golf
http://en.wikipedia.org/wiki/Project_Euler
http://en.wikipedia.org/wiki/Topological_sorting
http://en.wikipedia.org/wiki/Directed_acyclic_graph
http://www.oracle.com/technetwork/java/javase/community/jvmls2012-1840099.html
http://en.wikipedia.org/wiki/Imperative_programming
http://en.wikipedia.org/wiki/Functional_programming
http://stackoverflow.com/questions/602444/what-is-functional-declarative-and-imperative-programming
http://fpcomplete.com/the-downfall-of-imperative-programming/
http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/plbook/imperati.htm
http://the-27th-comrade.appspot.com/blog/ahJzfnRoZS0yN3RoLWNvbXJhZGVyDAsSBUVudHJ5GOFdDA
http://en.wikibooks.org/wiki/Computer_Programming/Imperative_programming
http://en.wikipedia.org/wiki/Logic_programming
http://en.wikipedia.org/wiki/Action_language
http://en.wikipedia.org/wiki/Agent-oriented_programming
http://en.wikipedia.org/wiki/Aspect-oriented_programming
http://en.wikipedia.org/wiki/Automata-based_programming
http://en.wikipedia.org/wiki/Component-based_software_engineering
http://en.wikipedia.org/wiki/Concatenative_programming_language
http://en.wikipedia.org/wiki/Concurrent_computing
http://en.wikipedia.org/wiki/Data-driven_programming
http://en.wikipedia.org/wiki/Declarative_programming
http://en.wikipedia.org/wiki/End-user_development
http://en.wikipedia.org/wiki/Event-driven_programming
http://en.wikipedia.org/wiki/Expression-oriented_programming_language
http://en.wikipedia.org/wiki/Feature_Oriented_Programming
http://en.wikipedia.org/wiki/Function-level_programming
http://en.wikipedia.org/wiki/Generic_programming
http://en.wikipedia.org/wiki/Language-oriented_programming
http://en.wikipedia.org/wiki/Metaprogramming
http://en.wikipedia.org/wiki/Non-structured_programming
http://en.wikipedia.org/wiki/Nondeterministic_programming
http://en.wikipedia.org/wiki/Semantic-oriented_programming
http://en.wikipedia.org/wiki/Structured_programming
http://en.wikipedia.org/wiki/Value-level_programming

http://www.stellman-greene.com/aspm/content/view/22/38/
http://www.stellman-greene.com/aspm/
http://www.stellman-greene.com/aspm/content/view/38/41/
http://www.stellman-greene.com/aspm/content/view/31/41/

Basically, the Vision & Scope tells you very briefly who needs the software, what their needs are, and how you'll meet those needs (by explaining the features of the software you'll be developing).

How to start a software project?

  1. Gather the requirements. This is one of the most important step (along with assembling the team, establishing the communication mechanism). When meeting with the client to gather the requirements, your team should include a business analyst, the technical lead / engineer. The business analyst and the technical lead need to have relevant background in the industry for which the product is being built for. Your team may also include a product manager, a project manager, a QA engineer. The more people you can bring to this meeting the better the outcome will be. Everybody bring their own set of questions from their own perspectives so there would be, in the end, less confusion, and less chance for misunderstanding. The trick is each member of your team need to know when to speak and when not to speak. The business analyst should be the one that do the talking. Perhaps, your team can put together a list of questions before the meeting, write each question down on a piece of paper and pass it to the business analyst, submit the question to the meeting forum, and let the business analyst read the question to everyone. Use online meeting provider such as WebEx to communicate your questions. You should record your meeting if possible. Perhaps you should maintain a list of questions that should be asked every time you start a new project.
  2. Build an online interactive prototype to validate your understanding of the project with the client.
  3. Decide on what tool will be used for project management so that everyone can see the status of the project.
  4. Decide on what tool will be used for source code management
  5. Decide on what tool will be used for Continuous Integration
  6. Decide on what IDE will be used
  7. Decide on the processes, tools, server requirements, licensing
  8. Break it down to smaller features / tasks
  9. For each requirement, design the database and software concepts and components (what layers, concepts, and components do we need? What tables do we need?). Design class diagrams. Design entity-relationship diagrams.
  10. Prioritize the tasks
  11. Design test cases
  12. Implement just enough code to make the test cases pass

A list of questions to ask the client during the "requirement gathering" meeting / phase:

  1. What is the purpose of the software?
  2. What are the required features?
  3. Who will be the users of the software? The client may not be the end-user of the software.
  4. How many users will be using the software at any given time?
  5. How large is the expected user base?
  6. How frequent will each user use the software?
  7. What do the users use the software for? How much load will it put on the system?
  8. What are the user demographic (age, gender, race, religion)
  9. What data do we need to collect?
  10. What are the security requirements?

Project Initiation phase starts when the purpose of a new project is defined. The project sponsor identifies:

  1. Secondary and Primary Goals
  2. Feasibility Study
  3. Risk Assessment. Does this project have any potential negative impact on existing business?
  4. Project Communication Plan
  5. Resources (team members), and how long (how much time) each team member will be available
  6. Milestones and timeline for each milestone
  7. Cost Assessment
  8. Project budget

The first step in developing a project is drafting a project case study which provides its complete business overview. It defines various project-centric problems and addresses some simple and complex project related issues by identifying a project solution to be implemented.

In "Term of Reference", the pragmatic evaluation of goals, objectives, vision, scope and risks take place. It helps further refining the available resources and structural inputs essential for getting project deliverables.

There is a tendency to over analyze requirements when beginning a project. Requirements, however relevant and appropriate at the threshold stages of a project, have to be modified, made more realistic, and refined as the project progresses.

For the requirement process to be effective, it must take into account:

  • The interest of the stakeholder
  • The qualification, competence, availability and behavior of all team members
  • The size of the project, completion time and budget
  • Inherent complexities of the project

The requirement process should comprise of four key factors - total understanding of the project, the step by step project activities, the individual role of all team members, and the communication plan. Everyone on the team should be able to know all the things that are going on with the project.

Brainstorm often: During the initial phases of software growth or even before starting to write a single line of code, you should do several sessions of brain storming. It could be on validating your idea, figuring out competition, predicting the future, picking a programming language, potential learning, etc. Know what you want to build before you build it.

Use good version control system: Even for the most trivial projects, you should try to use version control system.

Document all ideas: When the software is evolving you will have many ideas for new features, doing things differently, or incorporating competing features. Obviously due to lack of resources and time, you won't be able to incorporate all these. But you must document all the ideas, and if possible prioritize them. Keep a single list of ideas. Usually the software will evolve on its own to attract new features. Implement only the most crucial ideas and features, and resist the temptation to add many features.

Include testing and defensive programming: To be successful, sooner or later your software project will need to get out of the demo-mode and face the real world. It might become too late at that time to worry about scalability or glaring bugs if those involve redesigning your software. It saves a lot of time and energy to use common techniques such as good logging, unit testing, performance best practices, and defensive programming from day 1. Also maintain an issue tracker and log even the tiniest of issues with your software. Sooner or later you will need to address them.

Don't wait too long for 1.0 release: In the case of software projects, it is very easy to get started but very difficult to put an end. There is always an endless list of features which needs to be completed before the release, and hence your release never happens. Unless, you make it happen. You will have to make a firm decision about what bugs are important and what can remain as known issues for version 1.0. Implement Minimum Sellable Product.

Be attentive to each team member's needs. We are all human, and we need to socialize, talk to each other. This is what makes our brain grow. All employees are equal (treat them fairly, according to pre-defined order such as how long each have been with the company). Understand them at the personal level, and be supportive of their families' needs as much as possible. Provide an environment that encourage learning, and growth by openly sharing knowledge, cross train, and rotate responsibilities.

A good solution must be fast, easy, and reliable in that specific order. Each of those characteristics is considered ten time more important than the next. That philosophy motivated his team's decisions in almost every area, ranging from visual design to backend engineering.

The thing that people value most is their time. When users encountered flaws in software, they tend to be more forgiving if the software is extremely fast. A crash is less disruptive if the application is quick to restart and offer a quick path back to where the user was.

Speed is especially important because smartphone users tend to have shorter sessions (often less than three minutes long). Users expect applications to deliver relevant information as quickly as possible.

User experience is particularly important. If it takes more than 3 clicks for the user to perform an operation, the users are going to lose patience and easily be drawn away by push notification or other things happening on their phone.

Reliability is also important. Basic robustness and stability are important, but reliability also encompass other ideas like consistency and predictability. Reliable application is one the user can depend on. An application that crash often will annoy the users, and they will probably stop using it.

The API and plug-in architectures are the highest priority. Another way of putting that is: never build anything in-house if you can expose a basic API and get those high-value users (the ones who are getting the most value out of the platform) to build it for you. On the Trello team, any feature that can be provided by a plug-in must be provided by a plug-in. http://www.joelonsoftware.com/items/2012/01/06.html

Best Practices:

http://www.jnd.org/dn.mss/why_is_37signals_so_1.html (very opinionated, need to be careful here)

  • Being a developer does not stop when you leave your desk in the afternoon — it is a life style. Good ideas usually come when you are not working.
  • See the big picture
  • Take your time and do it right
  • Get a life. Your brain need rest.
  • Focus on one thing at a time (without loosing the big picture)
  • Be practical

References:

http://blog.mostof.it/being-a-better-developer/

Object Oriented Programming Considered Harmful
Class Considered Harmful
New Considered Harmful
The Gorilla Banana Problem
http://amzn.to/1WcDcJt
http://amzn.to/1Qs3VOv
https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3
https://medium.com/javascript-scene/a-simple-challenge-to-classical-inheritance-fans-e78c2cf5eead
https://medium.com/javascript-scene/common-misconceptions-about-inheritance-in-javascript-d5d9bab29b0a
https://medium.com/javascript-scene/how-to-fix-the-es6-class-keyword-2d42bb3f4caf
https://medium.com/javascript-scene/introducing-the-stamp-specification-77f8911c2fee
https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3
https://medium.com/javascript-scene/the-two-pillars-of-javascript-pt-2-functional-programming-a63aa53a41a4
https://medium.com/javascript-scene/the-dao-of-immutability-9f91a70c88cd
https://github.com/MostlyAdequate/mostly-adequate-guide
http://haskell.cs.yale.edu/wp-content/uploads/2015/03/HSoM.pdf
https://medium.com/javascript-scene/common-misconceptions-about-inheritance-in-javascript-d5d9bab29b0a
http://davidwalsh.name/javascript-objects
http://chimera.labs.oreilly.com/books/1234000000262/ch03.html#chcsrdou100015eilvj6l9inj
http://pjabook.com/
https://leanpub.com/learn-javascript-react-nodejs-es6/

Class Inheritance: instances inherit from classes (like a blueprint — a 
description of the class), and create sub-class relationships: hierarchical 
class taxonomies. Instances are typically instantiated via constructor 
functions with the `new` keyword. Class inheritance may or may not use the 
`class` keyword from ES6.

Prototypal Inheritance: instances inherit directly from other objects. Instances 
are typically instantiated via factory functions or `Object.create()`. Instances 
may be composed from many different objects, allowing for easy selective 
inheritance.

OOP Pros: It’s easy to understand the basic concept of objects and easy to 
interpret the meaning of method calls. OOP tends to use an imperative style 
rather than a declarative style, which reads like a straight-forward set of 
instructions for the computer to follow.

OOP Cons: OOP Typically depends on shared state. Objects and behaviors are 
typically tacked together on the same entity, which may be accessed at random 
by any number of functions with non-deterministic order, which may lead to 
undesirable behavior such as race conditions.

FP Pros: Using the functional paradigm, programmers avoid any shared state or 
side-effects, which eliminates bugs caused by multiple functions competing for 
the same resources. With features such as the availability of point-free style 
(aka tacit programming), functions tend to be radically simplified and easily 
recomposed for more generally reusable code compared to OOP.

FP also tends to favor declarative and denotational styles, which do not spell 
out step-by-step instructions for operations, but instead concentrate on what 
to do, letting the underlying functions take care of the how. This leaves 
tremendous latitude for refactoring and performance optimization, even allowing 
you to replace entire algorithms with more efficient ones with very little code 
change. (e.g., memoize, or use lazy evaluation in place of eager evaluation.)

Computation that makes use of pure functions is also easy to scale across 
multiple processors, or across distributed computing clusters without fear of 
threading resource conflicts, race conditions, etc…

FP Cons: Over exploitation of FP features such as point-free style and large 
compositions can potentially reduce readability because the resulting code is 
often more abstractly specified, more terse, and less concrete.

FP has a much steeper learning curve than OOP because the broad popularity of 
OOP has allowed the language and learning materials of OOP to become more 
conversational, whereas the language of FP tends to be much more academic and 
formal. FP concepts are frequently written about using idioms and notations 
from lambda calculus, algebras, and category theory, all of which requires a 
prior knowledge foundation in those domains to be understood.

There is more than one type of prototypal inheritance:
1. Delegation (i.e., the prototype chain).
2. Concatenative (i.e. mixins, `Object.assign()`).
3. Functional (Not to be confused with functional programming. A function used 
   to create a closure for private state/encapsulation).

Each type of prototypal inheritance has its own set of use-cases, but all of 
them are equally useful in their ability to enable composition, which creates 
has-a or uses-a or can-do relationships as opposed to the is-a relationship 
created with class inheritance.
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License