• Book Review: A Mind at Play: How Claude Shannon Invented the Information Age

    Review: A Mind at Play: How Claude Shannon Invented the Information Age, by Jimmy Soni and Rob Goodman. Simon & Schuster, July 2017. Buy a copy from Powell’s, Indiebound, or amazon; see if your friends are reading it at goodreads.

  • "How will design patterns make me a better coder?"

    A design pattern itself won't make you a better programmer. Knowing lots of them - when to use them, and their strengths and weaknesses - will. Design patterns are experience, coalesced and distilled.
  • Fractal Circles

    In August of 2014, I participated in Re:GENERATE, a show featuring computer-generated art. I made, among other things, a generative series for the event, that I named Fractal Circles.

  • How to Enable Mouse Wheel Support in controlP5 on Processing 2.2

    I’m finally using controlP5 in earnest, and I noticed that two-finger trackpad scrolling over a knob didn’t dial the knob, like I’d hoped it would. (Thanks to Ben Oakes, again, for showing me - just yesterday afternoon - that Ubuntu’s volume icon supports this. That was the trigger that got me wondering about this.)

  • NewHaven.IO goes to the White House

    President Obama has launched an initiative called TechHire.

  • Circle Pictures Redux

    Back in December, I posted some images I’d made by dropping non-overlapping circles on an image, larger or smaller based on the brightness of the underlying pixel at that spot. I called them Circle Pictures.

  • Public Domain Pictures

    Maybe old news, but news to me: 4 collections of photos in the public domain, and they’re not too bad:

  • "Computerless" Programming, via Golan Levin

    Golan Levin has posted his notes from the Code+Ed Session on 2014-06-10 at the Eyeo Festival, on computing without computers.

  • "A Little Ruby, a Lot of Objects," back on line

    When I was first learning Ruby, one of the resources that helped me most was Brian Marick’s “A Little Ruby, a Lot of Objects.” It’s modeled after The Little Schemer (or, if you’re older, The Little LISPer), but it uses Ruby, and teaches the core ideas of object-oriented programming in a way that helped me, even after I’d been doing OOP for 6 years. (I’m not surprised that his newer book, Functional Programming for the Object-Oriented Programmer, is just as illuminating.) The only thing I didn’t like was that it stopped after only 55 pages.

  • Two Copyright-Free Photo Collections

    I’m always looking for interesting photos to hack on, so I was glad to find these two sources of free images, both via Vormplus.

  • SuperCollider: 3 introductory posts

    Scott Petersen has put together three tutorials on getting started with SuperCollider:

  • Book Review: The Information, by James Gleick

    Or: “The Information: A History, a Theory, a Flood. A Review.”

  • Circle Pictures

    Circle Pictures

  • RubyNation 2013 In Review

    RubyNation 2013 is done! Outside of un-confs like BarCamp, it was the first conf I’ve presented at. I was nervous, so I kept practicing and smoothing the slides, and I think that helped a lot - everyone seemed to like the talk. Thanks again to everyone who came to hear it!

  • I'm Speaking at RubyNation 2013!

    This weekend, I’ll be giving a talk at RubyNation 2013, titled “Object-Functional Fusion in Ruby.”

  • Ruby Scrubbing JavaScript: Raise Those Curly Braces

    Of the Programmer Holy Wars, “curly braces on the same line, or the next line?” is not as vitriolic as emacs/vim or tabs/spaces, but it’s up there.

  • PSA: Connecticut Tech is Getting Exciting

    New Haven Ruby is going strong, and New Haven JavaScript is heating up fast. We had a great turnout last night, with about 40 people at the Digital Surgeons office, and some great talks. Meet-ups are full of energy, introductions, and catching up with friends. And, obviously, tech talk.

  • Direct Manipulation, and Text Editors

    Hat-tip to Giles Bowkett for mentioning Bret Victor’s talk, Stop Drawing Dead Fish, about direct manipulation and computer interaction as a tool for illustrators and animators.

  • Cantor's Snowflake

    The Koch snowflake is a famous fractal.

  • Symmetrical Portraits, Undone

    Julian Wolkenstein’s Symmetrical Portraits project just made the rounds. I could’ve sworn I saw it on Brain Pickings, but I can’t find it now. Whatever, no matter.

  • Chaos, Order, and Software Development

    Zach Dennis gave a very interesting, but not terribly well-received talk at RailsConf 2012, called “Sand Piles and Software.” (It’s on the schedule on Tuesday in Salon J, if you want to check it out.) Here are the slides (which are more suggestion than information), and here’s the synopsis:

  • ERMAHGERD, the Gem

    I just published my first “official” gem, ermahgerd, and what an auspicious way start my gem-author career! ERMAHGERD, I’M A RERL RERBER PRERGRERMAHR!

  • Rails 3: Selectively Override Email Recipients

    It’s a common thing, in your test environments, to intercept out-going email, and stuff it in some dumpster out back, so you don’t bother your users. We do this at SeeClickFix, and we’re upgrading to Rails 3, so I went searching for the new way to do this, and found Rob Aldred’s handy post on the subject.

  • New Haven Ruby: First Thursday, Third Wednesday

    The New Haven ruby group is gonna start building some rhythm, meeting twice every month, on the first Thursday and the third Wednesday. Even months (June, August, October) are hack-nights; odd months are social nights.

  • Out of Love with Active Record

    (I’m a new-comer to Rails. When I first found Ruby, and Rails, I liked the Ruby better. And I never found many Rails jobs near home anyway. So for years, Ruby flavored my C#, and C# is where I learned, among other things, to persist my domain aggregates with NHibernate. Now I’m a card-carrying Rails jobber, which is great, because I play with Ruby all day. And the Rails community is discovering domain-driven design, and ORMs…)

  • BarCamp Boston 7: This Weekend!

    BarCamp Boston 7

  • Cover your Moleskine in Brown Paper

    (He’s kidding, right? He didn’t really cover his moleskine in ugly brown papeAUGGUGHHUH)

  • Redder Pastures

    What the hell happened? I mean, I don’t care for “I haven’t been blogging because…” posts either, but it’s been quiet here lately, hasn’t it?

  • WordCram: Open-Source Word Clouds for Processing

    I just released a project I’ve been working on for a while, called WordCram.  As the title says, it’s a Processing library for generating word clouds.

  • After OsCon 2010

    OsCon 2010 is done, and I’m pooped. I met some great people, the talks were good, and I saw some promising ideas and technologies. Portland is a great city, with free public transportation, good beer, veggie-friendly restaurants, and Mt. Hood close by. What more could you want?

  • Disable Your Links, or Gate Your Functions?

    It’s pretty common to disable links and buttons that cause updates, so those updates don’t happen twice, and re-enable them when the update has finished.

  • Where the Abstraction Leaks: JavaScript's Fake Arrays

    Ruby arrays have a nice feature: you can construct a new array with an integer N, and a block, which will be called N times, to fill up the array:

  • Array.prototype.toString

    This is one of my favorite javascript tricks, because of its effort-to-payoff ratio.

  • Firebug and Monaco, on Windows

    I’ve been running Firebug at work for a long time, it’s a really solid tool. A while ago, I started using a Monaco.ttf for Windows. I think it looks much better on my Ubuntu system, but it’s nice to have on Vista.

  • Clojure Changing My Mind

    As good as Processing is, it’s still java. I’ve slowly been learning clojure, and trying to use it with Processing, via clj-processing. While the clojure docs and the book are both good, I’m still in that flounder-around stage, trying out tiny experiments to understand how things work.

  • A JavaScript War Story

    What follows is an account from the author’s experience. Some details have been changed for the usual reasons, and a poor memory has fuzzed out the rest.

  • Higher-Order Functions and Function Composition, with Processing

    I was looking for a good way to illustrate functional composition and higher order functions, and thought that something could be done with Processing, a java-based graphics tool. Among other things, Processing exposes raw pixel data for the images it renders, and you can update the pixels programatically, providing a simple kind of image filtering.

  • Book Review: Pragmatic Thinking and Learning

    I was planning on reading Andy Hunt’s Pragmatic Thinking and Learning: Refactor Your Wetware for a while, but kept putting it off, thinking it wasn’t really central to what I’m interested in, what I’m doing.  I was wrong.

  • Heading to the Int'l Lisp Conf, 2009

    My next step on the road to lisp is at the International Lisp Conference in Cambridge, MA, this March.

  • Come to the Hartford Ruby Brigade's January Meeting

    As we trudge back to our regular schedules after assorted holiday debaucheries, here’s a heartening thought: Hartford.rb is meeting on Monday, 1/26! Gary Wright will tell us the story of how he learned Git, and some lucky stiff will walk away with a free copy of The Rails Way. We’ll even have pizza – though we’re now on the look-out for a pizza sponsor, so if you know anyone looking to feed us (for only ~$50 a month!), it might even be free.

  • Accuracy and Precision: Not the Same

    I often hear people mis-use the words accuracy and precision, but they mean different things.

  • The Twelve Bugs of Christmas, via Ruby

    Here’s a little bit of post-Christmas fun, based on the Twelve Days of Christmas.

  • Simplifying Boolean Expressions

    Many programmers can't simplify boolean expressions...or at least code like they can't. Here are some basic rules for simplifying boolean expressions, and an example, with some pointers to more material on boolean algebra.
  • Next Hartford Ruby Group meeting: 11/24

    The Hartford Ruby Group is meeting this Monday, 11/24, from 6 - 8 PM.

  • Hartford Ruby Brigade next meeting: 10/27

    The Hartford Ruby Group is meeting this Monday, 10/27, at 6:00 PM.

  • Hartford Ruby Brigade meeting tonight

    If you’re in the area, feel free to drop in:

  • Use Ruby's method_missing to see what happens to an object

    Lately I’ve been generating MS Word .docs from text files, with RedCloth and Hpricot (thank you, why, for both of those), and win32ole. It’s been fun, except for the OLE parts: the ruby bridge is great, but the OLE API itself is strange, good documentation is sparse, and things get…flaky, sometimes.

  • Working Faster, Avoiding the Mouse

    I’m moving away from my mouse all the time. On the one hand, it’s so much faster to keep my fingers in the same place, and on the other, it’s easier to automate keystrokes than mouse motions & clicks. I especially don’t like mousing through menus, so I’m always on the lookout for keyboard shortcuts. Here are two tools that help me stay away from the mouse.

  • Long-running averages, without the sum of preceding values

    Here’s a little lunch-time diversionary math.  Suppose you want a function that takes a number, and returns the average of all the numbers it’s been called with so far.  Handy for continuously updated displays, that kind of thing. Here’s a method that will return this averaging function.

    private static Func MakeAverager()
        float sum = 0;
        int count = 0;
        return delegate(float x)
            sum += x;
            count += 1;
            return sum/count;
  • Gregory Brown at the Hartford Ruby Brigade

    This past Monday night, Gregory Brown, ruby mendicant, stopped by for the Hartford Ruby Brigade’s July meeting.

  • Constructor Inheritance in C# and Ruby

    This morning: “Surprise!  Want to conduct a job interview?”  I’ve been here a little over 3 months, but um, sure!  “Great.  He’s in the conference room right now.”  Wow, we move quick.

  • Why "Less Code" Matters

    …being able to do task X with 50 lines of code is preferable to needing 500 lines of code to do task X. Less code takes longer to write, but the real benefits are around maintenance: less code means less of a chance of bugs, less to keep in your head, less for someone else (or yourself 6 months later) to read through and learn, less to test, and less to modify when you change the rest of the system.

  • Passing by reference, and dog leashes

    Pass-by-reference and pass-by-value are pretty confusing when you start learning to code. When I first saw them, I know I ignored the distinction (until I got tired of my code not doing what I expected). Throwing collections into the mix just makes it worse.

  • My GoRuCo 2008 highlights

    Aaron and I had a great time at GoRuCo 2008 last Saturday. Here are my highlights.

  • Trading Space for Speed: Memoizing with Ruby Facets

    Recently, I talked about a faster, cheaper way to calculate Fibonacci numbers. One of the optimizations I made was to remember the value of each Fibonacci number: since F(7) is always 13, instead of recalculating it each time N=7, we can stuff 7 -> 13 into a look-up table for future reference. The function builds up a cheat-sheet, to avoid doing the re-work. It remembers.

  • Why We Abstract, and What To Do When We Can't

    “Whenever you see yourself writing the same thing down more than once, there’s something wrong and you shouldn’t be doing it, and the reason is not because it’s a waste of time to write something down more than once. It’s because there’s some idea here, a very simple idea, which has to do with the Sigma notation…not depending upon what it is I’m adding up. And I would like to be able to always…divide the things up into as many pieces as I can, each of which I understand separately. I would like to understand the way of adding things up, independently of what it is I’m adding up.”

    • Gerald Sussman, SICP Lecture 2a, “Higher-order Procedures” (emphasis added)
  • Ruby Facets: Symbol.to_proc, Class.to_proc

    One pretty well-know idiom in Ruby, and Facets, is Symbol.to_proc. It lets you turn these:

  • A Faster, Cheaper Fibonacci Definition

    The Fibonacci sequence is one of the best-known number sequences:

    1. 1
    2. 1
    3. 2
    4. 3
    5. 5
    6. 8
    7. 13
    8. 21...
  • Hartford Ruby Brigade starts with a tour of Ruby Facets

    As Rob Bazinet has said, the Hartford Ruby Brigade is having its first meeting on March 24. You can get all the details from his post. Come join us! There’s even a book raffle.

  • Continuations: a warm-up

    Continuations and continuation-passing style (CPS) are introduced in The Little Schemer, chapter 8, using collectors: functions that collect values, through being repeatedly redefined. It was a tough chapter for me, but the idea is simple once you get it, so I’d like to leave some help for others. I’ll use Ruby for the examples, with some JavaScript and Scheme at the end.

  • Regular Expressions into lambdas: swapper, stripper, scanner

    Here’s some light Friday fun… When working in ruby with regular expressions on Arrays of Strings, I get so tired of doing this:

  • Counting On Your Fingers

    If I ever have kids, I’ll teach them to count on their fingers. In binary. “Pff, 10? I can reach 1023!”

  • Why Functional JavaScript?

    I’m teaching myself functional programming (FP). I first noticed it in Ruby, even though it’s been in JavaScript all along. I’m working my way through Structure and Interpretation of Computer Programs (SICP), and The Little Schemer books, so I’m learning Scheme and Lisp too.

  • Fear, Uncertainty, and Doubt

    Of all the monsters that fill the nightmares of our folklore, none terrify more than werewolves, because they transform unexpectedly from the familiar into horrors. For these, one seeks bullets of silver that can magically lay them to rest. The familiar software project, at least as seen by the nontechnical manager, has something of this character; it is usually innocent and straightforward, but is capable of becoming a monster of missed schedules, blown budgets, and flawed products. So we hear desperate cries for a silver bullet… - Fred Brooks, No Silver Bullet

  • reCAPTCHA: stop spam. read books.

    This is really cool. reCAPTCHA is a free CAPTCHA service that asks the user to type two words. They know the first word, but the second comes from a failed OCR scan. If you get the first word right, reCAPTCHA assumes you’re human, and they store your answer to the second word…they even run it by a few other humans to raise the confidence. Not only are you authenticated, you’re transcribing. According to reCAPTCHA, “in aggregate these little puzzles consume more than 150,000 hours of work each day”.

  • Ruby's other ternary operator

    This may be a well-know Ruby trick, but I thought I’d share it anyway.

  • Functional Programming in JavaScript and Ruby

    [UPDATE: I’ve been lucky enough to have some commenters who know much more about functional programming than I do. There’s some good reading in the comments, and you especially should read them before using this stuff in production.]

  • How to Design A Domain Specific Language, with David Pollak

    I just finished watching David Pollack’s presentation at Google, How to Design A Domain Specific Language. It’s only an hour, and it’s got some interesting ideas. A nice jog, good for your mental health.

  • Programmable Text Editing on Windows with EmEditor

    Windows lacks a decent programmable text editor.

  • Gotham Ruby Conference

    This April 21, in Google’s Manhattan offices, for $100, you can check out the Gotham Ruby Conference.

  • Ruby, Yoga for your Brain

    Just a fun little bit of writing, for a contest

  • Blogging with RedCloth and WordPress

    I don’t particularly like WordPress’ built-in editor. I don’t like typing HTML by hand, especially since I’ve found Textism. I tried using Ruby’s RedCloth gem to convert my blog drafts from Writeboards into HTML that I can stuff into WordPress, but it replaces each double-newline with </p><p>, which makes it hard as hell to read.

  • I've been Blog-tagged??

    JT tagged me…so here we go. In case anyone’s wondering, here is where it all started.

  • Dvorak: The Betamax Keyboard

    I’ve been a Dvorak typist for about five months. It took me three tries to really stick it out through the learning phase, because let me tell you—as a touch typist, any learning curve over one week sucks (and you’re probably not learning Dvorak if you’re a hunt-and-peck-er). There are some things I wish I knew before I switched, so I’m feeding them to Google for others to find. My thoughts reflect only my experience, YMMV, and all that. For me, the short answer is that I’ll probably switch back to QWERTYUpdate: I never actually did, and I’m considering writing a recant to this post.  See the bottom of the post…

  • Why is Ant in XML?

    Before we start…

  • In the new office!

    My company moved its office last week – this is our first week at home in the new digs. My desk is against a great brick wall, and next to a window that actually opens! I have a great view of Talcott Mountain, which should soon start turning to fall colors.

  • Programming, Zen, and...Origami

    I’ve started re-reading Zen and the Art of Motorcycle Maintenance. There are so many gems in it that I’ll probably start a page in my backpack for them. Here’s one I like:

  • Who's Afraid of Functional Programming?

    Joel Spolsky just published a great (and very brief) explanation of functional programming. There’s also a podcast of Berkeley’s CS 61A SICP course from Spring ‘06 that I found – the first few lectures on functional programming are really worth your time. And finally, for a rambling, evening-discussion style explanation of functional programming, complete with historical anecdotes, there’s Functional Programming for the Rest of Us. [You might want to save that one, and come back when you have some time…but do come back to it.]

  • Invisible Blocks moves to WordPress

    Here’s the new RSS feed. JavaScript redirects should bring everyone over to the new site. Please let me know at danbernier - at - gmail if you find anything wrong.

  • Ruby, Meta-programming, and Watir

    WATIR – Web App Testing In Ruby

  • Conway's "Game of Life", the Glider, and Hackers

    I just ran across ESR’s proposal to adopt the Glider from Conway’s “Game of Life” as a “Universal Hacker Emblem”. I’m no hacker, but as he says, “hacker”: a title of honor that generally has to be [conferred by others]( rather than self-assumed.
  • New Job, No School!

    I’ve been working for over 6 years for large corporations, but last week I accepted a job offer to work at a much smaller company – I’ll be employee 6 (or 7, if you count the intern). I’m really excited, my family’s excited, my current co-workers keep telling me I’ll be missed, and my new co-workers can’t wait for me to start, so it’s a pretty good time. And just because that’s how life goes, I’ll also earn my B.S. in Computer Science after 10 years of full- and part-time study.

  • The New -Blue and Orange- Invisible Blocks

    Time for a new look! After reading about Nifty Corners, I decided it was time to go for that simpler, cleaner look I wanted. It’s still a bit bumpy, and I’m working things out slowly. If you see something amiss, or even if you love/hate the new look, feel free to let me know…

  • Software and Belief

    I spent some good time last week chasing down a bug in our J2EE app. It turned out that I was using the wrong session attribute name. Actually, I was using a correct name, because we store the same object in session twice, with different names (let’s just not talk about that), and in some situations, the attribute name I used hadn’t been populated yet. When I wrote my code, I thought I knew what the attribute name was (and I was sort of right), but I didn’t double-check.

  • Examples of DOM Hacking

    Finally! You can see a full-blown example of the techniques I’ve been discussing here (the code’s for IE only).

  • Practical Applications of Browser DOM Hacking

    I’ve been talking about hacking the browser’s DOM lately. Now, here are some situations where this might be useful – but I’ll only lightly cover them, and leave further exploration up to you. [Not because I’m trying to be clever and educational, but because Blogger strips out bunches of my HTML snips, even if I use escape chars. If you have any suggestions, I’m all ears.] Ok, practical applications of new knowledge, here we go!

  • Hacking the Browser's DOM for Fun

    Hacking the browser’s DOM is about traversing its structure, changing it around, and generating content. It’s the sexy half of Ajax – the part that changes the page before your very eyes! I won’t go into Ajax here, as there are other places that cover it far better than I can. Without Ajax’s other half, asynchronous HTTP, I’m not entirely sure how useful DOM hacking is, but it’s fun, and I’ve found at least a few good uses for it. YMMV – others on my team find it somewhat less attractive than I do. Along the way I’ll talk about function pointers, and throw in some recursion.

  • JavaScript OO and Function Pointers

    A few things converged nicely for me this week: function pointers in JavaScript, and hacking the browser’s DOM. I think I’ll talk about function pointers and JavaScript’s OO, and leave browser DOM hacking for the next post.

  • Talking about Software and the Nac Mac Feegle

    I was talking with a co-worker about how people imagine obstacles that aren’t really there. You ask them to do something perfectly reasonable, and they tell you it’s impossible, because of these imaginary obstacles. You have to first show them the obstacle isn’t there, and then things can proceed. “Oh,” I said, “it’s just like First Sight. Have you ever read the Wee Free Men?” This is a first for me – talking about software, communication, going from idea to implementation…and referencing a children’s book about small blue fighting Scotsmen known as the Nac Mac Feegle, or Wee Free Men. It’s one of Terry Pratchett’s Discworld novels.

  • Trying some agility

    I had an interesting conversation with a co-worker recently. We got to discussing a small project we were on back in January ‘05, that basically involved creating a small dynamic questioner. You configure the interview by creating questions, and each possible answer to the question leads to either another question, or an outcome. We modelled the interview as a directed acyclic graph (I know, you already knew about DAGs – the link is for the other readers). We built a test tool that traversed the DAG, and reported all possible paths. We even (this was pretty cool) built an importer that created interviews from FreeMind mind maps…basically made FreeMind our GUI. We did all this in about 3 weeks (Java and XSL, if anyone’s wondering). We had fun, and both our management and our customers loved it. It’s loads easier to change the questions now than it would’ve been if the questions were just hard-coded, the way everyone expected it to be done. I think we even beat the estimate for that approach.

  • Horray, The Vendor's code is improving!

    I’m happy to say the code is getting much better. This presents some new information to my thinking about off-shoring…

  • Outsourcing as Bargain-Basement Software

    Two trains of thought have been merging lately: the poor quality of the outsourced project I was working on, and “The Source Code is the Design” (see both the original article at developer.* and the XP Wiki page discussing it).

  • Getting ready for OOPSLA

    I have no idea what I’m in for, since this is my first conference. I signed up for two DesignFest sessions. I asked for the on-line image management problem and the teamwork software for children’s physical therapists…I only hope the groups I’m in are forgiving, because I expect I’ll be like that kid brother you used to let tag along. :shrug: We’ll see how it goes.

  • What Indians call the '@' symbol

    One of The Vendor’s guys-on-site just stopped by to ask me to email him some things. He just came onto the project, and I didn’t know his email address yet, so as I prepared the email, he dictated his address to me. As he spelled out each letter, I typed it in, until he said something that sounded just like “adder-oit”. I asked him to repeat it twice, and both times, it sounded just like “adder-oit”. Oh shit, I thought, maybe it’s one of those letters that has a weird translation, and he can’t remember what it is in English. Like ‘eegreck’ in French means the letter ‘y’. He realized I was confused, leaned over, and typed ‘@’.

  • Why do Americans tell themselves they'll survive off-shoring by being more creative than the rest of the world?

    I’ve been reading and thinking more and more about off-shoring. One thing that keeps coming up is the idea that Americans are generally more mentally flexible, or something. People talking about off-shoring say “yes, you’ll lose your mundane jobs, your grunt-work. But you’ll excel by being creative! That’s what Americans are good at!” Two pieces of the idea:

    • We value trouble-makers. People who say "screw off," and go do it their own way. Cowboys, mavericks, smart-alecks, rebels, scrappy little kids. Clever, resourceful people. Iconoclasts. Main benefit: we feel it's a Good Thing to charge off and try something, no matter how stupid the idea seems. We take risks, and sometimes that stupid idea pays off. Go figure.
    • We don't have a rigid class system. We believe, as a kind of core cultural value, that any poor bum with talent has a chance of using his talent to get rich. Call it the American dream. Main benefit: we believe that anyone can be rich/famous/president/CEO, so why not you? Why can't you be C-E-freakin'-O?
  • Help, I've been outsourced, and The Vendor's code is a mess!

    I’ve been working as tech. lead, going full-speed on a project since February. Last May, we learned it would be outsourced to The Vendor in India. Since my team has never outsourced anything before, we suddenly had to figure out how the whole thing would work (of course, there’s no extra time). We already did a decent amount of design work…would The Vendor repeat that work? Or would they work from what we provided them? How would they tie in to our build process? How about our internal services that use our own SOA framework? [We use proprietary, built-in-house frameworks for anything. We’re just now (yes, now) moving off our proprietary MVC framework to the latest, greatest, cutting-edge Struts 1.1 MVC framework. w00t!]

  • Building a Turing Machine out of Legos

    This looks like a worthy summer project. Too bad summer’s almost over…

  • Separation of concerns

    In some fun work-time conversation today, my friend Tom & I discussed Computerized Numerical Control (CNC) systems, and how they’re being used to turn 3D models of an object into physical sculptures. You can 3D-scan an object, tweak the model if you want, ship the digital file to one of these companies, and they ship you back a physical copy of it. There areother companies that similarly create resin sculptures from digital models.

  • Remove clutter, leave clarity

    I just heard from a friend & co-worker about a book called Why Business People Speak like Idiots, and a book Amazon offers with it, On Bullshit. These both sound pretty interesting. They remind me of, in no particular order, Orwell’s “On Polictics and the English Language”, Edward Tufte’s work, and Strunk’s Elements of Style: all efforts to remove clutter, and leave clarity. I think I’ll buy one and see for myself.

  • Hang on to that idea...

    I was talking with a co-worker today, an excellent developer, about how ideas fade, while the changes they cause remain.

  • Letting the ego get in the way

    One of Robert Glass’ Fallacies of Software Engineering is that “Programming can and should be egoless.” People think that ego gets in the way of writing good software – you need to be cool, calm, and collected. No room for ego here, thanks, we’re detached professionals. Glass, though, argues that ego is part of what makes a programmer good – it provides incentive, personal attachment, motivation. Your software reflects on you, so make it good. This is all fine, and makes some sense to me. However, I want to talk about another aspect of ego that I think is less discussed, and more of a problem.

  • Why do they think "doing it right" means taking longer?

    Often when I suggest a better way to do things, some kind of process improvement, people say, “I think that’s an excellent idea. Unfortunately, we’re on a very aggressive schedule. In a perfect world, I think your idea would be a wonderful way to do things, but we just don’t have the time now.” This is said about all kinds of reviews (requirements, design, and code), prototyping, usability testing, building strategically, unit testing…

  • "The interface IS the application"

    “The interface is the application.” You hear that a lot when someone’s trying to remind you to consider the end-user’s perspective. It’s a good reminder, too – to the user, the inner workings of your application are probably about as interesting as the inner workings of a warehouse. N-tier? Components? Who cares? At the end of the day, if people don’t use your software, is it really any good?

  • Keeping to the vision

    Maybe this echoes back to my days making music. I remember wondering whether a band needed to have a “leader,” a single member who wrote most of the words and music, and provided a psychological unity to the band. Gave it a personality.

  • Improving usability, and fighting the status quo

    Occasionally, when designing how software should work, the question comes up: the existing user interface or use case is bad, and we think we can improve it. Should we? A change for the better is still a change – does the benefit outweigh the pain of re-learning? Or, more pessimistically, the users are familiar with bad technology, so why bother making improvements?

  • Hackers and Painters

    I’m reading the book Hackers and Painters. In it, Paul Graham compares hackers (in the original sense of the word, not in the sense of people who break into things) to painters and other “makers” (composers, writers, etc). His point is that hacking is less precise, less calculated, than non-programmers probably think; that it’s more of a creative process, where a project can evolve as it progresses. [Contrast that with Zen and the Art of Motorcycle Maintenance: “It’s all of technology they can’t take…Sylvia’s irritation at a friend who thought computer programming was ‘creative’.”]

subscribe via RSS