Software for Students

Systers Code Sprint

Diane Curtis — Thu, 01 Oct 2009 21:44:00 GMT

Twelve hours into the day and two Starbucks stops behind me, I’m hanging out at the Systers Code Sprint. I met Robin Jeffries!! She’s super nice and we had a very good discussion about why Systers uses their current system rather than say the Groups developed by the company Robin works for (Google). ;-)

The goal for this session is to get folks engaged long term and to teach people about open source projects and why they might care about them. You can learn more about their efforts on their wiki. Right now we’ve broken into smaller groups and the experts are coaching each group individually. It seems like it’ll be a great learning experience for some of the students here. If you’re interested in getting involved, there’s still time!

If you know me, you might really be wondering why I’m here. I <3 Systers. More about Systers from their site:

“Systers is the world’s largest email community of technical women in computing. It was founded by Anita Borg in 1987 as a small electronic mailing list for women in “systems”. Today, Systers broadly promotes the interests of women in the computing and technology fields. Anita created Systers to “increas[e] the number of women in computer science and mak[e] the environments in which women work more conducive to their continued participation in the field.”

To get involved on the dev side, you can subscribe to Systers-dev – their public development mailing list.

Technorati Tags: ghc09,ghc

At the conference, on Eastern time but less over-committed than I thought :-)

Diane Curtis — Thu, 01 Oct 2009 11:31:00 GMT

I FINALLY arrived at the Grace Hopper Celebration of Women in Computing around 8PM last night. I’ve been thinking about and planning for the conference since February. (Not as long as the organizers, but that’s still a long time!) I arrived in time to meet up with some folks at the Poster Session and to attend a meeting with all of the other Microsoft folks in attendance. After doing some email and finally getting to sleep late, I woke up at my normal time and was ready to go at 4AM local time! At least I won’t have guilt about not checking email today. Done and done.

What am I doing today? I would love to tell you that I had my program 100% planned in advance, but this year this was not the case. This morning I was excited to put the finishing touches on my plans and very happy to see that I don’t have any overlaps today OR tomorrow. It’s a bit of a miracle really.

Some of the highlights of my calendar today are:

PRESENTING! Come visit me in Tucson E at 11:15AM. With other panelists from EA, ACM, and IEEE, I’ll be discussing Landing a Job and Succeeding in Industry: Bridging the gap between in-class learning and job-related skills. It’s on the Student track.
Booth time. Our Microsoft booth has some great giveaways. I may or may not have eaten one of the Microsoft chocolate bars at 5AM today. We have recruiters here from MSR and College Recruiting. I didn’t sign up until booth time until tomorrow, but you’ll likely find me here during the busy break times.
Blogging! I only have one assigned blogging session today, about Careers in Robotics.
Tweeting. You may have heard the goal that GHC would LOVE to be trending on twitter today. I’m @dianecu and will likely twitter more personal anecdotes than interesting insights, but I’ll definitely try to help the cause.

I’m participating in the CONNECT project and would love to meet more of you. You can find me wandering around today in my black glittery Microsoft shirt. Normally that’d set me apart more than it does today. ;-) T-30 minutes until I can go register!

Technorati Tags: ghc09,ghc

Microsoft iGive at Grace Hopper 2009

HilaryPike — Wed, 30 Sep 2009 20:25:00 GMT

At GHC 2008, we kicked off a campaign called iGive where women in computing gave back to the community. Please support iGive again this year as we continue to support and raise awareness for the Boys and Girls Clubs of America.

What is iGive?
The iGive campaigns are a way for Microsoft to “give back” to the communities that we live in and serve. It is part of the overall corporate citizenship pillar of key initiatives that we all embrace as part of our work at Microsoft. Every donor receives an iGive shirt (while supplies last). iGive is a program run at many conferences including Mix, Grace Hopper, and Microsoft Professional Developers Conference.

Boys and Girls Clubs of America

This year, the iGive program supports the Boys and Girls Clubs of America by raising money and helping raise awareness about their mission: to enable all young people, especially those who need us most, to reach their full potential as productive, caring, responsible citizens.

In every community, boys and girls are left to find their own recreation and companionship in the streets. An increasing number of children are at home with no adult care or supervision. Young people need to know that someone cares about them.

