(So, in reality, D probably isn’t all that little, but here’s to it making it up the mountain.)

A good while ago I wrote a post about my hope for the D programming language as an up-and-comer in systems and embedded programming. D promises to bring a number of modern language concepts and constructs to low-level systems while yet producing a fairly efficient runtime. It’s 3 years on since my original post, but I’m still hopeful.

Just a few days ago a comment came in on my original post. My friend Mark VanderVoord responded in that comment thread. I thought I’d make the content of the thread a bit more visible (below) as it’s concerned with using D in the real world.

There’s been respectable progress toward D becoming viable in the mainstream. I’ll venture a guess that it’s going to be several more years until it truly is.

Update (7/1/2010): We don’t often attract a great many comments on our posts. But we have here. I point it out because there’s good resources, background, and perspective on D in the comments. Take a read. The original comment thread that sparked this post can still be found beneath this update.

1. Steve Klabnik pointed out a new kernel project written in D (Steve is one of the authors)
2. Kevin Bowling recommends the book The D Programming Language written by another of our commenters Andrei Alexandrescu
3. Descent is an Eclipse plugin for D
4. Several have compared/contrasted D to the new Go programming language by Google

Update (7/6/2010): Commenter devdanke suggested Apple as a D corporate backer. Google seems to be pursuing Go; why not Apple getting behind D? Apple certainly has a lot invested in LLVM of late. Apple may just be up to something—though I’m doubtful it’s D. Time will tell…

slide Says:
June 25th, 2010 at 07:35 PM

Is there any active development that you know of to get D running on embedded, bare-metal type platforms?

Mark Says:
June 25th, 2010 at 11:01 PM

slide:

This is the current state of things as far as I know:

The official D versions (D1 and D2) by Digital Mars (DMD) are only x86 so far

GDC – this is a D front-end with a gcc backend. Theoretically this means you can target anything gcc can (which is almost everything). The work I’ve done with it (mostly ARM) has been pretty tricky to get working, though.

LDC – this is a D front-end to LLVM. Again, this means you should be able to target anything LLVM can. LLVM has a lot of momentum lately… and this port seems to be pretty active too. I have done some small experiments with getting it to target an ARM9. It seemed to work well. I hope to have more time to work on that in the future.

For either LDC or GDC, you’re getting D version 1, which is missing some of the new (in-progress) features. But, they’re more stable, so that’s nice.

D links easily to C, so bringing in libraries, RTOS’s etc is pretty easy.

I hope this helps.

Mark

When asked what sports they play, most high school students typically respond “football,” “baseball,” “basketball,” or “soccer.” I, however, get to respond with something much more interesting: “robotics.”

The sport I am referring to is the FIRST Robotics Competition, a high school level competitive robot building competition. Teams from around the world, 1,808 to be exact, compete against each other every year in a world wide challenge that culminates at the Championship held in Atlanta, Georgia.

I first started competing with the only FRC team in Grand Rapids, Creston High School’s robotics team, but eventually several members and I began looking into forming our own team closer to where we lived. In late October of 2009, those of us who lived in the Forest Hills, Ada, and Cascade areas of Grand Rapids decided to form the COMETS (Creating Outstanding Minds Embracing Technology and Science) only a couple months before the 2010 season began.

This year our challenge was to build a robot that could play a game called Breakaway basically a mixture of soccer and steeplechase, where robots competed against other robots in games of three vs. three. With the help of many local area sponsors, and great mentors (local engineers, programmers, and businessmen who guide team members in their efforts), we were able to build a highly competitive robot in the six weeks we were given. In fact, we won the West Michigan District event, placed 20th in the state, and won our division in the Championship. Not too bad for a rookie team.

But the most important part of the season was definitely not our win/loss record. It was the fact that students learned new skills in CAD and metal fabrication, programming, web design, 3D animation, and marketing. Just as important is the fact that students experienced how much fun science and technology can be, and built partnerships throughout our community (in fact, it was through Atomic’s sponsorship of local area teams that I first became aware of their internship program).

However, it’s easy to say that in retrospect.

In the three years that I have been involved with robotics, I’ve had seasons where the team has lost almost every single match, as well as seasons (recently) where we did incredibly well. But in all honesty, I only remember a handful of matches we played. What I do remember is the important stuff.

