Posts with keyword: programming


Automatically Run the KRL Parser When You Commit Code

Running the command line KRL parser is a pain. Better to have a Git hook do it for you.
Continue reading...


A Programming Model for the CloudOS

The CloudOS and the persistent data objects it runs on depend on a specific programming model. KRL is the only programming language that supports that model right now. This blog post discusses how we could expand the underlying rules engine to support running JavaScript programs on the CloudOS.
Continue reading...


Someone Clue Delta in About Transactional Integrity

Delta Airline's ticket kiosks apparently were designed and built by 1st year CS students using Visual Basic. I'm guessing that's the case based on the fact that they apparently have never heard that when you sell someone something, it's bad form to take their money and not deliver the product. They don't know that you should wrap such processes in transactions to ensure they're atomic. Someone needs to give them a clue. Last Friday on our way home from San Jose, Steve and I had the chance to get on an earlier flight for $50 each. I was checking
Continue reading...


Kynetx is Looking for a Part-Time Programmer

If you're a good developer, have always wanted to work on cutting edge stuff in a fun place, and are looking for part-time work, then Kynetx would like to talk to you. If you send me email, leave a comment on this post, or call, you will be ignored. If you come to Free Lunch Friday the day after tomorrow or next week, then you can get to know us and we can get to know you. Please RSVP to the plancast so we know you're coming. This position has the possibility of turning into fulltime employment and what
Continue reading...


KRL App A Day

Mike Grace, probably the most experienced KRL programmer and without a doubt the most prolific, has been doing a Kynetx App a Day and publishing them on a special blog. When he started we teased hik about doing the Twelve Days of Kynetx, but he's up to 33 now. Most of these are small useful little apps designed to teach a particular feature of KRL or technique for programming in KRL. Here's the list so far: Day 1--Basics and Notify Day 2--Dual Execution Environment part 1 Day 3--Web events and debugging Day 4--Explicit Events Day 5--MD5 and SHA1 hashing
Continue reading...


Building a Programming Layer for the Internet: Audio from Impact

We held our Impact conference for 2010 last April. There were a lot of great talks. Some of them we were able to capture and have published on IT Conversations. If you have yes listened to Steve Spencer, Joe Vito, Steve Gillmor, or Jon Udell, take some time and put them on your playlist. They are great talks with great messages. The audio from my talk from Impact wasn't quite good enough for IT Conversations--there were cutouts in some spots--so we didn't publish it there. I recently got around to cleaning it up and was going to publish it
Continue reading...


KRL Patterns: Building Event Intermediaries

Recently we somewhat quietly added a BIG new feature to KRL: explitic events. Using an explicit event, one rule can raise an event for another rule. Explicit events are raised in the rule postlude like so raise explicit event foo [for ] with fizz = "bazz" and fozz = 4 + x; If the optional for clause isn't given, the event is raised for the current ruleset, otherwise it's raised for the named ruleset. The with clause allows the developer to add event parameters to the explicit event. The right-hand side of the individual bindings in the with clause
Continue reading...


A Big, Programmable Event Loop in the Cloud

