Frameworks

I just got an email for a survey about open-source frameworks.  (Examples: Spring Framework, Ruby on Rails, django, CakePHP, Zend, JUCE, etc.)

I guess, to be honest, I hadn't really conceptualized frameworks as an independent category.  Interesting.

Kickstarter for an app builder

Build apps in the cloud, apparently.

Ebook publishing process

Good example of a build framework.

Function grapher play-by-play

Neat blog post series about writing a function grapher, including the parser.

JavaScript goodies

I love this stuff.

• Organic motion in bubbles using various trig functions
• Scrubby lets you adjust numeric constants in code and see the results immediately.  Very fun!

Doom is open source

Open-source target: Doom.

LINQ

So I looked up LINQ, and it turns out it's just a better interface for query manipulation.  Kind of like Data::Table::Lazy.  But it's got drivers for everything in the world.  So it's worth reading about.

Catch the cat

Here's a cute little Flash game that is both surprisingly solvable and surprisingly challenging.  Very bare-bones - you have a grid of circles and click them to keep a cat from escaping the grid.

It would be a good AI target, actually.  I think this may be a case where it would be interesting to explore simple semantic structures of some kind (grouping areas into some kind of cage element or something). I'm not sure.  But it would be interesting to explore.

Learning algorithms in Haskell

Hmm, this makes sense for Haskell, I think - really, anything mathematical makes sense for Haskell.  Note to self: really.  Learn you some Haskell.

Also: this.  I think the time has come.

Journal on Data Semantics

So this is a thing.

Random walk through coding country

Man, there is a lot of stuff out on the wild Internet these days.  Here's a brief trajectory of interesting things.

• Parsing Markdown as an F# kata
• F# snippets have a site of their own
• An F# Reversi kata (returns valid next moves)
• Coding dojo kata list.
• GNU C tutorial: getline.

Parsing C

So I'm taking another stab at writing a quasi-literate-programming tool, which, as I am writing things in C with it, requires a credible C parser to find declarations of stuff.

And while Perl has lots of C parsing tools of varying quantity, including a sample with Parse::Eyapp (which is quite fascinating in its own right), none of them are easily adapted - with the exception of the Inline tools.  Inline::C::ParseRegExp, for example, which does exactly what I want it to - find declarations of stuff.

Python, though, has pycparser.  (And of course, Perl has Inline::Python...)

And then, as always, there is Marpa.  I still have a big fat to-do on my list that says "Learn Marpa".  There's a new set of tutorials on Kegler's blog.  I need to work through those.

Update: I realized I was wrong.  I don't actually need a parser - just a tokenizer for C.  This is because all I need to do is cross-reference all identifiers, and the job is done.

Citation indexing

I can't remember whether I noted this when I saw it first, but: citation networks again.  Oh.  Citation analysis is a tag, so I guess I did.

Comparison of Python Web frameworks by code complexity

I keep meaning to do something meaningful about code complexity analysis, too.

Extremist programming

Here's a good point: programming in extremist languages (everything is X) is a good way to expand your understanding of programming.

Automated proofs and Coq

I ... need more sleep before really understanding what Coq can do, but apparently it's a theorem proving assistant, by which I understand it to be a system that can check your proofs for consistency if you stick to a machine-readable format for describing them.  I guess?

• Certified programming using it (a new book)
• A worked example of a stack machine compiler
• The Fundamental Theorem of Algebra.  No, really.

Code editors again

So somehow I ended up with a bunch of tabs open with code development environment articles.

• IDEs are important to Java because Java has lousy code arrangement - lots of tiny files with framework-induced nomenclature.  So the IDE is a navigational tool.  That squares with my memories of working with Visual Studio back in the day - vast amounts of boilerplate and Studio was really necessary to find the good stuff.
• Textadept is a programming editor written mostly in Lua, that also uses Scintilla as the editor component.  This makes it kinda like Padre (no doubt why it has no Perl tools).
• Zen Coding is ... typing acceleration for HTML and CSS.

I have some pretty decent thoughts about these links, but it's late and the thoughts are rather inchoate.  Short version: every set of code is a text that is written in a formal language in order to express some carefully defined syntactic structures that can be translated into code or actions.  But - and this is again not a new insight - those syntactic structures are a reflection of the deeper semantic structures in the programmer's mind as she comprehends the problem to be solved.

