So ok, I like code, I like people, I want to try it! I live a little south of Chicago so its a long commute and it seemed everyone was so busy to pair in person when I asked. I asked on Devchix mailing list for suggestions on how to do pairing online. I had found a few, and the group had some good suggestions. I even had a volunteer to try it with me! This week aimee and I set a few hours aside to try it and see if we could do it!

This article was also sort of “paired” as it was written from my perspective with input and suggestions from aimee!

We asked on Devchix mailing list for suggestions on how to do pairing online. I had found a few, and the group had some good suggestions. I even had a volunteer to try it with me! This week aimee and I set a few hours aside to try it and see if we could do it!

After introductions on Skype we set about getting a shared environment in which to code together. Ideally, we wanted some kind of desktop sharing so we could run tests, console and editor.

We had heard of a few tools and got suggestions from the devchix list:

IChat desktop sharing - we couldn’t get this to work, we did different things and it would appear to connect but then it failed. I tried to mess with settings for Sharing on mac, but nothing doing.

Rio seems to be a library to make collaborative apps, not to use in a pair programming environment.

BeSpin was hard to use.. we couldn’t figure out exactly how to use it. It almost seemed to offer to import the git repository we were working on, but then it said it only supports Subversion and Mercurial, not git.

SubEthaEdit worked but we would have to open each file individually and share each file… unless I was missing something. This would be fine for collaborating on a single file but then we could not share the test runs, terminal commands or view the browser together.

Etherpad - we didn’t end up trying this but I have used it before to debug some code or try out ideas with a friend. They recently got bought by Google, so it would be interesting to see what they do with it. This would suffer the same limitations as SubEthaEdit in that it’s just a text editor.

GoToMeeting (which is $40-50/month) its a little steep for the open source work I want to do. But people say it works really well.

VNC and Unix Screen - aimee had used this successfully before but since we weren’t on the same network, just our laptops at home, we weren’t sure it how we could make it work easily.

Then we came to TeamViewer which worked brilliantly! We shared desktop and I could type in aimee’s console window, see the tests running and type in textmate. Even with aimee on her Dvorak keyboard and I on Qwerty! I could type fine but couldn’t copy/paste with keyboard shortcuts so I used the mouse to copy/paste and it worked fine.

All in all, it was an awesome experience and I picked up on a few tidbits of knowledge from aimee on git, and rake! I had some bits of code from another project i was able to quickly copy/paste and get us rolling. We had a few discussions about coding style as we went.

Since aimee was more familiar with the codebase, she mainly wrote the behavioral specs and I wrote the code to satisfy them. We plan to switch around next time, when we pair on a different project that I’ve been developing for a while.

This is more like a “workbook” then a “how to write awesome code” book. You can download the code from github http://github.com/kevinrutherford/rrwb-code and you will find tests/specs for the exercises.

The book is arranged in three parts, The Art of Refactoring, Code Smells, and Programs to Refactor.

There are explanations of “code smells” which are one characteristic of code that could be improved. Some of them are long parameter lists, unnecessarily complex, global variable, feature envy sections, etc. One thing I find interesting is the “How did it get this way?” section. It gives some insight into the thought process and reasoning behind the smell. I think this is good, as programmers our ego may be rather miffed to hear “This code stinks” but with some reasoning, it makes the pain less and I think firms up in our minds when this happens again, to do it this other way. I always want to know why when someone says I could do such and such thing better.

In addition to the code smell examples there are three programs to refactor in the end of the book. In a conversational tone, it walks through and gives some hints on what needs refactoring. Its almost as if you had a pair programming buddy working with you and identifying in small chunks what can be improved. This is definitely something I want to work through more carefully.

What I find odd, is that not all the code smells have code examples. The inspiration for the book I think is the Martin Fowler book “Refactoring Improving the design of Existing Code” which has examples for every code smell. Maybe Ruby smells less than Java? Or those fixes are really trivial? I don’t know. Overall, this is a great book and is certainly worth the price and investment and you will be a better programmer because of it!