Boys & Girls Clubs offer that and more. Club programs and services promote and enhance the development of boys and girls by instilling a sense of competence, usefulness, belonging and influence.

Boys & Girls Clubs are a safe place to learn and grow – all while having fun. They are truly The Positive Place For Kids.

Where did the iGive campaign take place in 2008?
The dual conference launch of the iGive campaign in both Las Vegas & New York during March 2008 (in honor of National Women’s History Month) collected over 150 individual donations, and raised over $1400 from attendees at MIX and the Financial Services Developer Conference.

What makes the iGive shirt so special (why would I want one)?
It’s Microsoft like you have never seen it! The front of shirt has real Swarovski crystal gems forming the special iGive formula for the charity of choice. Celebrate diversity for yourself or a special female in your life. These shirts are limited edition, so be the first to collect each in the series!

Did this post or series make you say, "wow!" If so, Text W7 to 23000 (standard rates apply)

See you at GHC09! http://twitter.com/hilaryp

Technorati Tags: ghc09,ghc

3 Ways To Take Your Grace Hopper Experience Online

HilaryPike — Wed, 30 Sep 2009 14:04:00 GMT

The Grace Hopper Celebration of Women in Computing Conference is an excellent way to keep in touch with women’s issues, gain advice and insight for your career, and most importantly connect with other women in computing. The conference has a number of online venues to enhance your attendance or to follow along if you are unable to attend. Here’s a quick summary of the online resources for the conference.

GHC Website: Contains all the logistics you need for the conference including the conference agenda and resume submission facility

GHC Online Community

The Grace Hopper Conference is using the tag “ghc09” to identify associated online articles, pictures, and videos. Tagging online content allows it to be aggregated across many websites. BJ Wishinsky has done a great job setting up and connecting the online community for the conference. If you’re familiar with these online venues, here are the links you’ll need to get started.

Blog

Facebook

LinkedIn

Photos

Twitter

Videos

Notes wiki

Community Home

If you’re new to the online elements associated with the conference here are 3 Ways to enhance your Grace Hopper experience.

1. Connect to Real-time Discussion about the Conference

Subscribing to the real-time discussion on twitter enhances your conference experience by helping you feel connected to others at GHC and by sharing in their experience of the conference. Twitter is an online discussion engine where women will talk about their experiences at Grace Hopper.

It only allows 140 characters, so posts will be short. Like this one:

Twitter posts contain everything from links to relevant articles to day-to-day information, such as the coffee was bad or the sun is beating down this morning. Everyone posting about Grace Hopper will include the tag ‘#ghc09’ in order to take part in the conversation. You can listen in to this conversation by subscribing to all posts that include the tag ‘#ghc09’.

How to subscribe?

Use the Twitter Search Engine to find the conversation by going to: http://search.twitter.com/search?q=%23ghc09

In the right-hand pane you’ll see the RSS feed for your search select ‘Feed for this query’:

Select the application you’d like to use to read the discussion such as Live Bookmarks or Google Reader

As online users post to this discussion, you can see what they’re talking about in real-time

2. Find Articles and Information

Bookmarking websites like Delicious.com (sometimes written del.icio.us) or Technorati.com aggregate content labeled with the tag ‘#ghc09’. When you search for #ghc09 the results will show articles that use this tag. These websites are slower to update than Twitter and may take longer for articles to show up.

Twemes.com aggregates also online content associated with a specific tag, however it aggregates from specific sites such as Twitter and Flickr. Since both these sites are used for GHC, this is a great option. I sometimes have trouble accessing Twemes.com

3. Catch Up on Missed Sessions

Whether a lunch discussion with a new friend or conflicting sessions at GHC cause you to miss a session you’d like to see, don’t worry the online volunteers have it covered. Check out the Notes Wiki where conference attendees post notes from the sessions each day.

For instance, my panel in the Student Track: Landing a Job and Succeeding in Industry: Bridging the gap between in-class learning and job-related skill conflicts with: Industry Track: The Imposter Panel. Since I’ll be busy at this time, I’ll check in later to get tips and advice from these panel members.

See you online at the conference!

http://twitter.com/hilaryp

Technorati Tags: ghc09,ghc