The actual program may or may not solve that problem (hence the need for good testing), but its intent is to do so.  In reading code, we attempt to discover that intent and reconstruct the deep semantics.  What I'd like to do in an IDE and/or editor is to maintain something approximating those semantics in a structure during editing.  As that toolset improves, you could communicate with the editor on a higher level, interacting with the semantics and letting the toolset manipulate the specific code.

Because you don't actually care about the code any more than you care about assembler.  (Unless you care about assembler, but that's a different point.)  You want to solve your problem.

By looking at competitive programming problems and problem statements, I hope I'll be able to have small enough and abstracted enough snippets of semantics that it will be realistic to think about how the semantic comprehension of the problem statement is translated into program structure.

House Republicans gain my respect for twenty hours, blow it

So the House Republicans released an excellent position paper entitled "Three Myths about Copyright Law and Where to Start to Fix It."  Those myths are as follows:

• The purpose of copyright is to compensate the creator of the content
  (It is actually "to promote the progress of science and the useful arts")
• Copyright is free market capitalism at work
  (It actually provides a guaranteed, government-instituted, government-subsidized content monopoly)
• The current copyright regime leads to the greatest innovation and productivity
  This can't be refuted in a sound bite, so read the paper.  It's quite effectively written.

Oh, except you can't read the paper in its original place provided by the United States government, because less than 24 hours after its release, the MIAA and RIAA went ballistic and demanded it be retracted.  And those freedom-loving, Hollywood-support-free Republicans! They just refused!  Oh, no, wait, they did exactly what their corporate masters told them to do - and issued an apology for having mistakenly been too open about how America could benefit, but won't.

If you actually want to know what actual research by the Republican Party came up with about copyright, you'll need to check out one of the mirrors. [here] or [here]  Because today's American government is not there to provide you with research - it's there to protect money.  From you.

Entire Windows API in JavaScript

A Github gist - I don't actually know how you'd use it to access the Win32 API, but it's valuable as data alone.

Programming competitions

