montsamu musings

Whew.

2010-06-01T19:54:00.000-04:00

Well, the past couple of months have been mostly family, friends, work, and Bull Spec. But here's something which is just enough that I'd like to note it here:

My story, "The Man in the Mirror", is now up at Fifty-Two Stitches Dark Flash Fiction.

Places to write in RTP: Observation Park at RDU.

2010-04-11T15:00:00.000-04:00

Observation Park at RDU Airport is a pretty nice place to write because:

No WiFi (no distractions)
Large steel birds which should be flightless nonetheless soar and land with grace
Air Traffic Control Chatter on the speakers
There's a bathroom
There are details on small aircraft to read, like flight range, capacity, fuel consumption, etc.

Wow. It's been a while.

2010-04-10T15:44:00.001-04:00

If for some bizarre reason you're here instead of the BULL SPEC blog, head over there for some fun news:

Creative Commons licensed, pay-what-you-like PDF version of BULL SPEC #1 is available.
BULL SPEC #1 is now available at a bunch of stores, the latest of which is the Cary Barnes & Noble.

And some stuff that doesn't really go over there: two video "reviews" (more like previews or surveys or whatever):

The tools for the commons are ready.

2009-12-19T22:00:00.004-05:00

When getting ready to launch BULL SPEC, there were a lot of questions about the tools available to use in producing the e-books and audiobooks. Could I afford top end audio recording software, professional desktop publishing software, vector graphic software, and so on; were the open source versions really ready?

The open source tools are more than ready.

When I first tried using Audacity some years ago, it was not. (At least it didn't play nicely with my Firewire DAW hardware and recording stereo tracks the way that higher-end software did.) Faced with the choice of having used up my month of evaluation of the quite excellent Reaper and either registering or being a jerk to their licensing wishes, I decided to give Audacity another good try. Having just laid down a few test tracks with Audacity 1.3.10 I'm amazed at how far this software has come. I don't come close to pushing the edges of it (I don't use any transforms, plugins, etc. as this is handled mostly in hardware for me) but it handles my narration needs like a champion. And, thanks to recent updates, it even handles my multichannel recording needs (guitar L+R, voice, synth, etc.).

When I started working with the printer for the magazine version of BULL SPEC, they gave me a list of settings for Adobe inDesign. Now, I haven't used desktop publishing since Pagemaker. The original Pagemaker on the original Macintosh. (Shout out to the other editors of the Marion High School student paper!) I told them I'd like to give Scribus a try. They'd never heard of it.

Scribus was a bit rough around the edges in places in past versions, though solidly functional it zigged where inDesign zagged. Lots of things have changed for 1.3.5, and while some of the terminology changes (templates to "Master Pages" for example) make following the tutorial a bit challenging, 1.3.5 is ready for prime time, with the features I needed most and outputting in the format my printer needed. (Bleeds, crop marks, embedded fonts, specific color scheme, etc.)

I've used CamStudio (GPL screen recording software) with great success both in professional and amateur capacities.

Inkscape is an amazing vector graphics tool.

And I have never even used Blender or Gimp yet. Blender is up next. Video interviews and reviews podcasts? Yeah. I'm insane. No way I have time for this.

Holy updates!

2009-12-14T12:15:00.000-05:00

Note the first: the wonderful Thaumatrope is publishing my holiday-themed serial "Bad Elf: A Dark Christmas Serial (Killer)" both on Twitter and the website. This is a whole lot of fun; huge personal thanks to Mr. Lilly for working me through a month of rewrites to get it into a format that both Twitter and I can be happy with, and I hope at least a few people are amused.

Note the second: BULL SPEC #1 is now open for pre-orders. Source code available to the Google App Engine to Paypal ExpressCheckout bridge over at GitHub.

BULL SPEC and the gift economy.

2009-12-08T09:21:00.008-05:00

So, a quick unorganized mini-rant about the gift economy and BULL SPEC:

We have three "exemptions" right now:

We pay advances on content.
We pay for printing and shipping.
Due to #2: While we're "pay what you want" on all e-book and audiobooks, but, since for us physical printing and shipping cost per issue is a floor, on the print version we are "pay what you want above physical printing and shipping cost". All that means is that every word of the content and every stroke behind the artwork is in the gift economy in all forms; but the paper and ink and how it gets to you are not. (Yet.) (And yes, this means, if you're a person or a bookstore, you can buy as many copies as you want at physical cost, period, no questions asked. We'd love a gratuity back the other way but it's not something we're going to harp on or point fingers about. And if you only like one story: we'll make it easy to direct a little something to that author or artist, specifically.)

We'd love to find a printing and distribution partner to alleviate some or all of points #2 and #3. (Hint, hint.) But point #1 is not going anywhere any time soon. Why? Because that's us at BULL SPEC's input into the gift economy, getting the ball rolling, treating people as we'd like to be treated. And we're hoping to see that paid forward with interest over time.

Lastly, a quick word on ads: no, we don't and won't, ever, have paid ads. If there's something which looks like an ad, it's our way of saying "thanks" or "we like these folks" in a small way. And if there's anything ever annoying about these, let us know. We're not marketers or advertisers or marketees or advertisees. We're humans.

And we're still looking for a symbol which means "pay what you want" where a price tag like "$5" goes. (Again: Hint, hint.) For the print issue it would look something like "$2 + SYMBOL." Thanks in advance for any help.

