straws

I think the original comment was talking about the need to scale out application servers to take on additional load. Each application sever still communicates with (usually) the one database.

Normally people talk about that as a way to increase the throughput of requests that your site can respond to, but it has another benefit: more time spent performing data validation, string munging, date checking, etc adds up to less time spent in the database on the same thing.

Stack Overflow may run off of one relational database, but it solves the scaling problem through liberal application-level caching and reverse-proxy caching, all using about a dozen servers that connect to the one database.

Kind of makes you wish he watched a couple more Rich Hickey talks, like any of the ones around Datomic. The solution there is not "stick more business logic in the database", it's "split up the part responsible for writes from the part that queries it".

Reminds me a bit of Twitter's Flight framework with a little more structure around how application lifecycle is managed.

Ah, but what about Official Scrum Master Certification panels?

That was a cute nod to Growing A Language, the one-syllable description.

What are your thoughts then about putting only that region of the page behind some kind of loading/awaiting indication?

My issue with whole-page takeover loaders is that they lose your control and spatial sense of the app. You can't, for example, page away if you decide the report is taking too long to load, or you went to the wrong section of the site when hunting around for a piece of information.

For those uninitiated, this is the Duke Nukem Forever of hypertext:

http://archive.wired.com/wired/archive/3.06/xanadu_pr.html

  Xanadu was meant to be a universal library, a worldwide
  hypertext publishing tool, a system to resolve copyright disputes,
  and a meritocratic forum for discussion and debate. By putting all
  information within reach of all people, Xanadu was meant to
  eliminate scientific ignorance and cure political misunderstandings.
  And, on the very hackerish assumption that global catastrophes 
  are caused by ignorance, stupidity, and communication failures, 
  Xanadu was supposed to save the world.

There's the excellent https://github.com/epantry/django-sql-explorer if you're running a Django app.

This is a great talk in a completely unwatchable format. Here are links to mp4s of the video:

http://stream.hpi.uni-potsdam.de:8080/download/podcast/HPIK_...

http://stream.hpi.uni-potsdam.de:8080/download/podcast/HPIK_...

http://stream.hpi.uni-potsdam.de:8080/download/podcast/HPIK_...

http://stream.hpi.uni-potsdam.de:8080/download/podcast/HPIK_...

A statically typed language enforces an interface, but an interface is just a concept. All it does is ask: does this object respond to the following methods? You and your team can ask that question, or the type checker can.

We'll have effectively created a new breed of super-mice though.

If this kind of "marketing" is truly the thing you overlook when making things, are you making valuable tools that are hard or frustrating to use? What are the parts of your products that have nothing to do with the friction in using them?

You might like Javascript Allonge, a lot

https://leanpub.com/javascript-allonge/read

Jekyll, actually. Doesn't matter.

I'm surprised no one has tried to emulate Quip's editor yet

https://quip.com/

Only ever makes me think of http://blog.mailchimp.com/the-email-person-at-amazon-web-ser...

Well, of course it comes with gotchas:

- if that item is "display: table-cell", it must be within a larger element that's "display: table" or "display: table-row"

- "vertical-align: middle" works also for inline-block elements, but that means it's subject to all the other gotchas present in the article about explicit sizing

It eventually makes a kind of sense, but these rules are passed down in folklore and trial-and-error.

You wouldn't even need to have a separate section — you could get the point across well enough with a simple

  render_template('error.html')