OK, so there is such a thing as programming competitions, which I knew.  [Stanford course]  TopCoder is, in fact, structured as a set of programming competitions that lead to a complete product, which is kind of a neat idea, although exploitative of third-worlders if you ask me.  (I'm still going to poke around it for a while - I need to learn Java anyway.)

Anyway, so here's the thing.  All these take fairly clear statements of a problem, add domain knowledge that is fairly restricted, and output code.

If you actually read this blog - in which case, who are you? - I don't even need to finish.  You're already ahead of me.

Here's an online judge, at Peking U.

Penguin Puzzle

This is cute. Also, it's all JavaScript, which is utterly fascinating.  Makes my laptop sound like it's readying for takeoff.

Open source job boards

I'm not at a point right now where I can do freelance work in open-source very effectively, but here are two places to look when the time comes:

• Fossjobs.net
• Fr.lolix.org (why yes, it does help to be multilingual)

I should check for German-language ones, too.

Also: Topcoder.  I'd vaguely heard of it.

Learn visualization!

A recommendation to people new to scientific programming: learn visualization tools, especially fast ones.  The post has some nice specific recommendations, including R.

This is getting to be kind of a common thread lately in what I'm reading.  Ooh, Z has come up with something nice here: MetaSee for metagenomic visualization (open source).

Rewriting Reddit

Thoughts by Aaron Swartz on the occasion of the Reddit rewrite from Lisp to Python using his web.py.  The short version is that Python does have a lot of frameworks [see], but that they all suck, essentially.  He has some interesting things to say about Django, for example.

AI Sandbox

The dudes at Guerilla Games (no, I never heard of them, either) have released AI Sandbox, a neat platform for writing in-game AI, with a contest to write a Capture the Flag captain.

That is the very definition of cool.

I may find the time - somehow - to wedge that into my day this month.

One of the prizes is a free ticket to the Vienna Game/AI conference in 2013, a September event I really wish I'd known about in September!  If we're still here in Budapest next September, I may well go on over and check it out.

Dalton Caldwell on Twitter

Dalton Caldwell always has interesting things to say about the social Internet, and today is no different - he notes that Twitter has appointed MySpace hack Peter Chernin to its Board of Directors and is essentially recapitulating the successful trajectory of MySpace into the social Internet powerhouse that it is today.  Exciting!

They are pivoting from being a service for microblogging - discussion - to being a service for passive media consumption, because that's where the money appears to be.  Facebook is, of course, famously doing the same thing.

So whence the social Internet?  Do network effects inevitably trend towards passive media consumption?  Is that just what humanity really is?

Related articles for this news are all over the map.  BusinessInsider inexplicably thinks it's a good move.  Gigaom gives a little insight into why they think so; his function is to bring street cred on the only street Twitter really needs: Madison Avenue.  The only problem is that Madison Avenue doesn't understand the Internet at all - Madison Avenue is pretty sure the only thing wrong with the Internet is that it's not more like TV, and as soon as we all understand that, the better off the world will be.

But the plot really thickens when we discover that Chernin was the head of NewsCorp - and is credited with the ratings success of FOX News. FOX News - the ratings powerhouse that singlehandedly turned the news media, which Thomas Jefferson correctly identified as crucial to the working of a functional democracy to the extent that he enshrined that necessity in the Constitution itself, into entertainment.  FOX News, which preserved the form of news without the messy, expensive content.

Is that really where the Internet needs to go?

Update: Ouch.

MathBox

Another in-depth article from Steve Wittens, about animation, GL, and JavaScript.

The world moves pretty fast

How to stay relevant in it (Web programmer version). tl;dr: polyglot, change, jack-of-all-trades, keep learning, do it all (or at least understand it all).

Update: here's another similar article.

TermKit

A reinvention of the Unix command line, TermKit wraps commands in a JSON HMI layer, parses commands while you're typing so that the tokens work right without all the quotes and escapes, and does a lot of other neat stuff that we should really be thinking about this century.

I don't particularly love his aesthetic choices, but the overall idea is fantastic.  Unfortunately, he seems to have run aground on development.

I probably ought to look at Haskell

Haskell seems like it's maybe not 100% ready for prime time as a production language through the whole stack [previously], but the Haskell community is looking at some really, really neat stuff.  (Quite aside from factorization diagrams.)

Case in point, and discovered while writing about factorization diagrams: embedded domain-specific languages.  (Like their Workflow module.)

Factorization diagrams

Remember those factorization diagrams in Haskell a couple weeks ago?  These guys animated them, which makes them much, much cooler.

Oh, Zemanta, very nice!  The followup article by the guy who wrote the Haskell article, listing all the zany things the Internet did with them!  Zemanta seems to be pretty liberal about "related articles", and I really don't like how they format related articles if you let them do it for you - but once in a while they find something extremely relevant.

Message-oriented programming

Here's an interesting little insight about program architecture - by breaking things down into little pieces that pass messages back and forth, maybe written in different languages to take advantage of different library availability or even running on different machines, we can concentrate better on doing things right.

Like the Unix philosophy, like the database modeling approach, the more we concentrate on the problem instead of the shape of the code itself, the better off we are.

And then for completely unrelated reasons, I stumbled over message queue systems like 0MQ again.

Zemanta

I'm trying out Zemanta, which sits in your blogging editor and analyzes your text on the fly to suggest possible relevant links and images.

It remains to be seen how useful it'll be, but at it's text analysis, I can't help but be interested.  (And they've got an API!)

So far, the only negative is that I have to use the mouse to pull my sidebar down for tags for my posts.  That's not too horrible.

"Formal"

Defining new languages seems to be a popular hobby these days.  "Formal" is an ML dialect.

Patching machine code

Dear Lord is this geeky.  Fantastic article.

Common machine learning mistakes

Common mistakes applying machine learning to financial modeling - but they're common mistakes made in applying machine learning to anything.  Worth reading.

Unicode for dummies

A fantastic explanatory article about Unicode.

Music player in Python

This is neat!

Python for humans

A nice, if overly Pythonic, presentation about how to structure things better for the coder in complex areas like HTTP retrieval.

Here's the thing. Python's standard HTTP retrieval is a horrible mess because it provides options for every eventuality - and in Python, we all know that There's Only One Right Way.

This is ludicrous.  I see where they're coming from, but it holds them back.  There are always a multitude of Right Ways for something as inherently as complex as HTTP retrieval.  Sometimes you need those nasty callbacks.  And sometimes - arguably, most of the time - you really don't.  Insisting that all use cases always have to be identical is ridiculous.  We don't do that in the real world or in natural language, so why force it further than it should go in a programming language?

This is the sort of thing that should be documented in some kind of literate macro style or something, with wrapper objects or something of that nature.

Paymill

European payment gateway Paymill.

ccv computer vision library

This is just amazingly cool.  For computer vision, the open-source tool of choice is ccv.  The link is a blog post demonstrating tracking of an erratically moving object from frame to frame of a video.  Neat stuff!

Software development and Romney's loss