For example, I remember how in 2008 I scoured the Internet and Home Depot to find a material that would trigger the robot’s photoeyes when our ‘bot’s elevator passed them. I remember in 2009 when the FRC switched from a PIC based microprocessor to the powerPC based cRIO from National Instruments, and how I had to learn a new, object oriented language that came with it. I also remember how this year the other programmers and I wrote multi-threaded Java software so our robot could efficiently manage user input and a live camera feed.

The FRC creates an environment where being interested in science and technology is alright. That environment then goes on to encourage problem solving, creativity, and a strong team spirit. For me, this environment gives me an outlet where I can learn and create with people who have the same interests as I do. I could go on, but I think that you get the idea: this robotics competition is actually much more than just a sport.

I always have a shell open. Most of my daily project navigation and file-system work is done in Bash. If I can do something with a GUI or a terminal, I’ll prefer the terminal. I’m a polyglot programmer who often uses Windows, Linux, and Mac OS X all in the same day. There’s a tool I need whenever I work on the command-line: Working Directory.

Here’s a scenario:

Your project uses Java and Maven. That means the first useful bits of your code are buried somewhere like this:

/Users/capt.picard/work/FooFoo/src/main/java/org/foo

So you start out a new shell in your home directory and navigate all the way down there:

1
2
3
4

/Users/capt.picard$ cd work
/Users/capt.picard/work$ cd FooFoo
/Users/capt.picard/work/FooFoo$ cd src/main/java/org/foo
/Users/capt.picard/work/FooFoo/src/main/java/org/foo$

Whew! Maybe not a big deal once, but I hope you don’t have to do this every day! Fortunately you have command-line completion, cutting down on all that typing:

1
2

/Users/capt.picard$ cd wo[TAB]/Foo[TAB]/s[TAB]/m[TAB]/j[TAB][TAB][TAB]
/Users/capt.picard/work/FooFoo/src/main/java/org/foo$

Wait, what? That’s still a lot of typing! This is much quicker for users of Working Directory:

1
2

/Users/capt.picard$ wd
/Users/capt.picard/work/FooFoo/src/main/java/org/foo$

That’s it! Let’s see how that magic works.

Whenever you start a new project or workspace, just tell Working Directory (or just “wd”) that you want to make a new scheme:

/Users/capt.picard$ wdscheme foofoo

This creates a set of 10 slots associated with that scheme and copies in the contents of your previous scheme. (If you don’t need a clone of the previous scheme, you can clear those out with wdc.) Now you simply navigate to your project root, or wherever you most commonly need to start when you work on that project, using regular cd and all the tab-completions you can tolerate. Once there, you can store that directory in the default slot like this:

/Users/capt.picard/work/FooFoo/src/main/java/org/foo$ wds

If you then look at the list of slot assignments with wdl, you’ll see that you’ve stored the current directory in the 0th slot:

1
2
3
4
5
6
7
8
9
10
11

/Users/capt.picard$ wdl
0 /Users/capt.picard/work/FooFoo/src/main/java/org/foo
1
2
3
4
5
6
7
8
9

The first slot is special—you can access it without specifying a number at all. Just type wd to navigate to that slot and wds to set it to the current directory. The remaining slots require their number to retrieve or store. If you want to store the directory that holds your project tests in slot 3:

1
2
3
4
5
6
7
8
9
10
11
12
13

/Users/capt.picard$ cd work/FooFoo/src/test/java
/Users/capt.picard/work/FooFoo/src/test/java$ wds3
/Users/capt.picard/work/FooFoo/src/test/java$ wdl
0 /Users/capt.picard/work/FooFoo/src/main/java/org/foo
1
2
3 /Users/capt.picard/work/FooFoo/src/test/java
4
5
6
7
8
9

Now you can quickly navigate between source and test on the command-line:

1
2
3
4

/Users/capt.picard$ wd
/Users/capt.picard/work/FooFoo/src/main/java/org/foo$ wd3
/Users/capt.picard/work/FooFoo/src/test/java$ wd
/Users/capt.picard/work/FooFoo/src/main/java/org/foo$

You can have as many schemes as you want, but each scheme only stores 10 directories. This allows for maximum accessibility on the command-line with single-word aliases for going to or storing into each slot.

Working Directory has many other features that you may start to use over time:

