audionerd

I always liked this compact linear calendar format for planning and estimating. I use it often, with weeks on the left, and my list of tasks on the right.

I wrote a command-line app similar to `cal` to generate them in simple plain text: https://npmjs.com/package/calx

`calx 2024` will give you next year’s calendar.

… and load a Pd environment as a DAW plugin with PlugData https://github.com/timothyschoen/PlugData

@thi.ng/ksuid https://github.com/thi-ng/umbrella/tree/develop/packages/ksu...

> the square brackets syntax with the RDF data

Can you give an example?

I picked the current Turtle syntax because it seemed like the least line noise, and hopefully easy for contributors to understand. I would like to learn more about RDF. I don’t know if it was the right choice for this project to be honest though, I might end up switching to JSON.

Many MIDI instruments, effects, and modules released recently transmit MIDI over TRS or TS minijack cables. But, the specs they use vary, and are not always documented.

The more I tried to learn about TRS MIDI, the more confused I got, so I started taking notes with the intent to explain it to others as a reference guide.

I organized what data I could find online about these devices from sources like https://www.muffwiggler.com/forum/viewtopic.php?p=3168946, along with my own research, and put together this web UI (https://minimidi.world) to search it.

I‘m also publishing the data under a public domain license: https://github.com/audionerd/minimidi-data

I’m trying to be thoughtful about respecting users time and privacy with my choices for this microsite, so I'm trying a few experiments:

- one sponsor per month with a single, non-obnoxious banner

- unobtrusive affiliate advertising with simple, helpful links

- no tracking cookies (no google analytics)

- data is open for others to use and improve

Alan Kay coined the term "object-oriented" for software architecture in the late '60’s. He offers a good explanation of it: http://programmers.stackexchange.com/a/58732

“OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.” — Alan Kay

It's easy to assume only languages with Class and Object abstractions are "object-oriented", but the "orientation" is really more about your mental model of the system as differentiated objects that communicate via messages.

Check out "A Technology Freelancer's Guide to Starting a Worker Cooperative" http://techworker.coop/

A few technology worker coops are listed there with brief stories/interviews.

The original Eliss was the first iPhone game I installed. The use of multi-touch was really inspiring - it really took advantage of multi-touch and did so in a creative way, very early on.

I hacked together a little Ruby script to do something similar a few months back, might be useful to somebody:

https://github.com/space150/gifvine/blob/master/gifvine.rb

It runs server-side however, and requires several dependencies (ffmpeg, imagemagick) unlike JVine which runs client-side as a Java applet.

I was impressed by TaskJuggler's extensive data modeling for managing projects and people:

  http://www.taskjuggler.org/

Never used it on a real project, though.

Reminds me of the NYT "Stuffy" app, which was built in a similar way: http://open.blogs.nytimes.com/2010/05/25/building-a-better-s...

Pilbox looks great. Added it to this list of such image resizing services:

  https://github.com/adamdbradley/foresight.js/wiki/Server-Resizing-Images

Many, many implementations, and each goes about it differently. There's unfortunately no widely adopted standard for constructing a URL to request a resized/altered image.

It would be great to see traction on something like this RESTful Image API Specification:

  https://github.com/riapi/riapi

A few more Steve Jobs videos here:

  http://pinterest.com/moorage/ultimate-steve-jobs-collection/

If you're considering the DIY server-side image resize route, here's a good list of options:

  https://github.com/adamdbradley/foresight.js/wiki/Server-Resizing-Images

... and a comparison of benchmarks – ImageMagick vs. competitors like the very fast, low memory VIPS:

  http://www.vips.ecs.soton.ac.uk/index.php?title=Speed_and_Memory_Use

TextEdit has a handy, but often overloooked, use as a basic HTML editor for non-technical contributors.