And while we're asking for help: do we really need an ISBN? Sure they're cheap, but when you add the 1000% "handling fee" for the authorized US resellers they are not. We are working with some local (and sympathetic to the gift economy ideals behind what we're doing) bookstores and shops to have BULL SPEC on the racks and will be talking to them about this and/or UPC codes as well, but would love some input from wherever and whomever you are.

edit: And we will be doing "preorders" as soon as we figure out the physical printing and shipping costs. Look for more info about that, when it's ready, at BULL SPEC. And, not to "scoop" and though this is too premature to post as BULL SPEC (hence my little personal blog) it's looking good for launching our first benefit e-books/audiobooks of Joe Meno's "The Architecture of the Moon" by the end of the month. So preemptive happy freakin' New Year to Durham Literacy and our fingers are crossed and re-crossed that we can make a difference in that way.

A story's trip through the Clarkesworld submissions queue.

2009-11-25T21:44:00.004-05:00

On a dream-like "what if?" hope, tempered with "since they are so responsive, at least I'll be able to submit it somewhere else when they reject me, but still: what if?" I finally submitted a ruthlessly-pared-down-from-5000-to-under-4000-words story (the paring down alone took a month to get to a place which made me somewhat happy) to Clarkesworld on Tuesday morning, and found that my story was #27 in the queue. Before leaving for lunch, it was #25, and I already felt the sense of approaching doom. You can actually watch the clock tick down to your story's death; it's an interesting feeling.

Back from lunch, and my story was already #23.

Do not click reload every ten minutes. Do not click reload every ten minutes.

By the end of the afternoon my story was still at #23. What happened to my impending doom?

I tried not to imagine what it would be like to be able to tell my friends, "I can hardly believe it, but Clarkesworld accepted my story! Yes, way!" But it was no use. It's one of those places I've long felt that I would be able to say that I'd written a damned good story if they liked it.

I checked again after dinner; #18. OHMYGOD.

I checked again after putting the kids to bed. #18.

I checked again right before going to bed myself. #18. Had I fallen into an alternate universe? Was that universe trying to tell me something important about #18? Lottery tickets? An address to avoid?

I checked again first thing in the morning: #18. Meanwhile Pseudopod had let me know they weren't interested in a different story. Ah well. I still have those first two acceptances and a few more hopeful stories, right? After seeing the kids off to school I had to check Clarkesworld again: #18.

I managed to avoid checking again for over an hour and a half. Taking a quick break to make some tea at work: #14! OHMYGOD. It's moving again. And it's at the precise midpoint of its ill-fated journey; a rickety roller coaster car having ratcheted its way to the summit of the first hill, awaiting gravity's inevitable and relentless pull. Fare thee well on the leeward side, fair story, and check your safety harness.

Stopping for lunch, I couldn't help taking another peek: #14. On a lark, between bites of leftover pizza, another peek: #13! The free fall has begun. Half an hour later and I saw that my story was at #9. Maybe by tonight? Or maybe by the morning? Do these crazy folks work on Thanksgiving?

In the early afternoon I was called to pick up my daughter, who has developed a fever just in time for Thanksgiving. One last check before heading out the door: #9.

A pre-dinner check: #9. A post-dinner check: #9. Pseudopod already let me know they weren't interested in my next try there, either.

After the kids got to bed? #9. Maybe the news will be the first thing to greet me on Thanksgiving morning? I need to get one of those color-coded info globes hooked up for this. It can start out as Purple, move through Indigo to Blue, onto Green, Yellow, and hold on Orange until finally turning Red at the end. (Just in case, rig up a "Psychedelic" color pattern for the alternative case?)

Before heading up to bed, one last check. (Sure, right. Like I won't check from bed before falling asleep.) #7. Oh boy.

A half hour later, the e-mail arrives:

Dear Samuel,

Thank you for the opportunity to read your story. Unfortunately, your story isn't quite what we're looking for right now. Each month, we receive hundreds of submissions and while I may like many of them, I can only publish twelve of them per year.

In the past, we've provided detailed feedback on our rejections, but I'm afraid that due to time considerations, we're no longer able to offer that service. I appreciate your interest in Clarkesworld Magazine and hope that you'll keep us in mind in the future.

Take care,

Neil Clarke

Ah well. Now I can uncompress the story and undo many of the cuts and slices which helped it sneak (barely) under 4000 words, as nearly every single friend and colleague who has been gracious enough to read the story has demanded; let it breathe a little and stretch back into its frame at about another thousand words or two. Stories don't die, they just find another home, right?

Right?

The Aether Age

2009-11-24T22:00:00.000-05:00

I missed its conception and formulation, but I've been following The Aether Age for about a month or so now, thinking about the guidelines, openly lustful at the thought of putting together a story to be included in it. I love the concept of a concept-based anthology; I love the particular concept picked--Egyptian and Grecian steampunk? Yeah, I'm in; and I love that it's all turning into a ShareAlike licensed work and world to be built upon, remixed, enjoyed the world over.

So I finally took the time to research the setting and idea which had been slowly clawing its way out of my brain and into text, pound out a first draft over a few days, and give it a couple rounds of reading and editing. Pretty happy with it so far, and I hope it strikes a fancy with the editors over there.

There's also a Facebook Group for Aether Age along with the blog. Not much discussion going, but the world is really just getting started.

Well, what do you know.

2009-11-23T22:00:00.000-05:00

Well, it's finally happened. One editor was crazy enough to actually accept one of my stories. "The Man in the Mirror" will appear in the 2010 52-Stitches dark flash fiction anthology. It's very flash at 250 words, but that's about double the size of the first manuscript of the story I submitted to them. Very glad they were interested in a rewrite, and: Score one for the good guys!

Go.

2009-11-19T21:48:00.003-05:00

I'm a sucker for learning languages. So when Google released Go I jumped in and gave it a look. There's some interesting things in there, part C, part Limbo, part amalgam of new and old and new-old old-new. (Pick where GC and CSP go in that mix.)

Now, there are some growing pains; the "core" language packages include a myriad of fairly functional tools: hmac, json, http server and client, etc. Enough for me to spend a day or so putting together a quick Twitter-OAuth web app in Go.

Some warts: the documentation isn't quite there yet in some places, but it's growing; the http client doesn't support https or specifying headers in its public methods; but not big complaints as things are settling in -- those are library issues and they'll get sorted.

On the language itself: my main beefs are that (1) it doesn't support non-nullable types (yet? there's an open discussion on it.) and (2) it's a mix of statements and expressions (if is not an expression; it does not return a value). And again a bit of hard-to-find documentation, spread across a FAQ, a Tutorial, an "Effective Go" page, a Language Design FAQ, a Tech talk, and a "Language Specification" document. Most of the important bits are out there (if you also search through the growing mailing list as well as read the source code) but still some things which are a combination of hard-to-find and hard-to-guess. Like: how interface() and func() really work; how func types work; some of the edges.

Still, a good mental workout to remember how to use a C-like language; static compilation, linking, pointers, structs, etc. I had used Objective-C in the not-too-terribly distant past to put together a couple of iPhone prototype apps, but much of that is Apple's development environment holding your hand; not so much with a pleasant return-to-hacking-in-vi roots as a couple of days with Go. But it's not ready (not surprisingly at day 10 or whatever it is) for my needs, putting together a real website for BULL SPEC, and while it has a few bits which make it perhaps the best of the C-alikes so far, there's too much missing in it which Python, Scheme, OCaml, Haskell, Erlang, or Smalltalk provide that there's enough nits that add up in the core language that while it has been a fun diversion, I'm not sure I'll be spending a lot of time on Go in the near future.

BULL SPEC

2009-11-06T10:54:00.000-05:00

Against probably all better judgement, I've put a stake in the ground and hung a sign on it: BULL SPEC is open for submissions: Welcome to BULL SPEC.

Lessons

2009-09-28T12:29:00.004-04:00

As I ruminated on perhaps learning a lesson about which side projects are appropriate for a software engineer and father of two in a house without a soundproof music room, I realized that I have not properly learned one of the lessons I naïvely thought learned long ago, about getting work done to have in the end more -- and more quality -- time for non-work pursuits.

First, I think that I have come to believe that working on software projects as a side project from work (as a software engineer) are not right for me: (1) By the end of a day at work, particularly in the "crunch time" which has been shifting more and more to "all the time," often the last thing I want to do is sit back at a computer and write and test code, and in the other direction, after working all evening or weekend on my personal programming project my performance at work inevitably suffers; (2) it turns out that I am terrible at web design, and while this might be alleviated by study and practice, see #1, though as a personal development goal I hope to improve in this space through work-study at work; (3) potential IP conflicts with work.

Now, seeing this, what other side projects can I indulge in as an outlet for creative expression? The obvious ones to me are music and writing. Music has been hard to find time and workspace for, as having my equipment out is a disaster waiting to happen with two children under 3, and in any case playing guitar, trumpet, piano, synth, and singing after the kids go to bed is not an option. I'm still hoping to spend much of my December vacation recording new and old music and re-recording some even older songs, but it does not work out as a good fit.

But writing seems to fit. The kids demand stories at all times, so in a sense I'm "writing" all the time, even though half of those stories are "Marco plays soccer/baseball/hockey with his friends" or "Marco goes to the truck/tractor store with his friends." It's even a bedtime story which has uncorked the latest flurry of writing for me, "The Riddle of the Koi," even though yesterday I realized that more than likely that my Tolkien-reared subconscious had produced the "ROTK" initialization of the title. I can write without piles of gear and cords strewn about one or more rooms. I can write while waiting for a dentist appointment, or in an hour and a half of free time while the kids are blessedly napping at roughly the same time, or in the hour and a half after the kids go to bed. I can write! It is like rediscovering a vestigial limb, long forgotten.

Now, the naïveté. I have often thought to myself, proud of my supposed increasing wisdom, that if I had to go back and do college over again, I would actually study and work harder -- in order to in the result have more time for a personal life and personal pursuits, as well as getting the most out of the studies I was there to pursue in the first place. In college, far too often I put off work, put off studying, and in the end this caused me to spend more time and interrupt more personal choices to eventually make up that intellectual debt, and to do so in such a half-assed manner -- just enough to make the grade or pass the test -- that I missed even getting the real, life-long benefit of learning, despite the increased time cost.

But I realize that this is actually a lesson I have not really learned. At work, I too often let distractions sneak their way into my day, causing my work to suffer and slip, leading to work following me home as deadlines grow nearer and nearer, turning an 8 hour work day into 10-12, completely unnecessarily and completely foolishly and wastefully. On that note: to work! So that later, instead of paying the accrued interest of work debt, I can get to that topic which sparked the whole topic: writing the "ninja, pirates, and zombies set in feudal Japan" novelette -- and no, at least I hope not, it is not as trite as that sounds -- that wants its way out of my head: "A team of ninja sent to capture a pirate ship finds more than they bargained for when the corpses of the pirates lurch back to life, as one member of the ninja team's life comes full circle."

Whiteboarding a terribly drawn cartoon

2009-09-16T11:33:00.005-04:00

Well, more than two and a half years since the last post; appropriate the last one was about how being a 'new dad' changes one's perspectives on things.

OK, enough banter.

I finally think I am beginning to "grok" Twitter; I'd avoided it for a long while, and finally I see some fun in it: watching Neil Gaiman, William Gibson, and a few other folks tweet their way through their crazy days is actually fairly interesting, and through those tweets I've been introduced to a few new writers that I've come to like.

But then it gets weird.

I'd been following some good-natured cross-sniping between a few folks, followed a few of them, and, after a particularly interesting (to me) exchange, finally decided that I'd put marker to whiteboard and sketch some of it out in high drama. Very, very, very low art but it's a start; I don't think I've ever actually put a sketch online before, and these may be the first six sketches I've done in over a decade.

Illustration is certainly something I never developed. I like to think I did pretty well on the music side, and passably well on the writing side. But visual art has always escaped me. I doubt I will ever sketch anything worth looking at for more than a second of disgust and distaste, but a 50% improvement will be enough for me, and I actually found the "process" enjoyable. The "process?" Basically: sketch on an 8x10 whiteboard, snap a picture with my (7 year?) old Olympus digital, shrink it to 30% size (using MS Paint no less, if I keep going I'll write a script to do it) and upload to montsamu musings on drunkduck.com.

Unfortunately I have a dozen more drawings in mind for that story alone to reach its conclusion, and already there's another one in mind for the next chapter.

Finger-picking good

2007-02-06T08:52:00.000-05:00

Whew. I haven't played the guitar this much since October. I played until my fingers hurt. Then I played a few more songs. [M]rs. montsamu and baby montsamu were the receptive audience, although both settled in for a nap by the end. I'm getting closer to putting closing the books on a new song called The Sparrow -- a departure from my usual kind of song in that it actually has an expressed meaning, and is intended for children. But I guess that is just one example as to how a new dad's life changes.

Sometimes a sparrow's ignorance
can be confused for divine providence
because sometimes
knowing how far can keep you from taking flight at all.

Erlang: parallel-map and parallel-foreach

2007-02-02T14:53:00.001-05:00

In a post to erlang-questions last summer, Erlang on the niagara, Erlang super-hero Joe Armstrong posts a simple "parallel-map" implementation that he uses in place of some of his simple "iterative-foreach" calls to quickly achieve dramatic speed improvements by taking advantage of multiple processors. The post got me thinking, particularly in light of recent discussions on side-effects and purity, about the real differences and guarantees of such simple things as map and foreach.

Principally, map is (1) supposed to be called with a function with no side effects, (2) guarantees order of return to match the input list, and (3) makes no guarantee on order of function calls, while foreach is (1) used explicitly (and solely) for its side effects as (2) it has no return value (other than the atom ok for success) and (3) guarantees the order of function calls to match the order of the input list. Now, Joe's code was for a parallel-map implementation -- returning a list of results from the application of the given function, no guaranteed order of execution -- when it was actually being used to replace a foreach statement. It happened to work out nicely that his code did not rely on any order of execution promises.

But what if it did? And, anyway, it also made me wonder what cost was entailed with gathering the result list of a (potentially) large number of function calls, when in the end the result needed was only the lack of an error, and the eventual return of control to signify that the operation was complete?

But let's go back. First, let's look at how the standard Erlang lists module implements these two functions:

1> lists:map(fun(I) -> io:format("~w~n",[I]), I+1 end, lists:seq(1,10)).
1
2
3
4
5
6
7
8
9
10
[2,3,4,5,6,7,8,9,10,11]
2> lists:foreach(fun(I) -> io:format("~w~n",[I]) end, lists:seq(1,10)).
1
2
3
4
5
6
7
8
9
10
ok

Exactly as we expected. It just so happened that map made the function calls in the same order as the input list, but this wasn't guaranteed. What do I mean? A glance at the relevant documentation has the following to say about foreach:

This function is used for its side effects and the evaluation order is defined to be the same as the order of the elements in the list.

Contrast this with what it has to say about map:

This function is used to obtain the return values. The evaluation order is implementation dependent.

Fair enough. I put together a little first pass at a plists module (for, obviously, "parallel lists"):

-module(plists).
-export([pmap/2,pforeach/2,npforeach/2]).

pmap(F, L) ->
    S = self(),
    Pids = lists:map(fun(I) -> spawn(fun() -> pmap_f(S, F, I) end) end, L),
    pmap_gather(Pids).

pmap_gather([H|T]) ->
    receive
        {H, Ret} -> [Ret|pmap_gather(T)]
    end;
pmap_gather([]) ->
    [].

pmap_f(Parent, F, I) ->
    Parent ! {self(), (catch F(I))}.

pforeach(F, L) ->
  S = self(),
  Pids = pmap(fun(I) -> spawn(fun() -> pforeach_f(S,F,I) end) end, L),
  pforeach_wait(Pids).

pforeach_wait([H|T]) ->
  receive
    H -> pforeach_wait(T)
  end;
pforeach_wait([]) -> ok.

pforeach_f(Parent, F, I) ->
  _ = (catch F(I)),
  Parent ! self().

npforeach(F, L) ->
  S = self(),
  Pid = spawn(fun() -> npforeach_0(S,F,L) end),
  receive Pid -> ok end.

npforeach_0(Parent,F,L) ->
  S = self(),
  Pids = pmap(fun(I) -> spawn(fun() -> npforeach_f(S,F,I) end) end, L),
  npforeach_wait(S,length(Pids)),
  Parent ! S.

npforeach_wait(_S,0) -> ok;
npforeach_wait(S,N) ->
  receive
    S -> npforeach_wait(S,N-1)
  end.

npforeach_f(Parent, F, I) ->
  _ = (catch F(I)),
  Parent ! Parent.

Some things to notice here are that (1) my pmap is effectively the same as Joe's, but that (2) I've provided a pforeach here that works slightly differently in that it disregards return values instead of gathering them into a list. (Note, however, that like pmap it also disregards order of execution promise and so could not be a drop-in replacement for the iterative foreach.) For now, ignore the npforeach as I'll talk about it later.

Fine, anyway, let's play:

$ erl -smp +S 16 +A 2

Here I start Erlang, enabling the use of multiple processors, setting the internal scheduler to use 16 scheduler threads, and using 2 asynchronous threads.

Erlang (BEAM) emulator version 5.5.2 [source] [smp:16] [async-threads:2] [hipe] [kernel-poll:false]

Eshell V5.5.2  (abort with ^G)
1> c(plists).
{ok,plists}
2> plists:pforeach(fun(I) -> io:format("~w~n", [I]) end, lists:seq(1,10)).
2
3
4
5
6
7
1
8
9
10
ok
3> plists:pforeach(fun(I) -> io:format("~w~n", [I]) end, lists:seq(1,10)).
1
2
3
4
5
7
9
6
10
8
ok

OK! Here we go, we see that, as expected, the order of execution is certainly interleaved -- and not predictably. Let's move on to pmap:

4> plists:pmap(fun(I) -> io:format("~w~n",[I]), I + 1 end, lists:seq(1,20)).
1
3
4
5
6
7
8
10
9
11
12
13
14
15
16
17
18
19
20
2
[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]

Here we see that pmap also doesn't have any guaranteed order of execution (which it shouldn't) and that the return values are in proper order (which it should).

Now. Places to improve? Well, for one we could get all complicated-like and have options for a certain number of worker processes instead of "blindly" spawning a process for each element of a (potentially large!) input list. Another idea is spawning a "spawner" process to actually spawn the worker processes, so that our gathering can begin immediately without waiting for all the worker spawning to end. Yet another is, since we do not need any ordered return value from pforeach find a marginally better way of acknowledging process completion as they occur instead of always waiting for each process in order. (Now you can go back and look at npforeach if you like.) But mostly at that point you're just shuffling deck chairs. Actually just the simple difference between pmap and pforeach is mostly shuffling deck chairs. Certainly it "seems" like pforeach should be faster than pmap -- but lacking a Niagara of my own, mostly I end up testing the limits of my limited CPU and memory slice of my shared VPS server.

But, if anyone does happen to have an interesting amount of hardware lying around:

-module(plists_test).
-export([start/0]).

start() ->
  timer:start(),
  F = fun(I) -> math:pow(I,I) end,
  {T0,L} = timer:tc(lists,seq,[1,1000]),
  io:format("seq took ~w microseconds~n",[T0]),
  {T1,_V2} = timer:tc(plists,pmap,[F,L]),
  io:format("pmap took ~w microseconds~n",[T1]),
  {T2,_V1} = timer:tc(plists,pforeach,[F,L]),
  io:format("pforeach took ~w microseconds~n",[T2]),
  {T3,_V1} = timer:tc(plists,npforeach,[F,L]),
  io:format("npforeach took ~w microseconds~n",[T3]),
  ok.

And give it a twirl:

$ erl -smp +S 16 +A 2 -s plists_test -run init stop -noshell
seq took 109 microseconds
pmap took 90465 microseconds
pforeach took 104702 microseconds
npforeach took 112472 microseconds

As the input list gets larger, that "queue of processes instead of trying to spawn a process for each element of the list blindly" idea starts to look a whole lot better -- what good is spawning 10000 CPU-bound processes when you only a fraction of that in available CPU cores?

Erlang fizzbuzzery: Project Euler Problem 1

2007-01-30T14:14:00.001-05:00

Another excercise in solving a simple problem using multiple programming idioms in the same language, Erlang. This time the simple problem is Problem 1 from Project Euler: "If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000." In particular, the solutions presented are (1) a simple single-function loop which uses if to check for termination and matching numbers, (2) a simple loop using Erlang's guard syntax, and (3) a few solutions using some of the functions of the lists module, one using Erlang's list comprehension syntax.

Simple loop without guards:

-module(euler_1_loop).

-export([start/0,solve_euler_1/1]).

start() -> io:format("~w~n",[solve_euler_1(1000)]).

solve_euler_1(N) -> solve_euler_1(0,1,N).

solve_euler_1(Sum,Cur,N) ->
  if Cur >= N -> Sum;
     (0 == (Cur rem 3)) or (0 == (Cur rem 5)) -> solve_euler_1(Sum+Cur,Cur+1,N);
     true -> solve_euler_1(Sum,Cur+1,N)
  end.

The above does a few things right, such as remembering that all calls in Erlang are call by value and thus the easiest way to implement a recursive loop for this little problem is by simply keeping all the relevant data around as function parameters. It uses Erlang's if to test a series of expressions. As before, the simple module is constructed so that its main path, solve_euler_1/1, is exported so it can be externally tested, and the simple start function is exported so we can simply run the example (after compiling with erlc, of course) with:

erl -s euler_1_loop -run init stop -noshell

We can use Erlang's guard syntax to transform the above code into:

-module(euler_1_guards).

-export([start/0,solve_euler_1/1]).

start() -> io:format("~w~n",[solve_euler_1(1000)]).

solve_euler_1(N) -> solve_euler_1(0,1,N).

solve_euler_1(Sum,Cur,N) when Cur >= N -> Sum;
solve_euler_1(Sum,Cur,N) when (0 == (Cur rem 3)) or (0 == (Cur rem 5)) -> solve_euler_1(Sum+Cur,Cur+1,N);
solve_euler_1(Sum,Cur,N) -> solve_euler_1(Sum,Cur+1,N).

The above is a fairly simplistic example, but after all the problem is itself fairly simplistic. The first match for solve_euler_1/3 checks the end case, for when we have reached the end of the list of numbers we are supposed to be adding, and simply returns our running total. The second match checks to see if the current number is evenly divisible by 3 or 5, and if so, adds the current number to the running total, adds one to the current number, and re-enters the loop, keeping in mind that the matching process will start over again and so the end case will be handled appropriately. The last match simply leaves the running total alone, adds one to the current number, and re-enters the loop.

Using the lists module and Erlang's list comprehension syntax:

-module(euler_1_comprehension).

-export([start/0,solve_euler_1/1]).

start() -> io:format("~w~n",[solve_euler_1(1000)]).

solve_euler_1(N) -> lists:sum([X || X <- lists:seq(1,N-1), (X rem 3 == 0) or (X rem 5 == 0)]).

The above illustrates four important concepts:

lists:sum(List) which returns the sum of each element in a list;

lists:seq(Start,End) which returns a list of numbers from Start through End;

[X || X <- List] which is a simple list comprehension syntax example that actually produces the exact same input List (unlike [math:pow(X,2) || X <- List] which produces a list of the squares of the elements in the input List, or [{n,X} || X <- List] which produces a list of tuples where the first element is the atom 'n' and the second element is the original list element, or [{X,math:pow(X,2)} || X <- List], or...);

[X || X <- List, Expression] which filters the original List by only including those elements for which the given Expression is true, in this case, (X rem 3 == 0) or (X rem 5 == 0).

Similar to the above is using the lists module's filter function:

-module(euler_1_filter).

-export([start/0,solve_euler_1/1]).

start() -> io:format("~w~n",[solve_euler_1(1000)]).

solve_euler_1(N) -> lists:sum(lists:filter(fun(X) -> (X rem 3 == 0) or (X rem 5 == 0) end,lists:seq(1,N-1))).

This introduces the filter function itself, as well as the creation of an anonymous function in Erlang.

Yet another method of solving this problem comes again from the lists module, this time using foldl to accumulate along the list, and showing that anywhere you might declare an anonymous function (such as above) you can also use named functions:

-module(euler_1_foldl).

-export([start/0,solve_euler_1/1]).

start() -> io:format("~w~n",[solve_euler_1(1000)]).

solve_euler_1(N) -> lists:foldl(fun accum_fun/2,0,lists:seq(1,N-1)).

accum_fun(X,Sum) when X rem 3 == 0; X rem 5 == 0 -> X + Sum;
accum_fun(_X,Sum) -> Sum.

Here we have a couple of new things to see, of course the foldl function itself, but also we use a named function, accum_fun, where previously we had declared an anonymous function inline, and we used a special guard syntax where ; is really quite the same as or.

Hopefully this was at least a little helpful in illustrating a few ways that using some of Erlang's features can be fun, simple, fast, and clear. This example didn't really give us an opportunity to look at processes or matching, but I'm sure those will come along again soon enough.

Erlang fizzbuzzery

2007-01-25T09:49:00.001-05:00

Herein, a few different ways of implementing "a" solution to the FizzBuzz problem, showing examples of some different programming styles in Erlang solving the same problem.

Using a loop:

-module(fizzbuzz_with_loop).

-export([start/0]).

start() ->
  fizzbuzz(1,100).

fizzbuzz(N,M) when N > M -> noop;
fizzbuzz(N,M) ->
  io:format("~s~n",[fizzbuzz(N)]),
  fizzbuzz(N+1,M).

fizzbuzz(N) when N rem 3 == 0, N rem 5 == 0 -> "FizzBuzz";
fizzbuzz(N) when N rem 3 == 0 -> "Fizz";
fizzbuzz(N) when N rem 5 == 0 -> "Buzz";
fizzbuzz(N) -> integer_to_list(N).

Compile the module with erlc fizzbuzz_loop.erl and run with erl -s fizzbuzz_loop -run init stop -noshell [1] to produce:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
...

Using foreach (foreach is used because the order of evaluation is important):

-module(fizzbuzz_with_foreach).

-export([start/0]).

start() ->
  lists:foreach(fun(X) -> io:format("~s~n",[fizzbuzz(X)]) end, lists:seq(1,100)).

fizzbuzz(N) when N rem 3 == 0, N rem 5 == 0 -> "FizzBuzz";
fizzbuzz(N) when N rem 3 == 0 -> "Fizz";
fizzbuzz(N) when N rem 5 == 0 -> "Buzz";
fizzbuzz(N) -> integer_to_list(N).

Using list comprehension:

-module(fizzbuzz_with_list_comprehension).

-export([start/0]).

start() ->
  lists:foreach(fun(Y) -> io:format("~s~n",[Y]) end, [fizzbuzz(X) || X <- lists:seq(1,100)]).

fizzbuzz(N) when N rem 3 == 0, N rem 5 == 0 -> "FizzBuzz";
fizzbuzz(N) when N rem 3 == 0 -> "Fizz";
fizzbuzz(N) when N rem 5 == 0 -> "Buzz";
fizzbuzz(N) -> integer_to_list(N).

Using processes:

-module(fizzbuzz_with_processes).

% export default start function for command line
-export([start/0]).

% export entry point for spawned processes
-export([fizzbuzz_process/0]).

start() ->
  Fizz_PID = spawn(fizzbuzz_with_processes,fizzbuzz_process,[]),
  lists:foreach(fun(X) -> ask_fizzbuzz(Fizz_PID,X) end, lists:seq(1,100)),
  Fizz_PID ! {done}.

ask_fizzbuzz(Fizz_PID,N) ->
  Fizz_PID ! {fizzbuzz,N,self()},
  receive {Answer} -> io:format("~s~n",[Answer]) end.

fizzbuzz_process() ->
  receive
    {fizzbuzz,N,Caller_PID} -> Caller_PID ! {fizzbuzz(N)}, fizzbuzz_process();
    {done} -> noop end.

fizzbuzz(N) when N rem 3 == 0, N rem 5 == 0 -> "FizzBuzz";
fizzbuzz(N) when N rem 3 == 0 -> "Fizz";
fizzbuzz(N) when N rem 5 == 0 -> "Buzz";
fizzbuzz(N) -> integer_to_list(N).

With too many processes:

-module(fizzbuzz_with_too_many_processes).

% export default start function for command line
-export([start/0]).

% export entry point for spawned processes
-export([fizzbuzz_fizzer/1]).
-export([fizzbuzz_buzzer/1]).
-export([fizzbuzz_number/1]).
-export([fizzbuzz_printer/0]).

start() ->
  Printer = spawn(fizzbuzz_with_too_many_processes, fizzbuzz_printer, []),
  Processes = lists:map(fun(F) -> spawn(fizzbuzz_with_too_many_processes, F, [Printer]) end, [fizzbuzz_fizzer,fizzbuzz_buzzer,fizzbuzz_number]),
  lists:foreach(fun(X) -> lists:foreach(fun(P) -> P ! {n,X,self()}, receive {ok} -> noop end end, Processes), Printer ! {newline} end, lists:seq(1,100)),
  lists:foreach(fun(P) -> P ! {done} end, [Printer|Processes]).

fizzbuzz_fizzer(Printer) ->
  receive
    {n,N,P} ->
      if N rem 3 == 0 -> Printer ! {s,"Fizz"};
         true -> noop
      end,
      P ! {ok},
      fizzbuzz_fizzer(Printer);
    {done} -> noop end.

fizzbuzz_buzzer(Printer) ->
  receive
    {n,N,P} ->
      if N rem 5 == 0 -> Printer ! {s,"Buzz"};
         true -> noop
      end,
      P ! {ok},
      fizzbuzz_buzzer(Printer);
    {done} -> noop end.

fizzbuzz_number(Printer) ->
  receive
    {n,N,P} ->
      if (N rem 5 =/= 0) and (N rem 3 =/= 0) -> Printer ! {n,N};
         true -> noop
      end,
      P ! {ok},
      fizzbuzz_number(Printer);
    {done} -> noop end.

fizzbuzz_printer() ->
  receive
    {s,S} -> io:format("~s",[S]), fizzbuzz_printer();
    {n,N} -> io:format("~w",[N]), fizzbuzz_printer();
    {newline} -> io:format("~n",[]), fizzbuzz_printer();
    {done} -> noop end.

Why is the above so painful? Mostly because we have to wait for a reply from each fizzbuzz_X process because otherwise some of the processes will send messages to the printer out of order. To compare, see what the output is if you did not wait for an {ok}:

-module(fizzbuzz_with_asynch_processes).

% export default start function for command line
-export([start/0]).

% export entry point for spawned processes
-export([fizzbuzz_fizzer/1]).
-export([fizzbuzz_buzzer/1]).
-export([fizzbuzz_number/1]).
-export([fizzbuzz_printer/0]).

start() ->
  Printer = spawn(fizzbuzz_with_asynch_processes, fizzbuzz_printer, []),
  Processes = lists:map(fun(P) -> spawn(fizzbuzz_with_asynch_processes, P, [Printer]) end, [fizzbuzz_fizzer,fizzbuzz_buzzer,fizzbuzz_number]),
  lists:foreach(fun(N) -> lists:foreach(fun(P) -> P ! {n,N} end, Processes), Printer ! {newline} end, lists:seq(1,100)),
  lists:foreach(fun(P) -> P ! {done} end, [Printer|Processes]).

fizzbuzz_fizzer(Printer) ->
  receive
    {n,N} ->
      if N rem 3 == 0 -> Printer ! {s,"Fizz"};
         true -> noop
      end,
      fizzbuzz_fizzer(Printer);
    {done} -> noop end.

fizzbuzz_buzzer(Printer) ->
  receive
    {n,N} ->
      if N rem 5 == 0 -> Printer ! {s,"Buzz"};
         true -> noop
      end,
      fizzbuzz_buzzer(Printer);
    {done} -> noop end.

fizzbuzz_number(Printer) ->
  receive
    {n,N} when N rem 5 =/= 0, N rem 3 =/= 0 -> Printer ! {n,N}, fizzbuzz_number(Printer);
    {n,_N} -> fizzbuzz_number(Printer);
    {done} -> noop end.

fizzbuzz_printer() ->
  receive
    {s,S} -> io:format("~s",[S]), fizzbuzz_printer();
    {n,N} -> io:format("~w",[N]), fizzbuzz_printer();
    {newline} -> io:format("~n",[]), fizzbuzz_printer();
    {done} -> noop end.

The output of this last program is consistently interleaved. Moral of the story: just because you send a message to each of a set of processes in a particular order, it does not mean that each message will be received or more importantly acted upon in that particular order. Messages to a process are queued in order, but if you send a message M1 to process P1 and another message M2 to process P2, there is no guarantee that process P1 will receive the message before process P2. There is a guarantee that if you send message M1 to process P1 and another message M2 to the same process P1, M1 will be received before M2. But this is a crucial difference.

Lastly, an implementation that works, consisting of far too many processes:

-module(fizzbuzz_with_far_too_many_processes).

-export([start/0]).
-export([fizzbuzz/2]).

start() ->
  % spawn 100 processes to compute the 100 terms
  lists:map(fun(N) -> spawn(fizzbuzz_with_far_too_many_processes,fizzbuzz,[N,self()]) end, lists:seq(1,100)),
  lists:foreach(fun(T) -> io:format("~s~n",[element(2,T)]) end, [I || I <- receive_all(100)]).

receive_all(M) -> receive_all(M,[]).

receive_all(M,L) when M == length(L) -> lists:sort(L);
receive_all(M,L) ->
  receive
    {N,S} -> receive_all(M,[{N,S}|L])
  end.

fizzbuzz(N,P) when N rem 3 == 0, N rem 5 == 0 -> P ! {N,"FizzBuzz"};
fizzbuzz(N,P) when N rem 3 == 0 -> P ! {N,"Fizz"};
fizzbuzz(N,P) when N rem 5 == 0 -> P ! {N,"Buzz"};
fizzbuzz(N,P) -> P ! {N,integer_to_list(N)}.

A key thing to learn from this last listing is that erlang tuples are indexed starting at 1. But that is a gripe for another blog entry.

Notes:
[1] add -smp to the execution of the program to enable Erlang's use of multiple processors.

Erlang example: "parallel primes"

2007-01-23T16:39:00.001-05:00

The code for this example is fairly simplistic and does many things wrong. Nevertheless it does provide some examples of several Erlang constructs. Hopefully this little example is self-explanatory enough to be useful on its own for now, but I hope to now add some commentary as to its construction and flaws. First, it is obviously by far not a good way to generate a list of primes. The point is not to generate primes well, but to demonstrate, using a fairly easy-to-understand problem domain, how one might write a simple program that (1) spawns a set of worker processes to operate upon work items from a queue, (2) accumulate results from their work in an accumulation process, and (3) retrieve those results.

% pprimes.erl
-module(pprimes).

% functions that will be called from command-line must be exported
-export([start/1]).

% functions that will be spawned must be exported
-export([prime/3]).
-export([queue/3]).
-export([accum/1]).

% functions that could be externally testable could be exported
-export([is_prime/1]).
-export([atom_to_integer/1]).
-export([pprimes/2]).

% called from command-line with atoms, e.g. ['10','1000']
start([NProcessesAtom,PLimitAtom]) ->
  NProcesses = atom_to_integer(NProcessesAtom),
  PLimit = atom_to_integer(PLimitAtom),
  T1 = erlang:now(),
  L = pprimes(NProcesses,PLimit),
  T2 = erlang:now(),
  T = timer:now_diff(T2,T1),
  io:format("~w processes computing the ~w primes under ~w took ~w microseconds~n",[NProcesses,length(L),PLimit,T]).

pprimes(NProcesses,PLimit) ->

  % the simple accumulator process will collect the results
  Accum_PID = spawn(pprimes, accum, [[]]),

  % the queue process will serve out the next number to check as a prime
  Queue_PID = spawn(pprimes, queue, [2,PLimit,self()]),

  % spawn the worker processes
  lists:map(fun(X) -> spawn(pprimes, prime, [X,Accum_PID,Queue_PID]) end, lists:seq(1,NProcesses)),

  % wait for the worker processes to signal completion
  wait_primes(NProcesses),

  % when the worker processes are done, tell the queue process to complete
  Queue_PID ! {done},

  % send message to the accumulator process and wait for response
  Accum_PID ! {get_primes, self()},
  receive {primes,L} -> Accum_PID ! {done} end,
  L.

% if there are no more worker processes to wait for...
wait_primes(0) -> noop;

% otherwise keep waiting...
wait_primes(N) ->
  receive
    {done} -> wait_primes(N-1)
  end.

% simple accumulator process:
% when it receives an add_prime message, adds the prime and re-loops with new list
% when it receievs a get_primes message, responds with the current list and re-loops
% when it receives the "done" message, ends.
accum(L) ->
  receive
    {add_prime,P} -> accum([P|L]);
    {get_primes,Client_PID} -> Client_PID ! {primes,L}, accum(L);
    {done} -> noop
  end.

% queue process end case: when the queue is empty, enter the queue_empty function.
queue(Cur,PLimit,Main_PID) when Cur == PLimit ->
  queue_empty(Main_PID);

% queue process main case: wait for next_prime messages and re-enter
queue(Cur,PLimit,Main_PID) ->
  receive
    {next_prime,Prime_PID} ->
      Prime_PID ! {ok,Cur}
    end,
  queue(Cur+1,PLimit,Main_PID).

% empty queue process: inform next_prime requesters that the queue is empty until we receive the "done" message
queue_empty(Main_PID) ->
  receive
    {next_prime,Prime_PID} ->
      Prime_PID ! {queue_empty, Main_PID},
      queue_empty(Main_PID);
    {done} -> noop end.

% main worker process: get the next prime from the queue...
prime(X,Accum_PID,Queue_PID) ->
  Queue_PID ! {next_prime, self()},
  receive
    {ok,N} ->
      % io:format("worker ~w testing ~w ~n",[X,N]),
      case is_prime(N) of
        true ->
          % io:format("worker ~w found ~w to be prime!~n",[X,N]),
          Accum_PID ! {add_prime,N};
        false ->
          % io:format("worker ~w found ~w to NOT be prime!~n",[X,N]),
          noop
      end,
      prime(X,Accum_PID,Queue_PID);
    {queue_empty, Main_PID} -> Main_PID ! {done} end.

% very poor, but we want the process to actually do "some" work...
is_prime(N) when N < 2 -> false;
is_prime(N) when N == 2; N == 3 -> true;
is_prime(N) ->
  lists:all(fun(A) -> N rem A =/= 0 end, lists:seq(2, N div 2)).

% utility funtion: we get our arguments as 'atoms' e.g. '12' but we want integers
atom_to_integer(Atom) ->
  erlang:list_to_integer(erlang:atom_to_list(Atom)).

If you save the code from this listing as a file "pprimes.erl", you can then compile it from the command line with:

$ erlc pprimes.erl

The following shows an example of running the program from the command line:

$ erl -smp -s pprimes start 100 10000 -run init stop -noshell

You should receive some output that looks something like:

100 processes computing the 1229 primes under 10000 took 1894288 microseconds

And if that isn't "parallel enough", how about just blindly spawning a process for each work item immediately, bypassing the queue altogether?

-module(vpprimes).

-export([start/1]).
-export([vpprime/2]).

start([PLimitAtom]) ->
  vpprimes(atom_to_integer(PLimitAtom)).

vpprimes(PLimit) ->
  lists:map(fun(N) -> spawn(vpprimes, vpprime, [N,self()]) end, lists:seq(1,PLimit)),
  lists:foreach(fun(N) -> io:format("~w~n",[N]) end, [N || N <- receive_all(PLimit,0,[])]).

receive_all(PLimit,N,L) when PLimit == N -> lists:sort(L);
receive_all(PLimit,N,L) ->
  receive
    {p,P} -> receive_all(PLimit,N+1,[P|L]);
    {n,_N} -> receive_all(PLimit,N+1,L)
  end.

vpprime(N,R) ->
  T = is_prime(N),
  if T -> R ! {p,N};
     true -> R ! {n,N}
  end.

% very poor, but we want the process to actually do "some" work...
is_prime(N) when N < 2 -> false;
is_prime(N) when N == 2; N == 3 -> true;
is_prime(N) ->
  lists:all(fun(A) -> N rem A =/= 0 end, lists:seq(2, N div 2)).

% utility funtion: we get our arguments as 'atoms' e.g. '12' but we want integers
atom_to_integer(Atom) ->
  erlang:list_to_integer(erlang:atom_to_list(Atom)).

If nothing else, erl -smp -s vpprimes start 10000 -run init stop -noshell will launch 10000 processes to poorly compute a list of primes. Now, is any of this useful? Not for computing primes, certainly. But imagine instead that you wanted to take advantage of an 8-core system and at least speed up the "map" part of a "map-reduce" algorithm. You could now (hopefully) go out and write a "parallel-map" function that applies a function in parallel to all elements of a list, returning the new list.

More trumpet.

2006-10-07T15:33:00.000-04:00

A long practice session with the old horn, really starting to get the range, endurance, and tone control back. Most of the rest of it (fingering, reading music) is like riding a bike, and it's fairly silly how much I still remember from the old days.

Some guitar work, too.

Borrowed some microphones from a friend at work to experiment with new sounds, and just in time as the MOTU finally arrived -- missing all of the advertised audio cables, but I guess that is par for the course when buying used off of eBay. But wow, what a difference in sound when I plugged the MOTU in -- I guess that's what people are talking about when they say that your A/D converters matter, because it was not much short of an amazing difference.

I still don't understand sampling rates, sample size, and most of the driver settings. But hey, that's what a copious amount of free time is for...

Dusting off the trumpet.

2006-10-02T20:15:00.000-04:00

Practice time today was on the trumpet. Apparently the last time I played it, I thought that I would be picking it back up soon, because I left it half-covered with fingerprints. But that doesn't hurt the sound. Anyway, as I suspected it is mostly my range and endurance which are still the most hurt -- it's actually fairly interesting how much I still remember. Some more practice and I should be back up to snuff enough to get through any bits I come up with for the album.

Hello, MOTU.

2006-09-28T14:41:00.000-04:00

Well, just when I had officially decided to go with the Echo AudioFire4, I won an eBay auction for a used MOTU 828. It's definitely a lot more machine, but it has the footprint to prove it. Anyway, I'm hoping that it comes soon, it just works, and finally I can get all this gear talk behind me and get back to work.

On that front, I did some more playing around with Tracktion, recording a take of "Carousel". Wow! That is some pretty nice, easy to use software. It probably didn't hurt that I think I'm getting the knack of microphone placement and level setting the Mackie mic pres.

On the songwriting front, unfortunately I just can't stop the G-C-Em progression from dominating everything I do. I've been working on a song for a while, just lyrics and melody, and then I realised: uh-oh, this is practically the same song, again, as both "Carousel" and "Best Days". And I've already used the capo trick. So the song I've tentatively entitled "Where You End And I Begin" doesn't really have a place to go right now.

Tracktion and lack thereof.

2006-09-26T22:11:00.000-04:00

I downloaded the demo for Tracktion, the Mackie-distributed PC software for music recording. Since it comes with the Echo AudioFire devices, I wanted to see what I would be getting into. Looks really nice so far, sounds really nice.

I've been learning about analog summing. Very interesting stuff, using my mixer again in the final stages of studio mixdown. A neat idea and I really liked the sounds I was getting when playing with it and the demo of Tracktion.

But none of that made me a better player or singer today.

A cheap used Shure PG-57 is on its way from eBay. I plan to use it for trumpet snippets, maybe try some vocals on it as well. Too much gear talk, not enough music!

Jose, tripping, and progress

2006-09-26T00:01:00.000-04:00

First off, José González was absolutely great at Cat's Cradle last Thursday. Death Vessel opened and was quite a unique sound.

Unfortunately not much practice lately, and it shows. We took a trip back to the flatlands of Indiana this weekend, where I yelled myself hoarse at Purdue homecoming. But between seeing the old pines and oaks from "back home" and last week's concerts, there is certainly some inspiration to get back to work.

So finally tonight some progress. I put the "home studio" (I laugh!) back together, and had a chance to "X+Y" record some guitar with my PG81 and AT2020. It actually wasn't a terrible sound, even coming through the Sound Blaster. What was disconcerting, however, was some weird source of timeshifting when I recorded vocals to the guitar track. Some kind of latency is sneaking in there, either from the Sound Blaster itself, the USB bus, or from my sound software. Or, and I hope not, my Mackie -- the scary thing is I don't remember having this issue using the same software and sound card, the only differences were the inputs and the computer itself being the Athlon tower now instead of the Thinkpad. Very disconcerting.

Wow.

2006-09-20T00:59:00.000-04:00

Just got back from the Lincoln Theatre. Wow. Mason Jennings was just unbelievable live. Unbelievable.

Jennifer O'Connor opened the show, and was impressive in her own right. But from the moment Mason Jennings stepped on stage, until when he and his fellows played their last encore over 90 minutes later, it was just an amazing experience to be there in the Lincoln. Stunningly talented, intimate and powerful music. It makes me both want to get right to recording right away, and at the same time quit the whole thing.

Disappointment

2006-09-18T11:06:00.000-04:00

Ouch. Well, I spent most of Sunday afternoon figuring out how to properly wire my AT2020, Mackie, and sound card. Nothing worked, until finally I remembered that every time I plug in my USB sound card, I have to manually go into the control panel and select the "line in" for recording. I fired up my trusty, simple Acoustic Labs Multitrack Recorder and laid down a few tracks, anxiously awaiting the end result.

To my dismay it didn't sound like much of an improvement over the old Akai DM microphone recordings. Still tinny, still thin, no warmth.

Back to square one, I guess. Have to figure out if it's the sound card, if it's the PC, or what's exactly going on.

I did happen to catch K.T. Tunstall on Austin City Limits, though. Wow. Great live performance. Having spent the last few weeks absorbed in microphones and mixers, it gave me a bit broader appreciation for everything that went into the show. Now I want to figure out what some of her stomp boxes do...

Strings

2006-09-14T03:39:00.000-04:00

Well, maybe I was a bit too hasty pronouncing the death of my Martin strings. Tonight they sounded actually quite pleasant. Another night up all night looking at "audio interfaces" that I probably don't even need.

I did hear back from the AT2020 seller. Some jive about "we just print what the manufacturer says" which is, provably, a bunch of hogwash since the box doesn't even match its contents. But hey, what do I know. He promised to look around as see "if they have any extra adapters". Well, I certainly hope so.

Stringwork

2006-09-13T17:47:00.000-04:00

Saturday and Sunday saw a lot of playtime. The strings settled in only slightly, still a very bright, metallic sound. So I'm likely to avoid the Phosphor Bronze and Bronze strings from Martin in the future. The other options are Elixir, with their "nanoweb" coating, and the recommended D'Addario Silk and Steel strings, both of which are supposed to give me a bit of a softer, more mellow sound. That is what I like, so that sounds like a plan for the future for things to try.

Anyway, not much practicing on Monday or Tuesday. Last night I subbed in for a friend's soccer team and scored my first goal in organised soccer. Hopefully tonight I can get back "on the horse".

I did find a taker for the Yamaha mixer, so it's heading out the door. I had a taker for the AT2020, but inspecting the box revealed that the eBay seller either lied directly or made the mistake of forgotting 2 fairly key accessories. So that fell through in fairly spectacular fashion. There is another guy with interest, so maybe I can get those accessories and make the sale yet. Otherwise, it is a highly reviewed microphone, so maybe, just maybe, I'll try it out myself.

Self-defeatism

2006-09-07T17:25:00.000-04:00

I think the reason I haven't been able to sleep well since I started actually getting recording equipment (out of the blue and way ahead of plan) is inexorably tied to self-defeatism and fear of failure.

As I said in my first post to start this thing, I know I don't have all this talent. But something happens when you step up to a microphone to amplify or record yourself in a critical setting. It doesn't happen to me at all at open mic nights, or just hanging out with friends. But when the power is turned on, the tracker is ready to go, I freeze up. My stomach tightens, and I think: "Wow, you really suck. You are wasting your money." It's fear that if I truly give it my best shot, it will still suck even worse than my self-deprecating disclaimers profess, and that will be disappointing. So, to prevent this, I give myself an out. I don't try as hard. I back off. I engage in self-defeating behaviour like buying things I don't need, to make things overly complex. Like not sleeping.

I've got to get in the mindset that I'm doing this for fun, not for profit, or posterity, or pride.

Help is on the way

2006-09-07T00:32:00.001-04:00

On the way home, I emptied the contents of my wallet on some final close-out items from my local music shop. (And I wonder: where am I going to go for gear and guitar tech help now?) A couple of XLR microphone cables and an el-cheapo (as in $10) microphone stand. They had a couple of really interesting-looking microphone stands, really solidly-built boom stands from Germany, but even at closeout they were $50. (For a microphone stand. Yes, really.)

And then reaching home I realized that, once again, I am an idiot.

You see, when I realised I was going to return the PG57, I did a little eBay shopping. I put lowball offers in on a couple of microphones, one of which (AT2020) was accepted yesterday. Turns out, the other one was accepted earlier this evening. So I'll be adding a Shure PG81 to my closet, even though I was not yet budgeted for two microphones right now. It's a bit of a pickle. Worse, they are both condensors, leaving me without a dynamic mic for vocals.

Combine that with some brimming buyer's remorse for the Mackie -- I still need a decent sound interface to capture the output to my computer, and it just seems like the Mackie isn't as good a fit as I had thought when it comes down to really making it do what I want it to do. And buyer's remorse for both microphones, when I should have just picked up an SM57 and called it a day. Ah well.

But at least now I can absolutely stop looking at microphones for a good long while, because the wallet is closed.

Anyway, I also put new strings on the Washburn, some Martin Acoustic SP "custom light" strings (another closeout purchase from Pearson, R.I.P.). I really, really dislike the sound of all new strings. At least for a day or two, they just sound absolutely "twangy" and metallic as they settle in, and I think it may be a bit worse with this particular set of strings. I was a bit hesitant going lighter than my standard "medium" strings, but these were an in-between: heavier than light, lighter than medium. Turns out that this is just too damned light. But I'll give them a few more days, see how they turn out once they are broken in a bit. But my guess is that I'll be restringing the Washburn again before too long.

New strings on the fretboard, had a good run-through of most of the songs again. My fingers are finally starting to get back into playing shape, even though new strings seem to really cut up my left-hand fingertips. (Did I mention that I hate new strings?)

Microphone shuffle

2006-09-05T20:41:00.000-04:00

Out with the old, in with the new. Luckily I hadn't opened the Shure PG57 yet, because a glance at its online user's guide showed it wasn't recommended for acoustic guitar. (That's saved for the 81.) So, it safely back at its place of purchase, I picked up an Audio-Technica AT2020 from eBay to replace it. So, sometime next week or so, hopefully I'll be able to put together my first home recording of any decent fidelity. Hopefully I won't need to pick up the microphone's shock mount because that would just about double the price. But at some point, I need to pick up some kind of mic stand...