• wdenv stores the current scheme into similarily-named environment variables for easy use on the command-line for any purpose, like cp.
• Storing directories in slots doesn’t require that you be in the directory. Just give a directory as a parameter to wds[0-9] and it will store it instead of the current directory.
• wd is cross-platform, written in Bash and Perl. I’ve used it heavily over the years on Windows+cygwin, Linux, OS X, and Solaris.
• wd provides a bash-completion function for its schemes. wdscheme [TAB][TAB] will list of all of your existing schemes.
• Since wd stores schemes and slots on disk, all of your terminals will share the same scheme, so there’s no need to set the scheme every session. Storing a directory from one terminal makes it available in any other terminal.
• You can also temporarily override the working scheme in a particular shell by just setting the value of the environment variable WDSCHEME. If this variable is set, it’s used instead of the current scheme on disk.

Working Directory has been available for some years and gets constant daily use by its small community. Most people who’ve started using it never stop! Lately you can fetch the source from github or download the latest stable release directly from the project’s Downloads area.

I am a student at Grand Valley State University, and I have the privilege of interning at Atomic Object this summer. AO has a good relationship with the school, and I had heard quite a bit about the company. When I was looking for an internship in the summer, I placed AO at the top of my list for local companies, but I secretly hoped that I could get accepted to a bigger corporation. Motorola labs scaled back their internship program and my interview with Apple never materialized into a job. Fortunately, Atomic was willing to invest in me this summer. After 4 weeks, I am glad that the other companies turned me down.

Agile is people-centric. On my first day, when the employees welcomed me at the standup meeting, the focus on relationships was evident. The office is free of cubicles and open to everyone. This creates an atmosphere where ideas are easily transferable and people are free to communicate. I was pleased to attend an Atomic Spin Down, where the employees and their families enjoyed a Friday night at the office socializing and playing Rock Band. The employees clearly love their job and working with each other.

The care for the individual continues with Atomic’s clients. It is evident that AO works hard to make sure the clients’ projects succeed. On my second day at work, I was able to participate in a Research, Design, and Planning session where we analyzed the potential users of an application. The client arrived to the meeting with their ideas already formulated for the application. After a little bit of prodding, they were excitedly creating personas of the users. When they left, all parties involved had a deeper understanding of the application. Instead of working with stacks of requirements, AO seeks to understand people.

Agile is test-driven. I have to admit that when I first saw test-driven development, I was a little skeptical. The tests seemed really narrow in scope and I thought you had to write twice as much code. I am still learning a lot about testing, but I definitely appreciate a full suite of tests double-checking our code. Programmers like to trick themselves into believing that they never make mistakes and can always remember what every method does. In reality, we are not perfect. Writing test may take a little more initial investment, but it reduces time tracking down bugs. My current project has made major changes mid-stride. Refactoring code is usually an arduous task, but the tests ease the process.

I have soaked up a ton of information in 4 weeks, and I hope to continue learning across the remainder of the summer. If you are looking to learn more about agile practices, I recommend reading some of the books I have read this past month.

• The Pragmatic Programmer
• Extreme Programming Explained

Elvis Costello sings the melancholy tune, “A Good Year for the Roses.” The song has stuck with me, but the sad sentiment doesn’t match the colorful riot of rose blooms showing in Atomic Object’s parking lot this summer.

For the last several weeks I have been creating a tool that accepts a set of configuration files and builds a number of charts based on information in those configuration files. For a few reasons I chose to use Ruby and the WIN32OLE support in Excel for staging the data and creating the charts. There may be better Windows solutions to creating charts, but Excel isn’t bad at it and the OLE automation in Ruby makes it fairly easy to drive Excel.

A design student, Pascal Raabe has created a very nice tool summarizing the definitions, techniques, and roles of User Centered Design. It’s available as a free download as a jpeg or pdf. Alternatively, for a donation, it can be printed and shipped.

Did I mention that it includes penguins?

User Centered Design Infographic Poster

The central premise of user centered design is that the best designed products and services result from understanding the needs of the people who will use them. -Design Council

I’m a Graphic Design student about to go into my third year at the University College Falmouth. During a year of self-directed study I had the pleasure to work with many interesting design studios and practitioners which got me interested in user centered design.

Although I know that this diagram is by no means complete, I believe that it can be beneficial for students and design practitioners in various disciplines. I release it under a CC BY-NC-SA license with the hope that others will find it a useful tool for learning or teaching and to share and build upon…

This is an information graphic poster illustrating the underlying lifecycle, methods, principles and techniques in a user centered design process where the visual part is only the tip of the iceberg.