Early registration ends Friday. Go here for details.

Gloria

In mid 2007 I was happy working with Perl. One day a friend told me about a Ruby on Rails job. Back in 2007, Rails developers in Brazil were rare. Because of that, the employer was seeking someone who fit the company instead of someone with Rails experience. That was great for me!

After a pleasant summer, the new job’s charm wore off and I decided that I wanted to move on but continue to program with Rails. Finally, I left my job.

When I started to send out resumes I soon realized that Rails’ culture fundamentally changed the way that a Rails job search functioned. In addition to the traditional resume or CV, Rails jobs demanded to know about Working With Rails, LinkedIn, GitHub, Twitter, personal blogs and sites, discussion forum posts, participation in open source projects, and a multitude of other online presences. These new demands made me realize that I hadn’t been cultivating a comprehensive web presence, which is not uncommon for female programmers, in my experience.

At first, this realization was disturbing. Though it’s still possible to get a Rails job without a vast web presence, I was upset to realize that I hadn’t been adhering to this best practice. It was particularly jarring the first time I was unable to answer these questions to potential employer.
The practice of software development as a craft is constantly reinventing itself and this includes the processes around job seeking and reputation building. Despite all of the hours, projects, languages, and jobs I’ve previously invested in, I now realize that I need to adapt to this new developer reality of being social and visible with my work in order to win back my standing as a desirable developer and potential candidate for a Rails position. The details of how I’ll implement that strategy will be the subject of an upcoming post, but I look forward to the possibilities ahead.

To read in portuguese.

http://us.pycon.org/2010/registration/financial-aid/

This conference gets a bit bigger each year, but the organizers make a great effort to keep the small conference feel. It also has many level-100 tutorials, and is both socially and technically welcoming for py-newbies.

Open space sessions (everything from software development to Settlers) and poster sessions happen every night, tutorials run two days prior, and code sprints run for a few days after the conference. It promises to be a great learning and social experience you should not miss.

I am reserving a room and sharing it: http://us.pycon.org/2010/registration/room_sharing/
I’ll room with as many as possible, to cut costs for everyone. Bring a sleeping bag :)

See you there,

Gloria

Get GWT Trunk
The 2.0 features talked about here are in trunk and building it yourself is fairly straight forward.

1. If you don’t already have it, get the latest version of eclipse - Galileo, with the Google plugin.
   http://code.google.com/eclipse/

2. Checkout the source code
   Follow the instructions on the GWT homepage, its pretty good.
   Make sure you have ant installed. It takes awhile, i think maybe 20 mins or so on my macbook.

3. Setup the API directory in the Preferences for GWT
   In eclipse, add the new version of GWT library.

   Go to Eclipse > Preferences.
   Find the Google Web Toolkit on the left. Click add, add the path to the compile files like so:
   ~/gwt/trunk/build/lib
   I named it “trunk”

4. Create project
   Create a new Web Application Project, select “trunk” (or whatever you named it in the previous step) as the version of GWT to use.

The most interesting things in 2.0 is the UiBinder and UiHandler.

Using UiBinder
Usually for each element on the page you need to do something like this


CheckBox box = new CheckBox("this is the label for the checkbox");
box.setFormValue = "3";

Panel verticalPanel = new VerticalPanel();
panel.add(box);


If you have alot of elements on the page, that comes out to alot of java code. And you might start wondering if you are writing a Swing app or a web app?!?

in UiBinder, we can can put it in a XML file like:


<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui'>
<g:VerticalPanel>
<g:CheckBox ui:field="rubyCheck" formValue="ruby">Ruby</g:CheckBox>
</g:VerticalPanel>
</ui:UiBinder>


Typically any attribute you can use in the java code like setName, setFormValue, setStyleName you can add right in the xml as attribute=”"

You can reference your objects from the xml like so:

public class LanguageList extends Composite {
interface MyUiBinder extends UiBinder<Widget, LanguageList> {}
private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
@UiField CheckBox rubyCheck;
public LanguageList() {
// bind XML file of same name to this class
initWidget(uiBinder.createAndBindUi(this));
// use rubyCheck as if you had defined it already with new
rubyCheck.setStyleName("rubyCheckStyle");
}
}

Note you have to bind the xml to the java code with:

interface MyUiBinder extends UiBinder<Widget, LanguageList> {}
private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);

This process is called deferred binding. This may be familar to java programmers already but My background is LAM(P|P|R) programming so I am still trying to fully understand it myself! GWT homepage explains it here: http://code.google.com/webtoolkit/doc/1.6/FAQ_Client.html#Deferred_Binding

Using UiHandler

Typically, event handlers are written as such:


// add button and handler to alert the values of checkboxes
button.addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
String output = "";
for(CheckBox box : boxes) {
if (box.getValue()) {
output += box.getFormValue() + ", ";
}
}
Window.alert("You checked: "+ output);
}
});

Instead of having the click handler specified in the java method, you can attach it via an annotation:


@UiHandler("languageButton")
void doClick(ClickEvent event) {
String output = "";
for(CheckBox box : boxes) {
if (box.getValue()) {
output += box.getFormValue() + ", ";
}
}
Window.alert("You checked: "+ output);
}


Sweet, huh? I think it cleans up the code nicely and gets the job done!

Go compile the Trunk version of GWT and give it a try!

If you want to see the full source for a simple gwt app before and after UI Binder, I have a write up here with links to sources on github here.

Resources for learning gwt that I found helpful:

GWT Homepage
http://code.google.com/webtoolkit/

GWT Can Help You Create Amazing Web Apps
http://www.youtube.com/watch?v=T0X9BcBd-I0

GWT Best Practices
http://code.google.com/events/io/2009/sessions/GoogleWebToolkitBestPractices.html

OnGWT - various blog posts about GWT
http://www.ongwt.com/

Some of our members were fine with it, while others said they felt alienated by the term. Beth explained that it was because of its usage in the movement—“master craftsman” is held up as an ideal that everyone should aspire to, but its male bias makes it difficult for some women to relate to it.

We discussed alternatives like craftsperson, crafter, and artisan. After a bit of brainstorming, Tess came up with “codesmith.” Many of us were excited about this term—it has a fun and geeky vibe that captures the enthusiasm we have about our work, while having the same emphasis on creation present in “craftsman.”  While it’s certainly based on words like blacksmith, I like to think of it as more similar to wordsmith—a person who is skilled at using language to make something great.

As the sort of programmers who get into debates over small differences in syntax and rack our brains to come up with the most appropriate name for some variable, we know language is important. It’s a shortcut for identifying something, but over time it can create expectations and beliefs. Making changes to language can be difficult, but in the case of being inclusive to women in a women-starved field, I think it’s worth it.

My tutorial was intended to encourage women in computer science by serving two purposes: discussing the source code and functionality of a particular project, and openly discussing some of the issues they faced in their current programs and surroundings. I was pleasantly surprised to discover that these women needed no technical or social encouragement. They are already enthused, technically and socially well prepared, and on their way to a very bright future in engineering or computer science. I was pleasantly surprised that they were very comfortable in the bash shell, and as comfortable in their current college curriculum. Like children at play, they picked up the moderate-levelled tutorial code quickly, made great strides in such a short time, and had a lot of fun doing it.

It was profoundly encouraging to see such a small computer science program achieve diversity as well as such a high level of skill. It made me wonder why larger colleges and universities cannot accomplish the same on bigger budgets, with larger staff, and a more diverse mix of students. It touched me to hear and see the enthusiasm, eagerness, and skill of the students in this program. Their learning experience under the Department Chair, Dr. Burch, comes as close to perfect as I have ever seen.

