This page contains notes on programming languages, libraries, protocols, formats, and tools useful for interacting with the internet. I have attempted to ascertain what the top items in each category are -- "top" being some combination of "most popular" and "my favorite". Popularity includes momentum.
This page is basically notes based on rumors, and should not be construed as independent testimony. What I mean by that is that the lists on this page have been formulated just by reading other people's opinions on the web and by looking at demos/screenshots/tutorials -- if i have enough the experience with an item to judge it for myself, it is listed in the favorites section of this website, rather than here.
Blogs
As of March '10.
Wordpress.
CMSs
As of November '10.
In order from lightweight to heavyweight:
- Joomla
- known for a good UI (including more options for configuring the look of your site), but less extensibility
- Drupal
- perhaps the most popular one, although it only has about 25% more google hits than Plone; the most modules
- thought to be better at community
- can apparently integrate with CivicCRM?, SugarCRM?
- mercurial? http://drupal.org/project/hg
- Plone
- requires persistent server process
- has versioning
- has workflows
- although i suppose there are modules in Drupal for this
- can use ContentMirror? to export info into a database (and then mirror the site on GAE, apparently). can also use CMFDeployment or enpraxis.staticsite to export site into static HTML
- generally seems to be better at having central datatypes/information architecture that allows various parts of the site, and various modules, to communicate lists of items, events, etc. it seems like recent versions of Drupal are improving on this, though; Drupal 7 has triggers (events, i think), and rules
- mercurial? http://plone.org/products/raptus.mercurialstorage
- civicrm integration is apparently coming along
Conclusion: it's not apparent to me how to choose between Drupal and Plone. My sense is that Drupal's initial focus was on building sites like Slashdot and Plone's was for building a large corporate website, but i'm not sure what the difference is now. It also seems like Plone put more advanced infrastructure in the core (see outdated http://www.cmsmatrix.org/matrix/cms-matrix comparison between Drupal 6.1 and Plone 3), while Drupal let modules do more stuff at first, though of late it may be slowly pulling stuff into core (e.g. CCK, "content construction kit"). Finally, since Drupal can be installed on the cheapest form of commodity hosting and Plone can't (e.g. you can run Drupal on Dreamhost (you can even run it for free on Dreamhost Apps), but not Plone), and since more people know PHP than Python, i expect that Drupal has more sustainable development momentum (that is, my guess is that plone's arch is better, but it loses momentum b/c it cant be run on the most common type of cheap hosting).
Apparently Alfresco and Nuexo are ok too but for the different purpose of workflow-ish document management:
"
Drupal/Joomla are what you may call 'Web CMS'es or Web Content Management systems. They are meant to be used for deploying web solutions centered around content management, such as web portals, music/photo sharing websites, social networking websites etc.
Alfresco on the other hand is a ECM or Enterprise Content Management software. This relates to file-sharing on the enterprise level, such as file versioning, document management and indexing, online editing and updating documents, check-in/check-out ability for files, applying security and business rules to documentation etc. intra-corporation communication etc. Its functioning can be compared to FileNet?, Sharepoint, Documentum etc. " -- http://www.linkedin.com/answers/technology/enterprise-software/TCH_ENT/480854-18077316
see e.g. http://blogs.nuxeo.com/dev/2005/12/open-source-ecm-now.html , http://brianglass.wordpress.com/2006/03/18/alfresco-plone-and-knowledgetree/ . However it seems that Plone can do workflows, versioning, etc. and plone has many more google hits. Alfresco and Plone seem to claim to do document management and "ECM" as well as "WMS" (web) and "CMS" in general.
Liferay seems to be known for "enterprise portals".
typo3 gets mentioned a lot as well.
Version Control Systems (also known as "Revision Control Systems")
As of March '10.
- Mercurial (hg)
- my favorite
- 2nd in popularity (Git is more popular)
- more elegant and easier to use than Git
- Bzr
- Launchpad uses it
- I've been trying it out on a tiny project, so far it's the same as hg
Wikis
- Oddmuse
- my favorite
- single CGI script; no database required; easy install
- todo: review others
Programming Languages
As of November '08.
I've used Python and Perl extensively, and Haskell a little. I don't know Ruby, Scheme, Arc, Erlang, Self.
- Ruby
- frontrunner in popularity/hotness?
- like Python, but more Perl-y
- elegant
- dynamically typed, object-oriented
- lightweight syntax for anonymous functions; allows a slightly functional programming style
- Python has similar functionality but with more heavyweight syntax that makes it much less usable
- Python
- runner-up?
- like Ruby, but more emphasis on readable code
- some types of metaprogramming disallowed (e.g. source filters) in order ensure that code does what it looks like it does
- elegant
- dynamically typed, object-oriented
- faster than ruby
- Perl
- the old workhouse
- dynamically typed
- Haskell
- interesting language
- very elegant semantics, the syntax seems elegant but for some reason feels more heavyweight than python in actual usage
- learning these elegant semantics takes some time, not because they are complex but because just they are so different from what you are used to
- in haskell, things like global variables and imperative programming are not part of the elegant core of the language, but can be created as constructs; however, because they are constructs, their syntax is not as lightweight as it needs to be. Furthermore, understanding these constructs is difficult (although using them is not as difficult).
- core libraries are not as elegant as they need to be; they need to be refactored
- lacks a core feature of object-oriented programming languages: extensible operations of data types. Extensions exist to get around this, but they are complex and syntactically heavyweight (one of the simplest ways is to go from Figure 6 of http://homepages.cwi.nl/~ralf/gpce06/paper.pdf to figure 7; but look at all the boilerplate which is added. There are extensions to Haskell which do this for you but that adds complexity (even if the extended system is simple to use, you have to learn enough about these extensions to choose which extension to use) and presumably locks you in to the extension that you choose).
- statically typed, purely functional, lazy evaluation
- in my opinion, we need something which is to Haskell as Python/Ruby is to C++. But Haskell is already so elegant, you say. Yes, the core semantics are elegant, but the syntax/semantics needed to do common things like global variables, extensible operations, etc, is insufficiently lightweight/easy to learn, and the libraries are insufficiently elegant. Also, the syntax is lacking some bells and whistles like optionally named (rather than ordered) function arguments.
- (maybe Lisp is already what I seek; I don't know Lisp yet)
- Scheme, Arc
- two Lisp variants thought to be more elegant than other Lisp variants
- well, Arc is new so i should say "intends to be elegant" for that one
- Lisp is extremely elegant; a Lisp compiler can be written in Lisp very concisely
- In Lisp, code can be manipulated like data. Combined with the syntax, which is easily parsed and manipulated programmatically, this makes Lisp the best (afaik) for metaprogramming.
- Erlang
- Self
- said to be one of the smallest/simplest languages
Clearly, the perfect language will have to combine the semantics of Haskell, the convenience of Ruby, the straightforwardness of Python, the parallelness of Erlang, and the metaprogrammability of Lisp. And some logic programming to boot.
From these conjectures we can make some tentative inferences.
The perfect programming language does not have the syntax of Haskell, since afaik Haskell does not lend itself to a small self compiler like Lisp does. It does not have the syntax of Lisp either, since that Lisp is less concise and readable than Haskell.
Since it has the semantics of Haskell, the perfect language will probably compile to Haskell under the hood, provided that an elegant way to map Haskell compiler error messages to error messages in the source language can be found. This leads to the paranoid suspicion that perhaps the perfect language has already been invented in the guise of a Haskell extension, but that I don't know about it because instead of calling it something like "Ruby" and describing it as "a programming language", it may be called something like "Smash along your boilerplate" and described as "a generic programming approach based on a type-level typecase, best understood as a static dual of `Scrap your boilerplate I' (SYB1)."
If, as Paul Graham opines, succintness is the primary goal of language design, then the proof of the perfection of the perfect language will be that, for each of the above languages, an automated compiler will be written that compiles programs in that language into the perfect language. For most real-world programs and libraries, the version of the program in the perfect language will be about as short as in the original language, and often it will be shorter. I opine that straightforwardness/readability are also goals, therefore the version of the program in the perfect language will mostly be about as readable as in the original language; furthermore, often there will exist a version of the program in the perfect language which is more readable than any version in the original language.
Other language goals include its elegance, which has something to do with the number and complexity and orthogonality of its fundamental constructs. Its extensibility. And its ability to discourage the propensity towards "shattering"; that is, when libraries/language variants fork into a zillion incompatible versions (a problem that Lisp is said to have, and that Java and Python are said to try to avoid; although its unclear to me if this is just determined by the extensibility of the language combined with the culture of its community, in which case better language design can't solve it (unless you follow GvR?'s line that purposefully restricting metaprogramming is a feature, not a bug) -- or if, on the other hand, there are other aspects of language design that can fight the propensity to shatter).
Python web programming frameworks
As of November '08.
- Django
- frontrunner
- GvR?'s annointed favorite
- best-supported on Google App Engine (via app-engine-patch)
- monolithic
- Pylons
- runner-up; Django has about 10x as many Google hits
- more decoupled and more pythonic then Django
- since it is smaller than Django, it has less features and many less plugins
- TurboGears? 2 will be built on top of Pylons
See also http://groups.google.com/group/comp.lang.python/browse_thread/thread/a0b81cc2e2b386fa
Python web programming frameworks for Google App Engine
As of March '10
Django and Pylons work, but are maybe not the best choice b/c there is so much GAE-specific stuff that some of the stuff they do for you doesn't work or isn't appropriate or at the least needs to be adapted -- foremost amongst these things: using a BigTable? type thing is so different from using a relational database.
Note that the Django and webapp are the ones bundled with GAE.
Others:
GAE-specific
- webapp (that's the little one built-in to GAE)
- kay (Werkzeug based) (Jinja2) "The basic design of Kay is based on the Django framework, like middleware, settings and pluggable application, etc"
- tipfy (Werkzeug based) (any templating; Jinja2 and mako included) "follows the basic concepts of web.py and webapp"
- "AppEngine Framework"
- gae-mvc-engine "Rails-like" "follows Rails' convention-over-configuration philosophy wherever possible, and tries to import the best time-and-effort saving ideas from both Rails and ASP.NET MVC"
- Pyxer works with Paste, etc (Genshi)
- http://lax.logilab.org/
- http://code.google.com/p/web2py/ (is this GAE-specific?)
- http://github.com/snakajima/gdispatch (webapp plugin: dispatch + GET/POST params as kwargs)
General ones that are thought to work with GAE
Lists
http://code.google.com/p/tipfy/wiki/AppEngineFrameworks
Ruby web programming frameworks
As of November '08.
- Merb
- frontrunner
- said to be "Rails done better"
- Ruby on Rails (RoR?)
- Ramaze
Issue trackers
As of November '08.
- Bugzilla
- my current pick
- said to be hard to install due to using many different Perl modules
- RT
- Mantis
- said to not be quite powerful enough for large, complex projects
- Trac
- issue tracking combined with project planning in a custom wiki
- visually ugly
- Redmine
- said to be "Trac done better". Has a bunch of new features (and leaves out a bunch of old ones). Killer feature is multi-project hosting.
- visually pretty
- A bunch of people use Github combined with Lighthouse (both proprietary, not open source -- but maybe worth being inspired by)
- Eventum
- Used by nearlyfreespeech.net, so it must be good
(free) Open source project hosting
As of November '08.
- SourceForge?
- Not itself open-source
- Most powerful/flexible
- Hosts project websites and allows CGI
- Cluttered, annoying interfaces. Has custom issue tracker, wiki, etc, instead of using best-of-breed.
- Supports a diversity of version control systems
- My current pick
- Google Code
- Not itself open-source
- Doesn't permit GPL Affero-licensed projects
- Clean, simple interface but less powerful
- Forces people to sign-in in order to submit a bug to your project
- Only SVN
- Has wiki but otherwise does not host project websites
- Launchpad
- Open source
- Only Baazar (bzr)
- No project wikis
- I've heard it has a clean, simple interface, but I haven't checked it out much.
- Savaanah
- Is itself open-source (savane)
- Will only accept projects which don't offend the GNU organization -- for example, you can't have the word "open" in your project name, because they like the word "free" instead!
- Supports a diversity of version control systems
- Hosts project websites but no CGI
- Gitorious
- Is itself open-source
- Not full-stack project hosting, just Git hosting
- Only Git
- Github and Lighthouse
- Not themselves open-source
- Only Git
- There are also "only Mercurial" hosts
None of these fulfill my desires. What I'd really like is:
- Itself open-source
- Wikis
- Websites
- Bugzilla (maybe Track or Redmine or Mantis would do? just not Sourceforge's old custom issue tracker -- although maybe their new one will be better)
- Anonymous bug submission possible (at discretion of project)
- Full spectrum of version control systems, including Darcs
- Github-like social features
- CGI hosting desirable but not necessary, if a good wiki and issue tracker are present
- Project planning software like Trac desirable but not necessary
Afaik: No one has Darcs. No one but Github (and maybe Launchpad?) has the social distributed version control stuff. Sourceforge has almost everything, and since it has CGI you can use your own issue tracker, etc, but it is not itself open source. Savannah has almost everything but it doesn't have CGI, so it's much less flexible than Sourceforge, and the need to not offend the GNU is a little scary -- would they allow you to dual-license your code?
In summary, I am currently on Sourceforge and I might move to Savannah sometime.
javascript libraries
jquery
See also [Self-newsAndPredictions-netCodingOld], where I move old stuff to from this page after it is no longer something I'm interested in tracking.