Technical Book Club: Code Complete – High-Quality Routines

Kenny Spade — Wed, 26 Aug 2009 08:10:06 GMT

I first encountered routines in QBasic, around the time I started high school. I had been using GOTO and GOSUB commands in GW-BASIC for quite some time, but in QBasic, you had the ability to separate the code out from your main program, and to isolate variables from each other. Once I got the hang of the concept, it made programming much easier, and decreased the number of errors I had in a program quite substantially, since I could more easily isolate code, and look at a single block at a time, without having to scroll back and forth through the program (At the time, I was using a DOS based editor, so only 24 lines or so could fit on the screen at one time.)

Since then, working with routines has become much easier, and the IDEs and supporting tools have improved greatly. Documentation as been assisted through tools like Sandcastle for .NET, which takes comments assigned to routines when formatted a certain way, and generates documentation from them (In Java, the equivalent is Javadoc). The .NET IDE lets you refactor blocks of code into routines directly by selecting the block, right clicking, and choosing a menu item. Parameter passing and return values are handled automatically, and your routine is available for use in other blocks of code. Refactoring also allows you to rename routines easily, modify parameter order, and much more, making changes far less painful than they once were.

Over the next section, we’ll be covering routines in greater detail along with the book. Feel free to regale us with your stories of your interaction with routines, and how they affected your life by leaving us a comment below.

Technical Book Club: Code Complete – Beyond Classes: Packages

Kenny Spade — Fri, 21 Aug 2009 08:51:51 GMT

Separating classes into groups allows for a further level of abstraction than classes alone. In C#, this is done by the use of namespaces, in Java, this is done using Packages. The end result in either case is that you can ignore the internal details of the contained classes, and focus on the details you do wish to expose. Additionally, separating classes into namespaces allows you to avoid naming conflicts, and to more easily control access between the contained classes. Classes can be allowed full access within the namespace, while preventing external access.

Just like deciding which functions and data members to put in a class, though, it can be difficult to decide exactly which classes should go in which namespaces. If you aren’t careful, you can create unnecessary dependencies between them, and certain designs can actually end up causing a cyclical reference, where namespaces call each other. So basically, they’re like most things your encounter in software development: useful, but with the potential to make things difficult if used improperly.

Have you seen benefits from using packages or namespaces? Have you handcrafted packages in a language where they didn’t exist? Maybe you’ve ran into a package that needed to be re-architected due to a choice on what to include. Let us know.

Technical Book Club: Code Complete – Language-Specific Issues

Kenny Spade — Wed, 19 Aug 2009 08:51:58 GMT

If you drop a good developer into a project being written in any language, they’ll still be a good developer. The foundations are the same, regardless of the language, but there are some differences that can trip you up if you aren’t careful. These aren’t simply differences in what gets capitalized, or how you import class libraries, but the more subtle aspects that you might not catch if you weren’t paying attention.

One thing that caught me in C# was around Data Binding. I had been using data binding extensively on one of the projects I was working on, and couldn’t figure out why a new class I had just thrown together in a prototype wasn’t binding properly. I looked at the interface for a class that did work, then looked at my interface, and couldn’t see the difference. It turned out that when I had thrown together the prototype, I had exposed fields directly by making them public, where Data Binding required the fields to be exposed through properties. When you looked at the interface, you couldn’t really tell the difference, and since I had always used properties in the real code I had been working with, I never even knew that this was a requirement.

Have you encountered a quirk in a language that you weren’t expecting to see, or a difference from one language to another that gave you a bit of a headache trying to uncover? Let us know in the comments section below.

Technical Book Club: Code Complete – Reasons to Create a Class

Kenny Spade — Fri, 14 Aug 2009 08:54:11 GMT

When I started programming in an Object Oriented language, I was of the impression that everything should be a class. If something wasn’t inherently obvious as to how it should be implemented as a class, it must have been because I didn’t understand OOP well enough. It wasn’t until much later that I became comfortable enough with the concept to figure out what should be broken out into a class. This doesn’t mean that I’m infallible, so it’s good to see that I’ve mostly been on the right track. Of course, knowing something, and being able to explain and defend it are two different things.