The next day’s events at PyArkansas were held at the also-very-nice campus of University of Central Arkansas, where an entire day’s worth of tutorials took place. Two Python 101 tracks were held: one for programmers and one for non programmers (a great concept). An all-day Django Track was given, where the advanced course was taught by Jacob himself. I held an afternoon tutorial addressing advanced Python concepts, with downloadable example code, where we compared and contrasted build and deployment tools, played with regex, and showed examples of some internal Python oddities involving static variables. I unfortunately missed the Python Blender tutorial, held at the same time as mine, and I heard it went quite well.

The campus facilities were very accomodating. Everything was well organized,and up and running for us when we arrived. This is a very welcome surprise to anyone who has travelled a bit to do tutorials. I was specifically told by Dr. Chenyi Hu, the Department Chair of UCA, that he really does care about diversity, and it is something they strive to achieve. This was truly touching, quite impressive, and a pleasant surprise from such a small town.

Kudos to Greg Lindstrom, Dr. Carl Burch of Hendrix College, Dr. Chenyi Hu of UCA, and everyone else involved. You induced a big technical “tremor” through your small town, which echoed far and wide. It is yet another example of the great people drawn to the Python community, and the amount of quality effort they are willing to give back. I feel honoured to have been part of this event, and I hope to be involved in many more to come.

Gloria

I’ve worked with pair programming at just 1 company for 9 months, the results were both good and bad.

During the time when you are pairing you share your computer with another person. You also share your virtual life details, such as:

The one billion dollar question is: “What happens when the pair does not get along?”

If both people aren’t open to learning with from the experience, the day by day can become difficult.

Pair programming doesn’t work when one party feels the result could be better if the work was done alone. In this case, pair programming is an intrusive and negative experience.

Some people doesn’t understand this situation. To make it easier to understand I usually like to compare pair programming to driving a car and having someone beside you.

First case: Going by a known path.

Second case: Learning new path.

You are driving but now this person prefers to do the driving. If you make some mistake that person says “It would be better if I was driving.” or “If I was driving it wouldn’t have happened.”. What would you do?

Probably both of you arrive at the party in a bad mood and will try to avoid sharing the same the car again.

Maybe if you were in the car a debate would start. But, during pair programming you’re in a company and some words wouldn’t and shouldn’t be said.

Satchmo is based on the Django framework. More accurately, it is loosely coupled to Django through several external Django plugins. For example, registration functionality is extended through the django_registration external interface, installed as a separate egg in the Python distribution directory. Satchmo makes calls to this extension, leaving Django code untouched.

Compare this to Drupal registration changes, where source code is wedged into the existing framework, applying deep back end database schema changes, as well as code changes throughout the framework. The changes are irreversible, and if they fail, you’re SOL. Look under the hood of Drupal, and you see a tangle of database calls, auth and group checking calls, intertwined around back end logic. It’s not pretty, which is why it’s so hard to maintain and upgrade over time.

The Satchmo/Django coupling is not perfect. If you mismatch incompatible versions of Django plugins to Satchmo, or other applications, cryptic messages can appear from either side, pointing back to code compiled elsewhere and placed in your Python distro. This makes it difficult to trace back, even if you vaguely know where the failure point is.

But this is the worst problem Satchmo has presented to me so far. I can certainly live with that, compared to digging through many chunks of Drupal framework source code and database schema backups to figure out why a recent patch broke authentication, how group permissions were changed, etc.

Satchmo takes full advantage of all of the juicy Django goodness that makes web framework development fun again: built-in internationalization and localization all the way down to currency handling and language choices in templates, built-in registration, email verification and customer account management, built-in form data validation, seamless form-to-database data entry.

This is a revolutionary, much needed improvement in the Open Source store front choices. Now all we need is an Open Source back end inventory system, and a very functional Open Source phone bank system based on Asterisk, with Python wrappers, and life would be wonderful.

Gloria