A couple of good articles about the Romney campaign's snazzy new GOTV tool, Orca, which went down in a blaze of glory, much like the iconic picture of his blimp, but for entirely predictable reasons: insufficient testing, apparently in part because of a misplaced urge to centralization and secrecy, and way insufficient user training, along with some operational foulups (sending out incorrect passwords to users, etc.)  It was a fiasco in every sense of the term.

It was downright corporate.

RethinkDB

A new, presumably rethought, database.  Decentral, and NoSQL.

cat-bounce.com

I give you ... cat-bounce.com.

Trees

I've been taking a lot of my intermediate bloviating offline lately, because I wrote myself a little notes system to organize all the many threads of my life (I'll write about that at some point, but I want to let it mature a little).  So forgive me for not having mentioned that, having finished the minimum viable module for Data::Table::Lazy (an iterator-based in-memory table/matrix module), I have started work on Tree::Walker, which will walk directories and other hierarchical structures and output lazy tables, which in turn will be amenable to processing by an action framework as yet undesigned.

Note that what I've been doing in this thread lately is taking a lot of the components I wanted in Decl, and breaking them out into proper CPAN modules.  Decl will be a little syntactic sugar on top by the time I'm done with that effort - which is exactly right.

So.

Yeah, so I started Tree::Walker.  And rather than just implement the first tree kind of thing that sprang to mind, I decided to examine what others have written about trees.  Which just leads to infinite regress, of course, so here's a short list, in rough order of discovery.

• Tcl has TreeQL, the Tree Query Language.  I honestly don't find it very convincing.
• Here's a much nicer approach, TQL, standing for the same thing.  TQL has a from and a select clause, with a match pattern in the from that can bind variables, and it does a kind of unification thing. Once nodes have been identified, the select clause determines what to return.  I really like this approach.
• ANTLR does tree grammars, but here's an article I found deploring the practice.
• TDL is a Tree Description Language.
• Our old friend TXL also returns to the field [earlier].  If you recall, TXL combines BNF to create a tree with a pattern matcher and action specifier to transform the tree into whatever we like.  It's a nice concept that I thought a lot about during Decl 1.0.
• But right now I was wanting to work with walkers, not transducers.  So yeah, there aren't actually all that many options for a traversal algorithm: here's basically the whole list.  It consists of pre, post, and in.  The "in" option really only makes sense with binary trees.

So that's kind of the stuff I read to get my head back into the tree game.  As a result, I have a little clarity:

• A walker has to specify prefix, postfix, or after-n-fix sorting, or I suppose provide its own traversal function to specify "what to visit next" for a given location (this can be generalized to include a queue, perhaps)
• For each node visited, we end up with a type, a key (name, etc.), and arbitrary data
• For each valid type, we can specify a traversal action, a data return action, and an action action.
• Matching is built on top of traversal.  To match, we are given a multipart key (or a set of them) that matches a vertical series of nodes, and we track the key on the way down the traversal.  If it matches fully, the match's action fires.  These actions can again be actions or data retrieval actions. The driver has to be able to take an arbitrary single-node match pattern and say yea or nay for a given node.
• The whole thing has to go into an iterator.

HNN API

HackerNews has an API.

Rosalind bioinformatics sequence

