Slashdot Mirror
Open Source Course for Managers?
faqmaster asks: "I teach systems analysis and design as part of programming and project management tracks at a community college, and I'm interested in putting together a course for project-managers on open-source software. What suggestions would the Slashdot community have as far as what managers need to know/understand about Open Source? What books would you suggest? Anyone have any especially good case studies of successful OSS implementations in the business world? Any insight as to how project managers and the like can successfully incorporate open-source into thier projects? What advantages might they see? What are the pitfalls?"
Keep teams streamlined. By consolidating work into a smaller group, you can reduce the number of necessary meetings and the amount of time spent trying to keep everyone informed.
Define terminology. When you begin working on a project, nail down work-related definitions and make sure everyone involved understands them.
Document decisions. Any time you and your team makes a project-related decision, write it down. Include an overview of the rationale behind the resolution.
Group project deliverables. For long-term or ongoing projects, you can reduce project-management administrative burdens by delivering work in batches.
This will reduce the number of times that you need to contact your client and will allow you to consolidate feedback sessions and next steps.
Rework notes immediately. After you finish project meetings or phone calls, review your notes immediately and fill in details you remember from the session but did not write down. At the same time, make a list of next steps and mark the date they need to be completed on your calendar.
Keep everyone informed. Nothing is worse for a project team than to be left in the dark. Morale will drop quickly if team members complete work, and then discover the project has shifted direction and their efforts were for naught. Missteps like this also waste project resources, lengthen timelines and increase costs. Make sure the communication processes you have in place keep everyone informed. It is better to copy people on e-mails that may not directly affect them than to leave them off these communications completely.
Set realistic expectations. Project success is often measured in three ways: on-time delivery, high quality and reasonable cost. A typical project will allow for two of these items to be achieved, so while it's important to reach for all three goals, good managers prioritize them. They know that if they want a project on time and at cost, the level of detail they can hope for may slip. Likewise, if they want high quality at a low cost, they may need to stretch timelines.
If you celebrate Xmas, befriend me (538
I'd like to recommend Open Source Development with CVS
as a good starting point.
- How to get involved
- An email from an Apache developer that explains how he got started
- Project Guidelines
- Understanding Opensource
Yeah, ok I'm a karma whore. Still, if it helps this guy what's the harm?That which does not kill me only makes me whinier
I'll admin I have second hand knowledge about project management, but I learned what I know from those that are/were very good at it.
Most people in a team/project enviornment fall into one of these catagories:
1) Coder; the one that can hack code like there is no tomorrow.
2) Cheerleader; the person that "cheers" everyone on and tries to motivate everyone.
3) Idea man; a person with a gift of "thinking outside" the problem. Usually very smart and somewhat competent as a coder/pseudocoder. Usually thinks of everything except the "how" to do something.
4) diplomat; Usually the project manager him/her self. The one that can "herd cats" or talk to the previous 3, iron out differences and balance all the powers of 1 thru 3.
The more you think about it, the more it is dead on. I've had the advantage, if you will, of observing several teams after learning this little tidbit. Once you see it, you can not un-see it.
The point is: You need all of these types, period.
As the PM you need to recognise these talents reguardless of working in person or via email/IM or whatever communications are your norm.
I give you Linus and Bill G. as prime examples.
They know how to motivate people by using their natural talents, they both know when to say "good job", "work on it some more" or (bill g, IIRC) "that is the stupidest fucking thing I've ever heard of".
As a PM you have the most challenging job, but have to realise that w/o the 3 types, the project is hobbled or dead.
Example of MS/FSF, again offers plenty of insight as to what goes right/wrong with development.
With MS, the divisions are political, social, and idealogical.
With Free Software, timezones/distance, language barriers and occasionally egos.
So, if a book is not around to help, go to a university nearby, and see these dynamics for yourself.
Never know, you might be the one to write the book yourself, with or without the help of a psychology and computer sci. phd.
Cheers,
GISboy
If it is not on fire, it is a software problem.
I wrote the book "Embracing Insanity: Open Source Software Development" to educate management about the ways of Open Source. It deals less with project methodology and more with the social dynamics of the community, but you might find it helpful.
Here's a pointer to the Slashdot book review of it.
I started a project that I call OSS-Leaders for OSS project leaders a few weeks ago. The idea is to create a place where OSS leaders can exchange ideas. It sounds like a simple idea, but when I was leading an OSS project and needed some advice from my peers I discovered that there really wasn't anything like this.
/. email if you have any questions or suggestions.
It is really just a (closed, moderated) mailing list right now, but I hope to distill some of the discussion into some sort of "OSS Leadership How-to" or something.
It is still in the preliminary stages, but we can't grow without members . . .
If you are the leader of an OSS project I hope you will check it out!
Feel free to mail me at my
-Peter
PS: I use "OSS" above because the project is about the process (as opposed to the philosophy). Truth be known I tend to be a "Free Software Guy" but the project is intended to be agnostic about the OSS/Free Software debate.
Although it (in later chapters) assumes a more organized and linear organization than many OSS projects, I'd highly recommend "Code Complete" (full title, "Code Complete: A Practical Handbook of Software Construction") by Steve McConnell. The bulk of it is essential for good coding.
/.) Microsoft Press but this is BY COINCIDENCE, a mere accident of fate! Please do not doom this work just because of this quirk of fate! It really is an MS-free book, guaranteed pure.
Described simply, it tells how to design then write good code and code pieces, and how to document without the usual burden of "oh, rats, I guess I have to document now". Among his suggestions is to use your outline and/or pseudocode _as_ the documentation, by just filling the code in, rather than seeing documentation as a seperate step. If it's good enough for you to code by, it's probably better than any after-the-fact retro attempt at documenting.
He also deals with managing code projects that have high programmer turnover, very relevant to OSS.
The ISBN is 1-55615-484-4, ignore who published it. Seriously-- it's from (he shudders to say on
Actually, all programmers should read it.
A.
First, I'm going to assume that what you're talking about is projects that use OSS, rather than projects that generate OSS.
At AdAce (shameless plug), I pressured my CEO to let me build the website on top of OSS tools and systems. It was a relatively easy sell at the time, because I (the CSO) and the CTO were both OSS enthusiasts, and we got a lot of respect from our CEO for our technical expertise. This wasn't one of those micromanaging CEOs that some companies have.
Now I'm both CTO and CSO, and I'm quite happy with the result of using OSS wherever possible.
The website linked above is built on top of Apache, Linux, GIMP, MySQL, mod_ssl, and smail. We use gcc and all the other g-tools to build the beast. (We wanted to use PNG for all our graphics, but IE's support for PNG is just too horrible.)
Our system has only two pieces using closed-source closed-source software.
The first is the library provided to us by our credit card processor in order to communicate with their systems (signio, now bought by verisign). But that library was built using ssleay, and knowing that I was able to patch up the binary library to avoid certain SSL attacks against us. (thank you, ssleay!)
The second piece is our ad servers (realmedia). We chose closed source ad servers because we needed a certain set of features, and the OSS ad servers out there are too far behind in that feature set for us to use them. We could have added the features we need, but that would've but a huge engineering burden on us that we couldn't afford at the time. Now that we've come far enough, we're evaluating the current OSS ad servers to see which one we're going to adopt, and add the features that we need (and, of course, commit those new features back to the project).
The selling points that we used to push the OSS point are:
1) The security of an OSS project is superior to the security of a closed source project. This is because either the security holes are found by other people and patches are submitted back to the project, or I (whose duty it is to analyze our security) can find the problems and fix them. While with a closed source project, this is all dependent on the very busy engineers at the software's vendor, who will always prioritize security below where we would want it prioritized (we want it to be the #1 priority). It's so nice to be free of worrying over priority conflicts between us and a software vendor.
2) The stability is superior for the same reason.
3) Licensing fees are trivial. For most OSS projects, licensing is a voluntary donation to the support organization, and the size of that donation is up to us to determine. For other OSS projects, licensing is free. The only real exception is MySQL, which has specified certain donation levels which, nevertheless, are far lower than competing database software's license fees.
4) When (not if) the vendor of a closed source project moves on to other projects, and abandons the software that we're using, we're screwed. But if we use OSS, then we've got the source code, and can continue to support ourselves. Plus, when that happens, we've developed enough internal expertise with the software that it's not too difficult for us to support ourselves.
Apache, in particular, has been a huge boon to us. It's so easy to write modules for Apache that we've got our server packed to the gills with custom modules to perform certain session management and dynamic content tasks for us. These have improved our website's speed and maintainability by a huge margin. (some of these modules have progressed far enough that we're nearly ready to contribute them back to the Apache project.)
In hindsight, we made one big mistake with our OSS work. That is, whenever we brought some new OSS project on board, we would assign it to one engineer, and that engineer was to become our expert on that system. We spread this load around so that no one engineer would be overburdened. But what we should have done (in addition) was to have a "debriefing" a couple weeks after the assignment, so that that engineer could brain-dump a portion of his expertise into the rest of us. As it happened, we had engineers leave us (which is the usual case in engineering) who were the only people with expertise in a particular piece of the puzzle. And when that happened, we were left scrambling to redevelop the lost expertise. It all turned out ok, but it might not have.
These days, as a large result of using OSS wherever possible, we're in a very good position. Nearly all of our competing ad networks have abandoned the market for greener pastures, and that includes every ad network that's bigger than us except for 24/7 and doubleclick. The other big guys have switched to licensing their proprietary ad servers to other ad networks. As a direct result of our adoption of OSS, our total monthly technology costs are trivial, and we can survive comfortably on a truly tiny number of sales in a month. Having leaned heavily on OSS software, we were also able to focus a lot of our engineering on automating the administration of our system to a large a degree, so our administrative burdens are also tiny. This is letting us ride out this deep depression in our industry without worries, and when things turn around we'll be in a very enviable position.
The only downside to OSS is that there are a large number of licenses to read and discuss with our legal department. This number is, of course, similar to the number of licenses that we would be under if each individual portion of our website used equivalent closed source projects. However, closed source projects tend to bundle multiple pieces together under a single license, so we would actually have fewer pieces (and hence fewer licenses) if we used closed source. What's worse, many OSS projects use licenses that are superficially the same, but contain modifications that are specific to that project. So, though it's tempting to read the opening clauses and conclude that the license is the same as this other license that we already analyzed, it's foolish to do so.
But the bundling phenomenon of closed source projects is actually a disadvantage. Since no closed-source project satisfies all our needs, we would definately need multiple. And if different closed-source pieces overlap in their bundling, then either we have to reject a piece that we'd like to use, or we'd have to find a way to disable the pieces that we don't want to use. That's always a pain.
-- Nolite audere delere orbiculum rigidum meum.
Yes, as an undergraduate. By that point, I had already been programming for 10 years (I started programming when I was 12, in assembly, on an Altos 5-5D "minicomputer").
There are two things that you apparently don't realize.
The first is that academia is overwhelmed by politics and jockeying for position. This is most prevalent among graduate students (who are struggling to attract influential professors as research sponsors) and among associate professors (whor are struggling to advance along the tenure track, which has progressively fewer openings the farther you travel). In academia, it's not the project that matters, but how you're able to leverage that project for personal advancement. Yes, the corporate world has politics as well, but aside from a few rare companies, corporate politics are babies struggling over teddybears in the crib compared to academic politics.
The other thing that you don't realize is that the nature of user interface design is that it is subtle. You need to come up with mechanisms that help the user out without the user being made aware that they're being helped out. That's the whole game. So if you come up with a successful mechanism, that mechanism is, by the very nature of the game, subtle.
Here are the details:
When I came on board, vertices were selected by clicking the mouse within 20 pixels of the vertice's location. When you have a lot of vertices on the screen, these regions overlap, and the specific vertex that gets selected when you click in an overlap is unpredictable (it depends on the ordering of the vertices in the data structures). You could even end up selecting a vertex that was scrolled out of the visible area of the layout.
My change was to define "pick regions". These regions were dynamic, depending on your view, the vertex density, etc. The way it worked was that I iterated over the visible vertexes (we had a data structure that made this easy, and also let us easily find the vertices closest to a particular x,y coordinate: that was another research project in itself). For any click location, I found the eight closest vertices. For each vertex, I calculated its weighted distance from the click location (I used distance-squared, rather than distance, for reasons that will become apparent). I found the vertex that had the smallest distance, and then I looked for the vertex with the second smallest distance. That second vertex's distance had to be at least 35% larger (that was a tunable parameter, and my experiments showed that 35% number to be the best) than the first vertex's distance in order for the first vertex to be selected. If that test failed, then no vertex was selected. All of these calculations were done using screen coordinates (pixels) rather than routing coordinates, so that the view parameters would get incorporated into the calculation. The net result of this is that each vertex was surrounded by a lumpy region that was "owned" by that vertex. Any click in that region would select the owning vertex. The regions were lumpy because their shape in any direction would depend on the neighboring vertices. But by using a distance-squared metric, the lumpiness was somewhat smoothed out, thereby avoiding long and counterintuitive peninsulae spreading through the layout (and spared me the cost of a square root calculation). The overshoot requirement ensured that there were gaps between every pick region, where a click wouldn't select any vertex. These gaps were about 16% of the vertex density (sqrt(1.35) ~= 1.16). So they were small enough that it would be hard to click in a gap, but large enough that any click that fell outside of a gap was unambiguously associated with the same vertex for both the computer and the user.
The change had two results: 1) when the user successfully selected a vertex, it was always the same vertex that the user intended, and 2) when the user was being ambiguous, no vertex would get selected. The second possibility also existed in the previous mechanism, so it wasn't noticeable. And the first possibility meant that the users never ended up selecting the wrong vertex.
So, yes, the change was subtle. It wasn't subtle to someone looking at the code, but at that time the UI was 5MB of dense X11 and Motif code, so the researchers never ventured into it. We also had a standing policy that no one was to touch anyone else's module, and if anyone needed UI work done, they were to come talk to me to code it. This all means that they never even looked into the code until after my bombshell was dropped.
-- Nolite audere delere orbiculum rigidum meum.