On one of the projects that I was working on, I came in with quite a bit more development experience than the rest of the team, so I figured I would take it upon myself to pass on the lessons that I had learned, and show them how it was done. I started off by extolling the virtues of real bug tracking software to replace the Excel sheet they had been using. This was well received, so I continued on by showing them how they could abstract their database calls to allow them to separate their stored procedures from their database, making it possible to create a database agnostic application, and store their database calls in their revision control repository, to boot. Another well received suggestion! I was on a roll. Next, I started showing them where they had written the same block of code on almost every page in the system. It was a fairly involved block of code, involving a call to the database, and could be easily abstracted out to a user control, but for some reason this wasn’t quite clear. The company had recently had some parties interested in purchasing the code base come through, and they had commented on how they liked the fact that they weren’t re-using code through user controls, because it meant that if it broke, it wouldn’t break the entire system, just one small portion. Well yes, I replied, but if it breaks, it’s also less likely to be noticed, and it’s more difficult to change and repair, to boot.

Later, one of the owners of the company came to me, concerned. She let me know that she was very confident that I knew that I was doing, and she appreciated my efforts to improve the system, but that since this was a temporary position, she was concerned that when I left, the team would find it difficult to understand the code I was writing, and the suggestions I had been making. It turns out that reducing complexity can itself be complex.

Have you encountered situations where using a class made things easier, or where using a class would have simply added difficulty? Is there a rule you use to determine whether a class is suitable or not? Feel free to share.

Technical Book Club: Code Complete – Design and Implementation Issues

Kenny Spade — Wed, 12 Aug 2009 08:50:00 GMT

I like the idea of rules of thumb for coding. People a lot smarter than me have done a lot of research to figure these things out, so I figure it’s the least I can do to reap the benefits that come from them. One I heard a while back, and have found to be very true, is the idea that once you get beyond a single page of code, errors start becoming much more frequent. The bit about keeping a class to having 7 ± 2 data members was new to me, but it makes sense. There was a famous paper published in the fifties called The Magical Number Seven, Plus or Minus Two on the topic, and it has been proven over and over. I’ll have to see if this helps me in the future.

Deep inheritance trees are another rule of thumb you can take a look at. I agree that the more levels of inheritance you add, the more difficult it is to make sure that you follow the rules of the “is a” relationship. I worked on a project one time in school where we used the Unreal Tournament 2004 engine, and I remember trying to track down just where along the line a certain function was implemented. When it was that difficult to find a function because you have to crawl the tree, there’s very little chance that you’ll know everything you need to when you go to override a function.

The last bit in the section is on shallow vs. deep copies. I have been bit many times by making shallow copies, and finding out somewhere down the line that I need to make an edit that I don’t want to be changed in the original. This gets even more difficult when you don’t have the details of how the copy was done (and you really shouldn’t have to look). It might be a bit more work to do a deep copy, but it adds some piece of mind that nobody is messing with your bits.

Have you encountered any problems from the complexity that comes from the “has a” and “is a” relationships? How about deep copies? We’d love to hear your stories.

Technical Book Club: Code Complete – Good Class Interfaces

Kenny Spade — Fri, 07 Aug 2009 07:26:28 GMT

If you haven’t seen a good number of the suggestions in this section being violated, rest assured that you will. I actually cringed at a couple of them, remembering times where I had struggled with overly exposed classes and eroded class interfaces. (and yes, I’m guilty of taking a shortcut that ended up making things harder for someone else, I’m sure) The one that I remember most readily, though, is all of the code that I’ve come across that assumed you knew more than you should have had to. I was getting much of the code I worked with third hand, so sometimes I was lucky enough to have had someone comment a block of code letting me know why what I had just tried wouldn’t work, and letting me know that I would need to run some other block of code first. Other times, I would need to look at the other instances where this code was called, and see what it was with those blocks that caused them to work that I was missing.

The other point that I feel bears further examination is the importance of read-time convenience versus write-time convenience. You might have been working on a certain block of code much longer than you would have liked, and figured out a way to finish up early by cutting corners and making a variable public so you can use it without having to write a new method or figuring out the right way to do things. If you’re doing something that you wouldn’t be proud to show off, or that doesn’t quite feel right, you should re-evaluate the situation.