Everything I read about the SM81 makes me very, very interested. But it's still a bit beyond my budget reach, at least for now.

It's concert time

2006-09-04T22:39:00.000-04:00

This fall is just an amazing time to be a fan of "modern folk rock" music (or whatever you want to call it) in Durham, NC, or parts nearby. Even just the upcoming shows you can find on Etix for the area (Carrboro, Chapel Hill, and Raleigh -- are there really no Durham venues at all?) reads like a "who's who" of the genre.

Mason Jennings (mrs. montsamu's favorite) and Jose Gonzalez are the two shows we've decided to get ourselves together to go and see -- and if I had unlimited time I would definitely see a few more. Sufjan Stevens plays the same day as Jose Gonzalez, but unfortunately for me he sold out in minutes. This makes me sad, because he came through a couple of years ago and I made a "mental note" to get tickets, but as things tend to do it got overlooked until it was just too late. Ah well. At least I've managed to catch Alexi Murdoch down here, and a great show with Ben Arthur, Abra Moore, and Vienna Tang that was supposed to also feature Teitur, but he was called away at the last second to play the Prince of Denmark's birthday party or something.

So, without further adieu, my picks for shows to see if you're in the area (bold for the ones we're ticketed to see):
19 September: M Ward; Mason Jennings
20 September: Calexico
21 September: Sufjan Stevens; Jose Gonzalez
22 September: Eric Bachmann and Richard Buckner
3 October: Serena Maneesh (ok, so this is a completely different genre -- sue me.)
13 October: Shawn Colvin
19 October: Amos Lee
22 October: Old Crow Medicine Show
4 November: Carbon Leaf
8 November: Edwin McCain
14 November: Califone