(see: http://www.musingsfrommars.org/2007/03/using-text-edit-as-ht...)

While researching ways to parse the Web Archive HTML format it outputs, and was surprised to find Apple makes the entire source code for TextEdit available to any developer. Nice!

I like what you did here. It's common for new developers to rely heavily on complicated Lightbox scripts, because it seems daunting to implement one on their own. Your script would be good for a beginner to review. It covers the 80% case. You don't say anything about mobile support or browser support, a note on that might be helpful to add.

I've got to say though, the underscores (while more readable) are not the "house style" for JavaScript (at least, not the native functions of the language), where everyThingIsCamelCase.

Pair with a Guardfile and guard-shell to sync whenever a local file changes –

  https://github.com/guard/guard-shell

This is my weekend hack. It's only a few hours old, but I'm looking for early feedback if anyone's interested.

It's a YAML-powered local editor for static sites (e.g., sites built with the Middleman Ruby library)

My main influence is the excellent PHP content manager "Perch". Eventually, I'd like to bring some of Perch's magic to Ruby/Sinatra sites, and this is my first draft attempting that.

I really like this idea, and it's one I wish I had time to work on myself. I think there's a real need for something like this.

I've come to the conclusion that a project like this would only be successful if contributors are expected to document WHY the code used is written as it is.

Without documentation (an example UI style guide, like the homepage of Twitter Bootstrap) it's difficult to see both the big picture and the purpose of the small details.

Twitter Bootstrap had a great home page right from the start – it served as documentation for the project, as well as a marketing demo influencing you to try it.

So imagine if the contributors to your repo were simply asked to follow a few guidelines, documenting their contributions (say, providing example HTML and using KSS to markup their CSS).

https://github.com/kneath/kss

http://www.alistapart.com/articles/writingainterfacestylegui... http://www.engineyard.com/blog/2011/front-end-maintainabilit...

Maybe ask them to follow a few of the "Object Oriented CSS" principles, so that it's easier to mix and match parts from different folders:

https://github.com/stubbornella/oocss/wiki

Principles of separating the "structure" from the skin"; and separating "container" from "content".

Looks great! Thanks for the tip.

I thought I'd mention, for those who prefer a modern Ruby stack, it is possible to install a JSON REST plugin for Wordpress (like http://wordpress.org/extend/plugins/json-api/) on the back-end, and write your front-end display layer in Ruby.

What happened to Dan Kottke? The Wikipedia article doesn't seem to get into it.

If you can now run automated searches across multiple Dropbox accounts, think what that does for aggregating file storage and sharing.

Imagine how easy it would be to build a multi-user pseudo-P2P file search/share app on top of Dropbox now.

Or imagine when a user can sync/export their settings from a "cloud" service to a SQLite file in their Dropbox automatically.

I wonder if this approach could be used for more "static" sites as well? This sounds great for JavaScript-heavy web apps, but what if there's server-side HTML generation involved?

Speaking of kerning, here's a simple CSS declaration for modern browsers:

    text-rendering: optimizeLegibility;

... which will give you improved handling of kerning pairs and ligatures.

see: http://www.aestheticallyloyal.com/public/optimize-legibility...

How does this differ from http://www.kernjs.com/ ?

I was first introduced to the concept of 'streams' akin to this in SuperCollider, which uses them as building blocks for musical patterns.

http://danielnouri.org/docs/SuperColliderHelp/Streams-Patter...

http://danielnouri.org/docs/SuperColliderHelp/Streams-Patter...

SuperCollider is a fun language to study. You end up with compositional structures like the following (notice 'inf', which indicates an infinite loop)

    Pbind(
      \octave, 4,
      \degree, PstepNadd(
            Pseq([1, 2, 3]), 
            Pseq([0, -2, [1, 3], -5]), 
            Pshuf([1, 0, 3, 0], 2)
          ),
      \dur, PstepNadd(
            Pseq([1, 0, 0, 1], 2),
            Pshuf([1, 1, 2, 1], 2)
        ).loop * (1/8),
      \legato, Pn(Pshuf([0.2, 0.2, 0.2, 0.5, 0.5, 1.6, 1.4], 4), inf),
      \scale, #[0, 1, 3, 4, 5, 7, 8]
    ).play;

Is this just a way to trigger rsync every time a change happens to a given folder?

Looks like this command powers it:

  rsync -rav --stats --log-file=/home/$USER_NAME/.lipsyncd/lipsyncd.log -e "ssh -l $USER_NAME -p $SSH_PORT" --delete $REMOTE_HOST:$LOCAL_DIR $REMOTE_DIR

Couldn't you just toss that in a Guardfile and get the same effect?

  https://github.com/guard/guard/

Or am I oversimplifying it?

I noticed C#/.NET didn't make the list.

Is there a source for that Hemingway quote?

Perhaps he was simply being modest. "UI design, programming, and product strategy" are just the three specific subjects he has felt qualified to "long argue" about.