What struck you about this section? Were you inspired to re-visit an old interface and clean it up so that the abstraction felt right? Let us know what’s on your mind.

Technical Book Club: Code Complete – Class Foundations: Abstract Data Types (ADTs)

Kenny Spade — Wed, 05 Aug 2009 08:43:25 GMT

When I was studying ADTs in university, they didn’t make a lot of sense to me. They were treated as some theoretical concept, something you would only do as an exercise. In truth, we were using ADTs, but not to their full potential. We would abstract to the level of a binary tree, but not to the level of what we were using it for. Naming was done based on the type of object we were working on, so we would call it PersonTree, and if we decided that a List would work better, we needed to go through and rename every instance of PersonTree to PersonList. We did this because we were focused on the technical implementation details, rather than what we were implementing. Should the next developer down the line care whether you were using a List or a Collection to store your data? If you abstract properly, no, they shouldn’t. If your decision down the line to tighten up some code by changing the internals of some class, ideally, you shouldn’t be breaking anybody else’s code. You also shouldn’t be forcing people to rename all of their objects.

When ADTs are well written, acting upon them should be simple. I remember working with certain objects in VB6 where you set properties by ORing all of the flags you wanted. I also remember coming across certain blocks of code that weren’t working because someone had ANDed them together. It made sense when you read it, Bold AND Italic, but the implementation was exposed as being a set of boolean flags, which are turned on by ORing the right properties. Had they been implemented with methods like SetBoldOn, there would have been no possibility of making that mistake. The code basically writes itself.

Have you made use of ADTs, and have any success stories you’d like to share? Perhaps you’ve encountered a situation that could have used them, or seen a classic example of what an ADT should not be. Let us know, we’d love to hear about it.

Technical Book Club: Code Complete – Comments on Popular Methodologies

Kenny Spade — Sat, 01 Aug 2009 00:44:04 GMT

So how much design is enough? In my experience, enough design ends up being as much as you can fit in to the time allotted. I’ve never been on a project where I was given unlimited time before I had to start showing some progress towards the end product. Creating prototypes and capturing the design documentation can work in the short term, but eventually, you will have to get to the code. Every project failure I’ve been involved in have suffered from rushed design and poor planning, so if you aren’t satisfied that your design has made sufficient progress (a bit of uncertainty should be fine), make sure that you raise your concerns early and that they are noted. While voicing your concerns might not save the project, it may give the higher ups a chance to re-evaluate the project, and insulate you from the failure. Also, remember that working on a successful project is far more fun than a failing one, so if you think the project will end up as a death march, maybe it’s time to find a new project that can use your skills.

Wow, that sounded a little negative. The good news is that the more projects you work on, the better you get at things like recognizing problems that have already been solved, allowing you to focus on the small portion of the project that hasn’t been designed out by someone else. You’ll also be able to explain the reasons you should be spending more time doing design, and get more leeway on your projects based on past successes and failures that you’ve learned from.

How do your experiences compare? Have you successfully skated by with no design, or been bitten by something unexpected after you’ve designed your system to death?

Technical Book Club: Code Complete – Design Practices

Kenny Spade — Wed, 29 Jul 2009 07:40:54 GMT

In your time as a developer, you’re going to see a lot of different ways people approach design. I worked with a guy once who had to start every project by first creating the database that would power it. I worked with another who needed to know what every screen would look like in the application before he could understand it. An instructor of mine taught me the approach of creating a data flow diagram, and working from there. Every approach had it’s advantages, and they all had their drawbacks as well. As of yet, I am not aware of anyone having discovered a best way of doing design, so feel free to sample from the approaches you encounter, and find what works for you.

I prefer a top down approach with a lot of prototyping and collaboration. I used to write everything out by hand and scan it in, but I’m a big fan right now of SketchFlow for mocking up designs. I pass them back and forth within a group that I game with to get feedback on my look and feel, and to get past the ugly yet functional phase of my designs. I also have been known to post snippets and questions online to get feedback, and at one point in my developer career, I would pull our design guy away from whatever he was doing and present my code problems to him. Even though he didn’t have a lot of coding background, he was able to catch things that I was blinded to because I was too close to the problem, and sometimes the act of describing what I was thinking was enough to get those synapses firing and discover for my self what I needed to be doing.