If I weren't heading out of town on the 22nd, I would absolutely catch Bachmann (of Crooked Fingers) and Buckner, who is another one of those artists who I've loved for years, and the last time he came to town I made the mistake of the "mental note, down the drain" trick.

Labour Day weekend is a doozy

2006-09-04T22:04:00.000-04:00

Leaving the house on Saturday morning, heading out for some errands, I did not expect to see people wearing breadboards announcing that my treasured local music shop, Pearson Music, was going out of business. On a whim, I headed inside to see what might remain on the shelves. Sadly, no microphones, but they had three Mackie mixers to pick from, all at fairly steep markdown: a DFX-12, a 1202-VLZ Pro, and my eventual choice, a 1402-VLZ Pro.

So, I've been spending some time trying to figure out how to use it. So far, so good.

But unfortunately the upgrade from my previous microphone pre-amp (if a Radio Shack Karaoke Mic Adapter can be named as such) didn't alleviate my issues with the damaged goods that are my Akai DM-13 microphones. And, worse yet, my Dean Markley Acoustical Transducer decided that this would be the day it finally gave up the ghost for good. So I picked up a new microphone, a Shure PG57, but so far I haven't had a chance to take it out of the plastic wrap and put it to any kind of test.

So, quite a weekend. Maybe with the mixer and a new microphone, I'll get my butt in gear and put something together in the next couple of weeks. We'll see how it goes.