Just here to say: if you have to be using WordPress, use Timber (http://jarednova.github.io/timber/).

Abstracts away what is terrible about querying posts, pages, authors, comments, etc and gives you nice objects with what you'd expect. Uses Twig templates.

That's wordpress. . .

Everyone using jQuery is benefitting from functional programming. Querying, traversing, and filtering are based on `each` and `map`. It turns what was formerly looping and saving values as temporary/instance variables into declarative, collection-based compositions of functions.

Beyond that, Michael Fogus — big in the Clojure + Clojurescript community — has Functional Javascript which explores functional concepts using Underscore: http://www.amazon.com/Functional-JavaScript-Introducing-Prog...

Marijn Haverbeke — a big Lisp hacker and the creator of Codemirror — has a nice chapter in (the free!) Eloquent Javascript as well: http://eloquentjavascript.net/chapter6.html

You should also check out how Javascript supports functional programming in languages that compile to Javascript such as LiveScript or Elm.

http://livescript.net/ http://elm-lang.org/

I think we're mostly in agreement, @dj-wonk. Objects are about bundling that state and behavior, nothing more. How they're created or instantiated is secondary.

It's unnecessary to create classes for functionality when it's unnecessary to create objects for functionality. Here's an eloquent article on that subject:

http://me.veekun.com/blog/2013/03/03/the-controller-pattern-...

Gary Bernhardt has a nice talk about that:

https://www.destroyallsoftware.com/talks/boundaries

A lot of people I know consider object-oriented design orthogonal to the programming style — that the real improvement is moving from a procedural to functional approach. Any system that grows large enough to clearly define an architecture technically is object oriented, so long as it's passing messages among stable interfaces.

You want to have that functional core and imperative shell. Tell above, ask below.

It's just unfortunate that a lot of "object-oriented programming" that you learn in school is really just imperative programming with interfaces ;)

These things have been extremely unsuccessful in the past. . . I remember when they were liquidating these guys for ~$50:

http://www.motorola.com/us/Lapdock%E2%84%A2-for--MOTOROLA-AT...

All I can say about them is they make good raspberry pi docks.

Youtube's strength has never been as a portal, but as infrastructure. They tried feeding video bloggers with video responses (though that feature is going away), there are channels, which were always terrible to navigate, and there is of course the cesspool of comments. Youtube grew huge because it was easy to embed stuff and link to and upload with.

So what's the high barrier to entry that you're talking about? Vimeo has its creative community and Wistia has great embedding tools, but what other sort of niches do you see popping up that steal power users away from Youtube? What sort of business plans even make sense without Google's infrastructure and deep pockets?

Could you speak more about the things you dislike in Liquid? It's one of my favorite templating systems, especially if you're treating it in the same way as you would mustache templates, i.e., using a view-model or decorator to prep data from a model. If you're using a lot of `assign` or `capture` tags, it's horrible.

But also if you do: https://github.com/middleman/middleman-blog

Structured editors are cool. Not everything needs to be org-mode, but I feel like this project could learn from some existing tools:

• Quip's block level editing (https://quip.com/). This avoids the problem where users can't decide whether they should make multiple paragraphs within a block, or if they should make multiple blocks with one paragraph each — Quip makes it so that pressing return puts you into a state where you've created a whole new block-level chunk of information. Whether that's a paragraph or a heading or an image or a table, it doesn't matter because it enforces that the space must mean something. It even prevents you from pressing return multiple times, which would be handled in other wysiwyg editors with multiple <br>s or javascript margins or god knows what else.

• The ability to track and apply revisions a la substance.io (http://substance.io/#substance/manual). Having granular control about both the contents and placement of blocks is very important, especially when considering that a lot of content is edited while being written and revised once published. Substance's extension API is worth checking out too.

That said though, I think you're doing great work, and I'll be watching this project closely. Death to TinyMCE!

Stuff like Wordpress and Ghost exist to have a sharecrop of cheap hosting services with it pre-installed — with Ghost it just looks like JS was the language the developer (a front-end dev on Wordpress. . .) was most familiar with, And That's Fine

Woah, looks like this was made by Steven Lavelle (http://www.increpare.com/) too, who has made a staggering number of bizarre and fascinating indie games over the years. My personal favorite is Mirror Stage, where you navigate patterns in a kaleidoscope:

http://www.increpare.com/2009/03/mirror-stage-done/