So how about you? What kind of approaches have you seen that have seemed to work well? Are you more of a top down or a bottom up thinker? Let me know in the comments.

Technical Book Club: Code Complete – Design for Test

Kenny Spade — Sat, 25 Jul 2009 09:24:22 GMT

In my previous post, I covered design heuristics. I wanted to return to the topic to touch upon a topic that I feel is often overlooked. In fact, in the entire section on heuristics, only a single paragraph was dedicated to it. The concept of designing for test, often referred to as Test-Driven Development, or TDD, is something that just about every developer you speak to will agree upon as being a good thing. Far fewer developers actually take the time to do it. The concept itself is quite simple. Before you write any code for a new feature, you evaluate exactly what you want it to do. You then write a test that checks the output of your (nonexistent) code, run it, and watch it fail. Once the test fails, you can go ahead and start writing code. When you are confident that your code does everything it needs to pass the test (and no more, by the way), you run the test, and watch it succeed. At this point, you can begin to refactor the code, confident that as long as that test continues to succeed, you haven’t broken anything. Naturally, you’ll want to write a large number of tests to ensure extensive coverage. The great benefit is that since you are constantly running these tests as you move along the development process, if anything should ever break, you’ll know it right away, and not when the problem surfaces when you’re nowhere near the cause.

Like those other developers that I talked about, when I was working in the industry, I knew all about Test-Driven Development, thought it was a great idea, and never did anything about it. I first actually encountered it in a class in university, in the form of a Perl script that tested my application I was writing for a Data Structures and Algorithms course. The TA told us that he would be testing our applications with the tests he had provided, plus a number of additional tests that dealt with edge cases. If we passed all of the tests he gave us, we would be guaranteed a passing grade. The test suite ended up making the development project into a kind of a game. I would write some code, run the tests, and see how many tests it passed. Working alongside my friends, I could instantly see how I was doing in comparison by asking how many tests they passed. And it was much easier to find out what my application still needed, because I could see that I was failing all of the delete tasks, for example.

With modern IDE’s writing and running tests has become far easier than creating a script that did Diffs with the correct output. If you are using Visual Studio, for example, you can choose between Team System (you should have access through MSDNAA – if not, contact your instructors, chair, or friendly local ADE to get it in place), or through a tool like NUnit, either alone or in conjunction with an add-in like TestDriven.NET. I recommend you give it a go either for your next assignment, or on a side project. You’ll find that it not only makes things easier, but more fun, too.

Technical Book Club: Code Complete – Design Building Blocks: Heuristics

Kenny Spade — Thu, 23 Jul 2009 09:30:31 GMT

The section on Heuristics should be immediately familiar to any student who has gone through an Object Oriented programming course. Even so, it bears re-reading, as it is often quite easy to forget why what we are taught is such a good thing. Had I kept the idea of feature-itis relating to design patterns in mind when developing one application I worked on, I might have seen how not every type I created was as suited to the Factory Method pattern as I was leading myself to believe. I was able to successfully implement the ideas I was going for, but I never did quite shake the feeling that something wasn’t quite meshing in my design.

Another situation mentioned briefly had to do with writing code to abstract usage of a non-standard language feature, and it deserves to extended to the idea of using external APIs, as well. You don’t always have control over the interfaces that you’re working with, as I found out when I implemented a mapping component into an application I was building. The API gave you the ability to create maps, export the map in certain formats, and copy the image to the clipboard. Without writing a custom handler for the mapping format, which didn’t look promising, the only way to get the map into my application was to make use of the clipboard as an intermediate storage. This of course required taking the current data stored in the clipboard and copying it into memory to be restored after the process completed. But by abstracting the usage of what could be seen as a global variable into an isolated routine, it was then possible to replace the function with a better implementation when the mapping control improved to allow for direct access to the image, or when a handler for the mapping format could be written, all without modifying the application itself.

The final point in the section really highlights something great. Not every problem can be solved the same way. The heuristics highlighted are guidelines, and will serve you well, but if you’re not making headway, don’t feel like you have to keep doing what you’re doing because it’s worked in the past. There are multiple ways of doing just about everything, and one of them is bound to work for the problem at hand.