Ouch.

2006-08-31T09:40:00.000-04:00

Well, fingerpicking work was severely hampered when I completely jacked up my thumb playing basketball. I got through another go-round of "Carousel" and the piano version of "This Old Road", and some more piano covers.

On my mind: microphones. The 1970s-era Akai microphones I have pick up spoken word and even vocals fairly well, but I've not managed yet to get them to pick up my guitar in anywhere close to acceptable, and the piezoelectric pickup I've had for years just doesn't do it for me either. It probably doesn't help that my pickups and sound card cost $20 each, but hey. I'll get there. Right now there's no point in rushing on any of that because I've certainly still got work to do ironing out and finishing a few of the songs.

Where do people find the time...

2006-08-30T10:58:00.000-04:00

I put another set of song lyrics up, and actually had some time to practice through quite a few tunes on the guitar at home: "Carolina", "Cry", "Catch the Sun", "Best Days", "Anger", a bit of "Crossroads", and the guitar version of "This Old Road". I also played a few of the covers I'd like to record, but after learning a little about mechanical licensing, I definitely could not offer free downloads at any fidelity of my version of a cover, period. And, since it's not terribly likely that anybody would be lining up to pay for one, I'll probably have to stay away from them for now.

Putting yourself out there

2006-08-29T10:24:00.000-04:00