Rosalind [hnn] is a really neat sequence of bioinformatics problems and a grader (it generates a data file and checks your output - you program it however you like, but you've got five minutes from getting the data to submit your response).

It's got a forum system, badges, the whole nine yards, and a branding thing if you want to use it in your class.

I'm working through the sequence - but it's a good target application, too.  But yeah, bioinformatics is kind of neat!

Intensive Gaston Unit

The Internet scares me sometimes.

Forking data

Heroku has a neat new feature: data forks of PostgreSQL databases.  The advantage: you think less in terms of database servers and more in terms of the data.

That's a good insight.

Nice mathematically based graphics

I give you Ogre's gallery.

Gray code and Kohonen maps

A Gray code is a binary encoding of numbers where neighboring numbers differ by only one bit.  I actually independently invented this in the summer of ... must have been 1995, I guess, reasoning backwards from life events.  I implemented it in Visual Basic as an experimental memory based on Kohonen maps, then lost the code.  Every now and then I try to reconstruct it, but get lost in the Gray code concept - and today I learned it has a name!

Ah, the Internet.  Life is so much better with it.

I really need to reconstruct that research thread.  It was a good one.  The idea was to use a Kohonen map as the index for a semantic space, with semantic units encoded as vectors of keys into the map.  Thus each key self-organizes into a self-describing semantic unit that can be expanded into its components in an organic way in working memory.  Or something.  I really need to reconstruct that.

The Goal is to be Like a Bad Hacker Movie

This post by James Hague is what took me to his site this week.  The idea is quick turnaround, like in hacker movies.  And he's right.  Instant-on programming would be a fantastic thing to have at your fingertips, and sometimes our current tools nearly allow us to achieve it.

But data analysis with quick plots, yeah, that too.

James Hague on Visual Programming

Interesting post.  His blog is full of good stuff, though.  Anyway, the idea: graphical presentation of program structure.

A tcpdump primer

This is neat - tcpdump is a kind of scary tool but essential for networking work.

BonsaiJS

BonsaiJS is a very neat SVG renderer that runs in the browser in JavaScript.

That, my friends, makes Toonbots a whole new ballgame.  I need to revisit the Toon-o-Matic.  Seriously.

core.logic

Relational programming and constraint logic programming for Clojure.  Good links to follow, should I ever get the time to look at this stuff again.

Data science in HFT

Oooh, financial AI, always an interesting topic!  And a great article, too.

Rx: reactive extensions to .NET and JS

So Rx is a reactive extension library that brings reactive programming to the .NET world, built on top of LINQ, which I'd also like to look at - and Microsoft just open sourced it.

• Blog post about this.
• HNN thread.
• The repository.
• Rx koans, also at CodePlex.
• Intro to Rx, an ebook for learning the thing that really looks quite fascinating.

It seems to me that reactive extensions are a natural outgrowth of lazy lists (plus an event subscription model for new additions to the list) and I could profitably bring them to Perl based on Data::Table::Lazy.  Just a thought.

I feel as though I'm recapitulating a lot of the pieces of Decl, only in standalone form.  This feels like a good thing - in the end, Decl will be just syntactic sugar on a lot of powerful tools, which is where it should have been in the first place (I just wasn't finding the tools I wanted).

Data science in the Obama campaign

Time has an interesting article on the Obama campaign's use of data analysis to target their ad dollars (including his appearance on Reddit, of course, which cost him nothing but time).  What I find fascinating is this general trend towards science - data analysis in the campaign, poll analysis by Nate Silver - that is proving itself in the public mind in a much more direct way than the old model of personal genius doing the incomprehensible.

Strange days indeed.

Target application: Bonitasoft

It says "open source" on the site's title - but I see no indication that it actually is.

Anyway, my throat still clenches when I see this stuff.  I still want to finish the wftk, twelve years later.

Interesting big data/textual analysis blog

Another Word For It.  The author is interested in topic maps, an automatic semantic structuring technique for large document collections.

My problem: I have never developed the habit or a toolset for consuming news.  If something bubbles up on HNN, that's historically been enough for me (before HNN, it was just whether I encountered something in other online communities; HNN is a lot more efficient in finding things I like, though).

I need to do something about that.

Update 2012-11-06: And then I find CPAN module "TM" (topic maps) today - freaky!

Datev Mittelstand Compact Pro

Target application.  If Datev can sell this to Germans, there's a reallly big market for small-business accounting software.

QuestionsThree

Target application - QuestionsThree [blog] [hnn] is a nifty gadget that gives you a local phone number that people can call to buzz you into the gate, then texts you that they've done it.  Very neat!

Slick little idea; now the builder is wondering 2. ??? 3. Profit, as one does.

Tower Defense generator

There's not even a Website for this project - I followed links through the wild vastness of the Net to find it.  But - cool!  Generate Tower Defense games using a vocabulary and analytic framework!  I love that kind of stuff.

How to build a Web app from scratch

Boilerplate! [github]

Base components: Coffeescript, jQuery, Underscore, Backbone, Handlebars (template engine), Less, WordPress API for content entry.

Nice overview!

A Django REST framework

APIs and Web frameworks: a Django REST framework.

Generative graphics in JS

Amusing little JS generative landscape; lacks happy clouds.

Django drip

A good real-life, but small, Django application that's open-source and thus ready for understanding, Django drip is for management of email drips.

Hacking language learning

Another interesting way to hack the language learning process.  HNN seems interested in these lately...

UI gallery

Neat!