An event loop is a message dispatcher. The loop runs, waiting for events, and responding to them. This is how I've come to think of the Kynetx Network Service (KNS): a big, programmable event loop that runs in the cloud. We haven't always thought of KNS as an event loop, we used to think of it as a ruleset evaluation engine. These ruleset evaluations were tied to users visiting a page. We now view that as just one kind of event (a pageview event, to be specific). We also promoted some other events in the system (like Web clicks
Continue reading...


The Power of Late Binding

Lately the subject of late binding keeps coming up. In computer science the term refers to runtime resolution of what names mean and includes the concept of dynamic loading. Most of the languages that have gained favor over the last decade like Python and Ruby are late binding languages. Usually these languages also include other runtime resolution features like dynamic types. Raising the topic causes programmers to reach for their crusader sword and shield as they prepare for the religious battle that is sure to follow. Late binding is a big deal in many OO langauges because of the
Continue reading...


Things Every Programmer Should Know

This week on the Technometria Podcast, I interview Kevlin Henney, the editor of the book 97 Things Every Programmer Should Know. I really enjoyed reading this book and I enjoyed the conversation with Kevlin. One of the things that struck me is that there's so much wisdom here that we just don't teach people. Rather, we expect them to pick it up as they go along. I heartily recommend the book (and the podcast) to beginning programmers and old-hands alike. The book's Web page has copies of the contributions that made it into the book and also the one's
Continue reading...


UTOS Hackathon on April 24

Image by mindjuju via Flickr UTOS (Utah Open Source Foundation) is sponsoring a hackathon on April 24th. Here's Clint Savage's description: Concept is a coding barcamp. People show up to help or to present a coding project, new or existing, in 30 seconds. Everyone spends a bit of time getting organized (determining where each group will reside to hack), then the hacking begins. Breakfast, Lunch and Dinner are provided as well. There is also a Wiki page about the hackathon with more information. The hackathon is sponsored by XMission and Stackable.com. This sounds like it will be a fun
Continue reading...


Looping in KRL

One of the design goals of the Kynetx Rule Language (KRL) is to make it easy to use online data sources to augment the user's experience in the browser. Using interesting data implies some kind of iteration. KRL supports both implicit and explicit looping. Ths article discusses looping in KRL and how looping in a rule language like KRL differs from how you might use it in an imperative language. First, recognize that the ruleset itself is a loop. You should imagine the rulset as a big switch statement inside a loop that is executed over and over again
Continue reading...


Build 354: Control Statements in Postludes

This afternoon we releases Build 354 of KNS supporting the addition of a last control statement to postludes. In addition, we also now allow guard conditionals on any statement in a postlude. These are relatively minor additions to KRL in anticipation of some larger features that are coming soon. The use a last statement in a postlude will halt the execution of the ruleset at that rule if it is executed. So, the following statement would halt execution after the current rule if the rule fired: fired { last } This can be useful for rules that initiate action
Continue reading...


My Last Tweet...Powered by Kynetx

I've had a box on the right-hand side of this blog showing my lastest tweet. Today I realized that it would be better powered by Kynetx. I took a few minutes and wrote one up. You can see it on the right-hand side of this page. To do this, I used the Twitter API to grab my tweets and then replaced an empty div on my page with it. Since Kynetx rules run each time the page is loaded, it's constantly updated. The first step was to declare a datasource to read my tweets: global { datasource tweets I've
Continue reading...


Converting QIF Files to CSV

I haven't updated Quicken on my Mac since 2006. Yeah, I know, but it does what I want. The program is that my version of Quicken only export QIF format files and Quicken on Windows apparently hasn't supported importing those since 2005 or something. The problem was that I needed to get some information about my credit card account to my accountant. If you google around, you'll find people who sell programs that convert QIF files to Excel that they want real money for (like $60). Forget that. Especially when I've got Perl at my beck
Continue reading...


Registration Open for Kynetx Impact Conference

We've opened registration for Kynetx Impact 2009, our developer's conference. You can register here for the event. We've changed the dates to November 18-19th (I previously announced dates in October) to better fit with some other conference schedules. We're charging a small fee to cover food, but if that's problem for you contact me about a scholarship. Doc Searls will give the opening keynote and Craig Burton will give the closing keynote. Here is a list of topics we'll cover: Building Apps with KRL (Kynetx Rule Language) Advanced Rule Writing Introduction to Action & Information Cards Leveraging Data sets
Continue reading...


Programming Languages as a Notation

I was listening to Jon Udell's interview of Joan Peckham on computational thinking and the subject of whether a general education computational thinking course should include programming. I've thought a lot about this and have some strong opinions. Computational thinking will be, at its heart, a study of algorithms. That's what computer science is, after you strip away the blinking lights: algorithms. Teaching computational thinking will involve the elucidation of a set of skills that computer scientists use to solve problems that have usefulness in other domains as well. Each of those will involve some kind
Continue reading...


Posting on code.kynetx.com

As we get ready to launch a limited beta program for developers to use the Kynetx platform, one of the things I wanted to get going was a place to talk about Kynetx code. So we stood up code.kynetx.com. When it's all done, there will be documentation, forums, and examples. I've been making some posts on it even though the template isn't done. So far I've posted: New feature: CSS in Globals Updating the Runtime: Annotated Search Results KRL Templates I've been enjoying writing these because it gives me a chance to write about changes and features in one
Continue reading...


Cydni Tetro on Using Scrum

This weeks's Technometria podcast features Cydni Tetro. Cyd is with NextPage and recently took over responsibility for managing development in addition to her product management duties. We talked for a great deal of the interview about the use of Scrum and what works and what doesn't. Of course we also got in some discussion of Twitter.
Continue reading...


Seeing the Dynamic in the Static

Jeff Atwood opines on why many programmers are also musicians of some kind--or at least appreciate music. I've heard this said of mathematicians as well. I have long held that all of these disciplines hold in common the ability to relate the dynamic and the static. Good programmers can see how the program will operate by looking at a lexically scoped program listings. Musicians do the same thing with music (I'm not just talking about music notation, but that's part of it).
Continue reading...


A Retweeting Twitterbot in Perl

Image via CrunchBase I'm trying an experiment with this year's Utah legislative session, I've created a Twitter account (@utahpolitics) and set up an autofollower on it (hat tip to @jesse). I wanted to also set up a retweeting twitterbot so that people following the account would see what anyone else following the account said when it contained certain keywords. The world probably doesn't need yet another retweeter, but I couldn't find exactly what I was looking for and decided to build one for a few reasons: I like to program I want to understand the Twitter API more deeply
Continue reading...


Infrastructure Automation Increases Operational Efficiency

Last week Jeff Atwood wrote a piece about why throwing hardware at a problem makes sense in some situations. He's careful to avoid the trap of thinking that throwing hardware at a poorly designed program will do more than buy you a little time, but makes a good point: Clearly, hardware is cheap, and programmers are expensive. Whenever you're provided an opportunity to leverage that imbalance, it would be incredibly foolish not to. From Coding Horror: Hardware is Cheap, Programmers are ExpensiveReferenced Sat Dec 27 2008 15:42:36 GMT-0700 (MST) Riffing on that, Gordon Weakliem makes a related and somewhat
Continue reading...


Multi-Platform Add-On Lessons Learned

Words of advice from the multi-platform add-on session at AddOnCon: Start from the beginning to support multiple browsers by not using features that are specific to one or the other. Keep things like XPath expression standard Test IE add-ons on Vista and IE8 first--especially if you're going to use an external process. Using an external process in IE can greatly increase testability Modularity and code portability The learning curve for IE add-on development is steep. Once you're on top, it flattens out and gets easier. Crashing the browser is easy in IE and the opportunity for conflicts is high
Continue reading...


Breaking Some Ironclad Rules about Startups

Joel Spolsky Joel Spolsky and Jeff Atwood built Stackoverflow.com, a site for programmers to ask other programmers questions. If you haven't been over there, you ought to check it out. They have some very nice concepts for building a community site and it's nicely done. Joel and Jeff have been discussing programming, and the building of Stack Overflow on their weekly show on IT Conversations. In this article in Inc magazine, Joel talks about seven iron clad rules he has for starting a technology venture: Vet programmer carefully Put everyone in one office Plan use bug tracking Test software
Continue reading...


Being Lazy the Right Way

Mike Farmer takes on code generation in his blog and argues that frameworks are a better way to be lazy: Newbies can use them as a crutch instead of learning the language like they should. When things break or don't work the right way, they are stuck. Then come countless hours stepping through code that looks like it was written in greek trying to figure out what the problem is. Not my idea of a good time From Frameworks Over Code GeneratorsReferenced Sat Nov 01 2008 21:38:41 GMT-0600 (MDT)
Continue reading...


Stack Overflow and Cowbells

I just put up Episode 26 of Stack Overflow on IT Conversations. I've really enjoyed listening to Joel and Jeff over the last few months. And the Stack Overflow site is simply the best place to get answers to programming questions. From the show description: Joel and Jeff answer five listener questions, mostly about social software design. Warning: this podcast features cowbell. Really. From IT Conversations | StackOverflow | Episode 26 (Free Podcast)Referenced Wed Oct 15 2008 18:31:15 GMT-0600 (MDT)
Continue reading...


Visualizing Workflow and Transparent Systems

I thoroughly enjoyed Jon Udell's interview with Ward Cunningham on IT Conversations. They talk a lot about Ward's efforts at the Eclipse Foundation to build transparent workflow systems. That is, as Jon puts it: But what if you could find out, before pressing the Save button, what's going on in that black box? And what if your way of finding out wasn't by reading bogus documentation, but instead by probing the system itself using its own test framework? From Ward Cunningham's Visible Workings « Jon UdellReferenced Thu Mar 20 2008 08:42:43 GMT-0600 (MDT) You'll want to read Jon's description
Continue reading...


Marc Hedlund: Debugging Hacks, What They Never Taught You About Solving Hard Bugs

Marc Hedlund talks about debugging(click to enlarge) There's no doubt that debugging is a critical skill for anyone who codes. Marc Hedlund is talking about how to tackle the really difficult ones. I enjoyed Marc's tutorial from last year, and picked this one on that basis. Most bugs aren't hard. 95% of the time, you can find a fix easily and move on. Marc's tutorial is about what to do when the simple methods don't work anymore. He gives an example of a login that would fail once every 10,000 times or so. Turns out the problem was a
Continue reading...


On Static Types and Language Choice

I caught a little flack in response to my post calling attention to Steve Yegge's recent essay "Portrait of a Noob." In particular Levi thought I was out of line for endorsing something so inflammatory: "People who approach programming differently than I do are insecure n00bs" That's a great attitude for a professor to endorse in a public forum. Steve's rant is nothing more than hot air attempting to justify his personal preferences at the expense of others. It makes you feel good because his preferences are the same as yours. The fact remains, however, that there's no real
Continue reading...


Types as Comments

Steve Yegge is at it again. This time he's taking on modeling: Well, we also know that static types are just metadata. They're a specialized kind of comment targeted at two kinds of readers: programmers and compilers. Static types tell a story about the computation, presumably to help both reader groups understand the intent of the program. But the static types can be thrown away at runtime, because in the end they're just stylized comments. They're like pedigree paperwork: it might make a certain insecure personality type happier about their dog, but the dog certainly doesn't care. If static
Continue reading...


Unit Testing in Scheme

I put together a mini-lecture on unit testing in Scheme for my CS330 class. It's not a complete introduction, just a tutorial on getting started. If you have suggestions on using SchemeUnit, I'd love to hear them. Students in CS330 submit their assignments to an autograder. They sometimes try to use the autograder as a test harness with bad results. I think there are some distinct advantages to students using unit testing in preparing their assignments: Unit tests separate tests from the code. It's cleaner and easier to manage. They can write tests before they code. This forces them
Continue reading...


Starting a High Tech Business: The Rude Dog Demo and Working Code

I’m starting a new business called Kynetx. As I go through some of the things I do, I’m planning to blog them. The whole series will be here. This is the eighth installment. You may find my efforts instructive. Or you may know a better way—if so, please let me know! I have a friend who has a way with words and has started his share of high-tech businesses. I asked him his advice on getting started and Dan said "Welp, you gotta get yourself a rude dog demo!" What he meant is that you can't just start a
Continue reading...


Arc Is Released

Paul Graham has released Arc, his new language. Arc is still a work in progress. We've done little more than take a snapshot of the code and put it online. I spent a fews days cleaning up inconsistencies, but it's still in the semi-finished state most software is, full of hacks and note-to-self comments about fixing them. From Arc's OutReferenced Wed Jan 30 2008 16:21:31 GMT-0700 (MST) Paul mentions Arc in a number of his essays: The Hundred-Year Language http://www.paulgraham.com/noop.html http://www.paulgraham.com/progbot.html Some Work on Arc Arc Paul wrote HackerNews in Arc as a "big project" to shake out the
Continue reading...


Perl Testing

I didn't grow up in an era where testing was as well though of as it is now. When I learned to program, you ran a few tests after the fact and threw it over the wall to the QA department. Not very politically correct in today's software engineering world. As a result, I understand the value of testing and support the idea intellectually, but I don't have the discipline. Recently I was faced with the problem of building code that translated a domain specific language (KRL) back and forth between three different representations: The textual representation is what
Continue reading...


Scheme and Ruby

Duane Johnson pointed me to a very interesting discussion on Y Combinator about the differences between Scheme and Ruby. This is an excellent discussion--not a flame war--that I found enlightening. The summary, if you don't want to read the discussion thread: Ruby closures are more complex Macros, macros, macros... Can't say enough about macros. Every language besides Lisp and it's close relatives trade macros for complex syntax. Maybe that's a good trade-off, maybe not. Nevertheless, it is a trade-off. You can't have the full power of macros without simple (abstract) syntax that's exposed to the programmer. Now, that I've
Continue reading...


Starting a High Tech Business: Choosing a Deployment Model

I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the fifth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Jason Fried at 37Signals has an excellent list of all the reasons they don't sell installable software. That inspired Joel Spolsky to write about gnarly programs. Interestingly, I know people with the exact opposite response as Jason: "Boy, I wish we just sold
Continue reading...


Domain Specific Languages

Recently, I've been designing a domain specific language for Kynetx, the start-up I'm working on. When you tell someone you're designing a language, the usual reaction is incredulity. "Why would you design your own language?!?!" they say. I'm here to tell you why. First, let me say that I'm a big believer in notation. Using the right notation to describe and think about a problem is a powerful tool--one that we're too eager to give up it seems. People seem to believe that (a) all languages are pretty much the same and (b) the world has enough notations. While
Continue reading...


User Expectations Are Out of Control

This is great essay from Raganwald on what users expect and IT fails to deliver. Hyperbole? Sure, but that makes it funny and just like antiseptic, the sting let's you know it's working.
Continue reading...


An Accidental Simula User

Luca Cardelli is one of the big guns in programming language theory--consistently producing interesting and important results over several decades. His paper (with Peter Wagner) "On Understanding Types, Data Abstraction, and Polymorphism" which I read as a graduate student deeply influenced me. Cardelli is now at Microsoft Research. He has recent slides (from ECOOP 2007) about his journey into the theory of objects called An Accidental Simula User that are a good read for anyone interested in object-oriented programming. Here's the abstract: It was a simple choice, really, on an IBM 370 in the 70's, between APL, Fortran, Lisp
Continue reading...


Perl Web Framework Recommendations

Does anyone have recommendations on a Perl Web framework? I've heard of Catalyst and not much else. A few things make me leery: the blog is infrequently updated and the last release of the code was November of 2006. I know there are other frameworks (I vaguely remember attending a talk at OSCON) but I don't know anything about them.
Continue reading...


Java Framework Round-Up

Matt Raible of Raible Designs gave this morning's keynote presentation comparing Java Web frameworks (slide - PDF). Matt started off with an overview of the pros and cons of each framework, as he saw them. Java Server Faces or JSF is the Java EE standard. Lots of demand and lots of jobs working with JSF. Initially, its fast and easy to develop with. There are a lot of tools and component libraries are plentiful. The bad news: Tag soup for JSPs--the pages are lots of anything but HTML. JSF doesn't do REST-style Web services well and security can be
Continue reading...


Adobe Open-sources Flex

Yawn... I'm not sure what the excitement is all about.
Continue reading...


Speeding Up Crypt::DH

I was installing Crypt::DH, the Perl Diffie-Hellman library today. The tests took 20 minutes on a Macbook Pro. Then I noticed a comment on an OpenID forum about "making sure the GMP Perl bindings were enabled" to speed things up. Specifically this means install Math::BigInt::GMP, as I found out, after some searching. The same tests ran in less than 10 seconds using the GMP library. That's impressive.
Continue reading...


Is Your API Too Fat?

Kode Vicious offers a nice, short tutorial on API design in this month's ACM Queue. Getting the right balance is never easy. I face this question all the time with students in my large scale distributed computing class. KV holds up the UNIX API set for file manipulation as the classic example of good API design: The classic, and perhaps now cliché, example of a good API is the Unix open, close, read, write, ioctl set of system calls for performing file I/O. Unix cheated, in a way, by saying that all files were just streams of bytes without
Continue reading...


Miguel on Mono

In this week's Technometria podcast, Scott, Ben, and I talk with Miguel de Icaza, the founder and force behind the Mono project. We had a great discussion about the project's history, purpose, and architecture. We also got into some discussion of programming languages in general. I think you'll enjoy it. One program note: Matt Asay, who has been a co-host on Technometria for many months has had to pull back on his involvement. Ben Galbraith, a good friend and great technologist, has joined Scott and I in our weekly show.
Continue reading...


Java and IP Addresses

A few weeks ago, I cut over my blog and several other Web sites to a new, much fast server. I don't know that it's made much difference in how fast people retrieve my blog since it's mostly static, but it's made a great deal of difference to me in posting speed and other back office functions. What's been curious to me is that the old server continues to get a few hits. I did a little exploring today and discovered a few interesting things. First, all of the hits are for RSS feeds of one kind of another.
Continue reading...


Cleaning Up Unwanted Files in Linux

One of my grad students just went to remove some unwanted, automatically created files in his directory and accidentally deleted some things he wanted. I use a script to do clean ups to prevent these kinds of silly errors (which we're all prone to). Here's the script: #!/bin/bash if [ ! -e $HOME/.rmd ] then mkdir $HOME/.rmd fi find $HOME \\( -name '.rmd' -prune \\) -o \\ \\( -name '*~' \\ -o -name ',*' \\ -o -name '#*#' \\ -o -name '*.bak'\\ -o -name '*.backup' -atime +5\\ -o -name 'core'\\ \\) \\ -print -exec mv -f {} $HOME/.rmd \\;
Continue reading...


Would You Like to Update Now?

This morning Michael Sullivan of Booz Allen Hamilton was speaking about bar codes and his computer flashed a "Would you like to update..." message. I had to laugh at the inappropriateness of the message in the context. Vista is supposed to be smarter about knowing that you're giving a presentation and not interrupting, but in truth there's almost no context where I want to be interrupted to answer that question. Of course, systems need to be updated and without reminders, we're unlikely to remember. What I really want is an interface to my todo system so that such tasks
Continue reading...


Rentals on Rails

Cid Dennis, an old friend from the iMall days--and one of the best programmers I know--has built his first Rails application: RentSpider, a rental property listing service. Go Cid!
Continue reading...


Building Newsletters for IT Conversations

I was a little late getting this week's IT Conversations newsletter out because I was trying to finish my tool for building the newsletter. I like building tools because they help me leverage my time. The newsletter tool is written in Perl. It downloads and parses two different RSS feeds and a zipped CSV file with ratings data. I only want items in the two RSS feeds that haven't been seen before so I have to have a persistent hash to remember the GUIDs of previously seen items. The tool also sorts the shows using the ratings data (which
Continue reading...


On the Importance of Names

Phil Hagelberg of Technomancy references the essay on Confucianism and Technical standards with this quote: In a famous passage, Analects 13.3, Confucius was asked by a disciple what his first order of business would be if he were to govern a state. He replied, 正名, meaning roughly "make right the names," "insure that names are used properly," or "rectify the names." His disciple was somewhat incredulous and asked, "Would you be as impractical as that?" Confucius strongly rebuked his disciple and explained that proper nomenclature is the basis of language and that language is central to taking care of
Continue reading...


Top Ten IT Conversations Shows for January 2007

Here are the top ten most listened to shows on IT Conversations for January 2007: Who Owns "You"? - Supernova2006 John Seely Brown - Supernova 2005 Peter Navarro - Tech Nation Curt Carlson - Tech Nation David Platt - Why Software Sucks Chip Heath - Tech Nation Gary Lang - Opening the Possibilities: APIs and Open Source Code Sudoku, Biorobotics & Aeronautical Genius - IEEE Spectrum Radio Dr. Pauline Mele - BioTech Nation Kelly Phillipps - New Technology In Enterprises Today was the first time I've used my new Perl script to generate this list. Up until now, I
Continue reading...


Bosworth on Physics, Psychology, and Software

Adam Bosworth almost always makes me think, so I jump at a chance to listen to him or read what he writes. He recently gave a talk in NYC as part of the Google Speaker Series and Darryl Taft wrote up a report at eWeek. Bosworth talked about how physics and psychology affect which applications fail and which succeed. His examples: AJAX, PDAs, and natural language recognition. His recommendations: Keep it simple and stupid--even if that requires more clicks Use AJAX where it makes a difference--not just the geewhiz factor Make your tools transparent and fast Support bottom-up learning
Continue reading...


January CTO Breakfast Report

We talked about the recent SHA-1 hack and the MD5 exploits that are available. Lockcrack (a password cracking program) apparently has a table of pre computed hashes now installed that make cracking many hashes a job of just a few seconds. There's a pattern in some technology start-ups where there's a brilliant technologist who has an idea that many others can't quite understand. They attract some money and generate a lot of hype on the basis of their brilliance, but eventually fail because they can't explain what they do. We got into a discussion of phones and convergence. Richard
Continue reading...


Building Living Software

Steve Yegge rants, in reference to software design, that crap is still crap, no matter how many rubies you swallowed. If software design interests you, then you'll enjoy this--even if you don't agree. As I was reading this, I was reminded several times about Scott Rosenberg's article on Charles Simonyi, Anything You Can Do, I Can Do Meta. Simonyi, who was the force behind Office at Microsoft and arguably the richest programmer in the world, is hot on the heels of a programming methodology he calls "intentional programming" and has a company to develop it Intentional Software. The basic
Continue reading...


Why Software Sucks, the Podcast

I just published the podcast version of Why Software Sucks on IT Conversations. The interview is part of the Technometria series with David Platt, author of the book. Here's the description of the show: What is the most important thing to the average computer user? They want their machine to "just work". Why does Google know how to correctly translate a United Parcel Service tracking number, while the actual UPS website requires multiple entries just to get to the point where the tracking number can be entered? Programmer David Platt is the author of "Why Software Sucks...and What You
Continue reading...


Teaching Yourself to Program

This article from Peter Norvig on teaching yourself to program in 10 years has been around for a while, but it's still worth reading. The basic points? Get interested in programming, pick an interactive language, and do it--for a long time.
Continue reading...


What's Your Interface?

Steve Yegge is a great writer. The latest from Stevie's Blog Rants proves it. Take 15 minutes and read it.
Continue reading...


Composition as a Programming Activity

When I started programming, you had four choices on the IBM 370 system that the University of Idaho made available to students: Cobol, Fortran, Basic, and APL. I learned Fortran and Basic, avoided Cobol because it was for "business", and looked on APL with wide-eyed wonder. "Someday," I thought, "when I'm all grown up, I'll learn APL." Well, of course, that day never came (I never grew up and I never learned APL). I'd kind of thought APL was dead--after all, you don't hear about it much. People refer, jokingly, to APL as a "write-only" language because it's very
Continue reading...


Integrating Mantis and Subversion

Tom Gregory has a nice tutorial on integrating Subversion and Mantis so that, for example, Mantis tickets can be automatically closed when a fix is committed to the repository. Frankly, I'd never even considered this. Good stuff and well written.
Continue reading...


And Now...Scheme in Haskell

AS a followup to my post last week about building a Lisp interpreter in Haskell, here's a similar, albeit more in-depth, tutorial that shows how to implement a good-sized subset of R5RS Scheme in Haskell.
Continue reading...


A Lisp Interpreter in Haskell

Defmacro.org has an excellent little article on using Haskell to build a working Lisp interpreter--at least a good start at one. I do something similar with my 330 class using Gofer (an outdated dialect related to Haskell). I mostly use Gofer to show them how type inference works, but since they're studying interpreters, they might as well see an inerpreter in Gofer while we're at it. It's been too long since I've known monads well enough to decipher what he does at the end. I'm going to have to go back and review and then look at his article
Continue reading...


Rails Demo

I put together a Rails Demo for my class that shows them how Rails could be used to do part of what they're doing in one assignment with J2EE. I plan to run through the entire demo Monday in class.
Continue reading...


Ruby and Unicode

Kevin Tew and Devlin Daley, two of my students went over to RubyCon last week. When I asked them how it was, they said the usual things people say about a conference, but they only mentioned one presenter by name: Tim Bray. Tim gave a talk on unicode, internationalization, and multilingual issues in Ruby. He has a post on his blog that talks about those same issues and includes some of the slides from his talk. This is one of those topics that makes most programmers eyes glaze over because it's not all that sexy and it's pretty hard
Continue reading...


Matz Talk on Ruby Design Principles

Last week, Matz, the chief designer and creator of the Ruby programming language stopped by BYU on his way to RubyCon. I was fortunate to go to lunch with him and capture the colloquium talk he gave. I've posted his talk on IT Conversations. I'm still working on getting slides to post. Update: Slides from Matz's talk are available.
Continue reading...


Emacs and Ruby

Jao at Programming Musings linked my my post on tools with a nice article on using powerful editors. Jao's post included a link to a screencast on using emacs and ruby by Marshall Vandegrift. I've been using emacs for 20 years, but I learned a lot of useful little tricks. Vandegrift has a post giving links to the various packages he uses in the screencast. Here's the ones I found interesting. One of the things I've always liked about TextMate is its signature directory listing on the left hand side and the ease with which that allows you to
Continue reading...


Ralph Griswold Dies

I learned the Icon programming language as a grad student at UC Davis. Ron Olsen, then a new assistant professor had just gotten his Ph.D. from Arizona where Ralph Griswold, Icon's inventor taught and he brought it with him. Icon has a number of interesting programming language features. Griswold was also the inventor of SNOBOL. He died a few weeks ago. Computer Science has always been a discipline where the founders were still around. That's changing.
Continue reading...


The Most Important Language in 2006: JavaScript

You gotta love Steve Yegge's blog. One of his latest posts is called Dreaming in a Browser Swamp. Steve's style is to write infrequent, long posts, but they are always worth the wait and the read. "Browser Swamp" makes the outrageous claim that JavaScript is the most important language in the world today. A claim that surely going to get some argument (language wars are so much fun) but one which is grounded in some solid rationale. Note that Steve didn't say that it's the best language, only that it's the most important.
Continue reading...


HTML to Kwiki Markup Conversion

I use Kwiki for lecture notes, homework and other Web pages I need to teach my class. Here's an example: the lectures for my programming language design class. Today I needed to convert some old pages (embedded in PHP) for use on the wiki. I did one by hand and thought that I ought to write a Perl program to convert the HTML to Kwiki mark-up. Then I got smart and realized someone must have already done it--I was right. David Iberri has a HTML to Kwiki module for Perl that with a little scaffolding did the job nicely:
Continue reading...


On the Acceptability of Lisp

Steve Yegge has a post that I just stumbled across on why Lisp isn't an acceptable Lisp. He hits on some great points, many of which numberless concourses of Lisp programmers would argue with him endlessly on. Nevertheless, good reading. His points: Which Lisp? Worthless Spec CLOS Macros Type System
Continue reading...


Building Cars With Small Teams

Ariel Atom front view(click to enlarge) This video about the Ariel Atom is fun to watch. This would be a great car to drive. The best quote from the video: "anyone who wants to know what a car should be should drive one of these." The reason I mention it here, however, is that the Atom is built by a small team of seven people. It's easy to see how a small team can develop software, but the conventional wisdom is that to manufacture something like a car you have to have a big organization. I chose the word "manufacture"
Continue reading...


On The Virtues of Functional Abstraction

Joel Spolsky, who I interviewed for IT Conversations last year is talking about virtues of first-class functions and their positive impact on functional abstraction. Ok. I hope you're convinced, by now, that programming languages with first-class functions let you find more opportunities for abstraction, which means your code is smaller, tighter, more reusable, and more scalable. Lots of Google applications use MapReduce and they all benefit whenever someone optimizes it or fixes bugs. From Joel on SoftwareReferenced Mon Aug 07 2006 14:36:35 GMT-0600 (MDT) When I make students learn Scheme in CS330, it's often the first language they've used
Continue reading...


Building Tools for Personal Productivity

Peter Bowen wrote about system administration and procrastination. His particular problem was with Nagios, but we've all been there from time to time. When I became Executive Producer of IT Conversations I tried to spend the time necessary to build tools to help me automate the work wherever possible. For example, the newsletter that goes out each week is mostly generated from RSS feeds using a MovableType template and then has the ratings integrated using a Perl script. Took me an hour or two to put together but it saves me precious minutes each week when I create the
Continue reading...


More Less Is More

If you think Jason Fried was just some geek who doesn't know what he's talking about when he says Less is More, be sure to listen to Moira Gunn's interview with Cheskin CEO Darrel Rhea where he specifically talks about how compulsively adding features to products doesn't lead to customer satisfaction. You may not be able to please everyone--get over it.
Continue reading...


Practical Common Lisp

I just published an interview with Peter Seibel at IT Conversations. I did this interview as part of my Technometria podcast. I saw Peter's book, Practical Common Lisp, in the bookstore a while back and picked it up. Now, I'm a Lisp fan, so he didn't have to sell me on the language. Even so, as someone who sees a lot of programming language books, I was impressed with this one and read it cover to cover. Peter and I talk about his background, how he came to Lisp, some of Lisp's most powerful features (like macros, CLOS, and
Continue reading...


Evolving Software

Jon Udell's latest column at InfoWorld is a scary story that's all too common: fork-lift upgrades of Web-based software that leaves users worse-off than before. I've been consulting with a company that's developing a Web-based product for the last five or six months. The back-end is, realistically, quite complex and involves a fair amount of ontological work. I've suggested a release strategy that gets a timely and useful piece of the product out soon and then adds functionality little-by-little, every week or so, over the coming months. You'd be surprise by the amount of resistance that sort of idea
Continue reading...


Less is More

Jason Fried is the CEO of 37 Signals, a company that's garnered attention for delivering great Web-based tools like Basecamp and Writeboard. I've used these in my lab at BYU to great effect. At IT Conversations, however, we found that they just weren't right for the project management tasks we had. Obviously, these tools aren't right for everyone and that's the story. In one of the IT Conversation shows I really liked last week, Jason delivers a short (12 min) talk from Web 2.0 called "Less is More." In the talk, Jason talks about how to win by "under-doing"
Continue reading...


Learning CSS

A friend of mine is learning CSS. Like me, his standard MO when learning something new is to just look at the source and start playing around until you get it right. Mostly that works for CSS, but I found that there were some subtle points that I didn't just pick up and having a book helped. Here were two I found very useful: The Zen of CSS Design : Visual Enlightenment for the Web (Voices That Matter) by Dave Shea and Molly E. Holzschlag, based on the CSS Zen Garden, was not necessarily useful for learning CSS (although
Continue reading...


It's Not 500 Channels Stupid

I remember reading an article in 1996 about "what is the Internet and what does it mean to me?" in one of those airline magazines that are always sitting in the seat pocket when you get on a plane. The bottom line of the article was that the Internet would bring 500 TV channels into every home. I remember thinking that this poor author just didn't get it. The Internet would bring millions of channels into our homes. I used to try to characterize this as a everyone as a media creator, but that didn't really capture it. Now
Continue reading...


Effective Scheming

I received an email from a former student who's caught the Scheme bug. He says: I took 330 from you last year and I really enjoy coding in Scheme. I do any class project I can in Scheme -- even my Python code is riddled with lambda statements. I have two questions I was hoping you could help me with What are the prospects for kids who like coding in Scheme/Lisp, and how does one locate/maximize those prospects? What are some key things I could do to become a really great Scheme/Lisp coder? That is, what are some concepts
Continue reading...


Getting Real

Last year at ETech (see you next week, BTW), I wrote about Jason Fried's talk on lessons learned building Basecamp, the online project management system from 37Signals. The talk was interesting and full of wisdom on how to build Web applications. now the folks at 37Signals have come out with suggestions in bookform, called Getting Real. The book is only available as a PDF. There are some sample chapters online, including one called Meetings Are Toxic (PDF). I've got a copy; there's some good stuff there.
Continue reading...


IT Conversations Is Branching Out

My favorite podcast network, IT Conversations, is growing up and becoming The Conversations Network (TCN). IT Conversations will be one of, eventually, many channels in TCN. Doug Kaye discusses the logic behind this move and it's implications on his blog. Good luck to Doug on this new move--his efforts to build IT Conversations have changed how I get information and enriched my life. I'm grateful.
Continue reading...


Programming Head Shakers

If you're not reading The Daily WTF and you program, you really ought to give it a spot in your attention stream. Today's entry is a classic: using a termporary file instead of sprintf. The comments are pretty good as well, dissecting the code and pointing out all kinds of style programs. A humorous way to learn from bad examples.
Continue reading...