Well, I used Writely to put a few songs worth of lyrics online. It's certainly a much easier and faster way than trying to use Google Pages to edit several pages and get everything "just right". Of course, "just right" certainly doesn't summarize my feeling on the lyrics at all. Standing alone, without music -- wow, they look juvenile and simple. But then again, not may people mistake a lyrics book for poetry.

Maybe it's a good thing I don't have my actual poetry online anymore...

I didn't get much practice in last night, since I was taking in the Jimmy V Volunteer dinner. To my surprise, a very accomplished singer-songwriter, James House, was the evening entertainment. Once home, I did manage to get once more through "Carousel". I'm not sure I'm happy with it but it appears to be getting "set" into a final state. My songs are so limited in chord changes and variety, but at least I threw a capo on for "Carousel" to change the pitch of the drone and hum, even if it's basically the same rythm and chord progression for the most part as "Best Days".

I've got to get with Bud and iron out some kind of agreement for the poem he wrote that I turned into a song, back in 1998 or so. But he's yet another of the friends I've completely lost contact with over the years. (Maybe there's a song idea in there somewhere...)

Is this thing on?

2006-08-28T16:42:00.000-04:00

Against all better judgement, I'm finally getting around to recording some of my songs. I don't think they are particularly good, or that I'm a particularly good musician. But they're my songs, and I think at least a couple of people might enjoy hearing them. In any case, my friends and family will have something more tangible to point to when I ask them why they are pointing and laughing at me.

The main home for things like lyrics, tabliature, and links to downloads will be over at the main montsamu music website, but this blog will keep track of my progress as I put pen to paper, pick to string, fingers to piano, and microphone to input and try to put together something that sounds sort of like a guy and his guitar and piano instead of static or the sound of a cassette tape going round and round.