(A note: the "boilerplate" tag isn't just for boilerplate, but also the bits you plug into the boilerplate, I guess.)

Mining massive time series

Some very interesting aspects of time series similarity.

Infinite Gangnam Style

1. Analyze Gangnam Style to split it into beats
2. For each beat, see the other most-similar beats that follow it
3. Make a big transition network
4. Animate frames from the video to match your beats
5. Put it all on the Web as Infinite Gangnam Style
6. ???
7. Profit!

Very, very cool.

Grepsr

Grepsr appears to be a consulting service slash platform for repeating web scraping.  Pricing appears high.

Study hacks

Another learning-support article, by the guy who worked through an MIT CS BS in one year, outlining how he did it.  The key insight I see is the Feynman technique: for a given idea or method you don't understand, write down a lecture on it (an article) from scratch.  When you get to a point where you're stuck, you've identified what you don't understand.  Study it in more detail.

The idea of the "learning support" thread is really not too germane to this blog (except insofar as it's a natural target for a programming system that purports to be semantically motivated).  It's motivated by two main things, though: first, supporting human performance is what programming is for, and second, understanding human learning is part of understanding semantics.

Version your APIs!

Do what this post says.

Fabric

Wow.  Fabric is a Python module/utility that allows you to turn Unix commands on the local or remote system into building blocks.  This is just so cool.

Tools for coders and developers

Another one of those list articles.  I like them.

Errors vs. Bugs

An extremely thought-provoking thesis, contrasting errors vs. bugs and how the distinction is useful when learning to play piano or, actually, anything at all.

"World countries" database

Here's a neat little idea, a Web service that generates MySQL code to create and load a list of countries according to fresh data.

This could be generalized to another data-dictionary kind of gallery.  Think about that!

Coursera CS curriculum

This is cool.  This kind of curriculum should probably be a thing.

KitBOM

Model this: BOMs for kits.  Neat idea!

Spaghetti? Or just Big?

Here's a thoughtful article about why spaghetti code is harmful (it's too hard to understand all at once) but pointing out that spaghetti is only one way that code can become humanly impossible.  Big Code is the underlying problem: code that has gone beyond some threshold complexity that is maintainable.

It makes you want to get back to work on AI.

On that note, here's a link dump on static code analysis:

• Carmack likes it.
• Microsoft has /analyze in their IDE.
• Clang does it.
• CPPcheck is good for C++, apparently.

What's good about ugly Java

Finally for today's link dump, a thought-provoking article from a guy at Twitter about why Java works so well for enterprise-scale applications: among other things, the many different options for a given object let you tune a massive application to suit your needs.  The result is harder code to understand, but that's because the subject itself is hard to understand.

There are other points in this article, which I need to reread to really get, but I think that this tunability is not a final answer to the question of code beauty.  Lately, I've been thinking in terms of annotations on code, and this is another place where an annotation would be appropriate.

As I'm rapidly prototyping a system, I'd simply instantiate some sort of default object; metadata for this object, however, would indicate that it could be tuned, perhaps by including additional callbacks, perhaps simply by selecting a particular set of tuning values - whatever.  As I needed to further tune my system after learning how it works, I'd annotate that call.  The annotation could be any arbitrary setup code, but here's the key: it would be invisible - a footnote.  Then I could have a reasonable overview version of the code that I could understand on an intuitive basis, without losing the detail that is required for the grungy version, and this, crucially, is why serious books have footnotes.  Seriously!  A straight down-the-list presentation of everything at once isn't conducive to a good understanding of complex ideas in any fields, so why should programming be any different?

Footnotes.  That's what a serious coding system needs.

Functional Reactive Programming

This is really a neat idea that I've mentioned before, but reactive programming is the idea of setting up a network of values (Elm calls these signals - values that change over time) that affect one another dynamically.  This is an inherently declarative style of programming (as the second link there explicitly states).

On that same site, there's an excellent exposition of how to write a Pong game in Elm using this programming style, and a more recent article on how reactive programming avoids the proliferation of callbacks that characterize API-style and more recent non-blocking frameworks like node.js.

Elm itself is a language that compiles to JavaScript on the browser and (I think) on the server as well.  It seems to have some way to integrate with Haskell on the server, but I honestly haven't spent much time investigating it - and I should. I should investigate all the things.

Doxing a Russian hacker

This is a neat procedural.

Deep learning

Interview with one of the winning team of the Kaggle Merck competition - they did it with neural networks, which are back in the news lately.

Webshell

This is pretty neat - a little Web service that allows you to compose other Web services.

API generator

...whatever that is.  Deserves investigation.

Command line tools for developers

More Unix command-line tools - some I never heard of.  I need to do a database for these.

PDF site

I think Planet PDF has essentially everything you want to know about the PDF format.  Here's a sample: PDF stamping.