How do you go from idea to implementation when developing classes for other developers in other places?

Question

I am looking for inspiration in how to design classes from scratch in a project with several developers in different places (so no sessions without a board).

Suppose you are tasked with implementing a fairly large function that will be used by other developers later in the project. This function will require several classes and will interact with other classes that already exist in the project. Of course, you want other developers to take effect before continuing and implementing all this. Now, how do you go on?

I would start with the best tool available: pen and paper . But then what? I would like to materialize my lines and bubbles and notations on my paper on the screens of other developers. Is the best method to simply scan and email paper? Are there any good templates for writing a text design? Are there any online tools that can quickly simulate class design? Should I just write "skeletons" for classes and request feedback?

An important point to think about here is that the only message available is phone and email, as the developers are far apart.

Answer 1

I really disagree that "the only phone available is telephone and email." The network has changed a lot, and there are lots great new ways to do sharing and most of them are free .

Edit: list links

• Microsoft SharedView
• Adobe ConnectNow
• Skype
• Drop.io
• Google Docs
• Office live
• Skrbl
• Google Code Reviews
• Gliffy

Answer 2

Do not go to it in a Big all or nothing session where you are trying to create all the classes of the system.

Take 1 or 2 functions and start from there. Do not hold large meetings, instead carry out small small meetings at which you evaluate these functions. You can apply the lessons learned to the following. It will also allow you to delve into the details if necessary.

If it is integrated with existing code, ask the appropriate developers how it affects it.

If we are talking about different subsystems, keep the integration points at a minimum and keep them simple. Sometimes you simply cannot / should not embed the preferences of many other commands in it, but instead, another command makes a simple class that exposes your api in such a way as to make maximum use of their code. You do not want to complicate the situation by keeping simple things, usually the best way.

Also note that all of this investment in identifying integration points through these project meetings is mostly related if we are talking about subsystem integration. Large projects with teams working in different parts of it. You do not want to penetrate into any of the internal parts of the parts that they develop (unless you talk about architectural issues ... but you should have someone who can take care of this in these commands ...), instead You want to focus on how you will integrate.

Another thing is when you distribute team members working in the same part of the system as long as you have clean code (and that you should concentrate on the only feedback), you can continue to work with the team and turn the code into that really needed to be implemented. With these team members you should be in constant contact if the time zone difference becomes such that you should have at least 30-60 minutes of overlap ... you can get by and I did it, but the overlap really pays off.

Ps. I have been working with distributed teams for 4 years, and in both cases I mentioned above (different teams for the subsystems of a large project, one team working on a specific subsystem) and 2 of those years that were with globally distributed teams.

Answer 3

Use video conferencing: talk to each other using a micro laptop and let them enter your computer using VNC so that they can see your screen.

From this, any modeling / text editor should be used as support: Paint, Word, WinDesign, Objecteering, etc. The best way to communicate.

PS: I agree that pen and paper are better, but when it's for you, not for foreign developers. So forget to scan and email ^^

Answer 4

First, I start reading requirements and documentation and try to get an approximate sketch. This is mainly done inside my head and partially on paper. (I have very good memory.) The first phase of design is often removed from my computer! Ideas may appear in my head while I'm in the car. Sometimes I even get new ideas when you throw something stinky in a large porcelain pot in a very small locked room. In general, design ideas tend to await when they are quiet, and I have a chance to let my mind wander around a bit.

Almost two years ago I had a large project that needed to be designed. Another developer was already working on this, but he was completely upset, just leaving the company simply because after a few weeks he still could not find a good solution. So it was my turn ...

I had the advantage that I could work at home, and did so. I spent the first day in my bedroom, in bed with a pen, paper and documents. I had notes from my former colleague and I saw that he made things too complicated, so I began to divide the problem into smaller steps. I continued to spend paper on notes, doing calculations in my head, and comparing my notes with documentation and other notes. On this first day, I never used my computer.

On the second day, I began to introduce technical design and write code to test several principles. Nevertheless, I still spent a lot of time from my computer, although I took short intervals between them to take a break from hard thinking. It took a whole day, but in the end I had a whole concept on paper.

On the third day, I published my concept and shared it with my teammates. Although I continued to establish basic code requirements, they could begin to judge my design and point out flaws. They did not find them that day, although I left a few there.

The next day, my teammate and I began to implement the Proof-Of-Concept code, which would be needed to make everything work. For another two weeks, the entire beta was over and it just took some tweaks. That was what the rest of the team would do, and I went on vacation.

After returning from my vacation, the whole project was very successful, and the functionality was very well received by our customers!

So, the required materials: small rooms, pen, paper, bed, a lot of coffee, food and rest. Stay away from the computer and be lazy. (Laziness, I mean: Avoid writing code right away. Just think about what makes people think that you're just not doing anything ...)

When developing something for others to implement, you will need the first part of the design yourself, as much as possible. Just stick to big things, providing the opportunity for small things to add your team. And most importantly: rely on your team to take your work at a certain moment and be ready to retreat as soon as they begin to move!

Answer 5

I have no experience in this lack of co-location situation, but I agree with the idea that the pen and paper approach is best to start discussing design. Scott Ambler talks about using prisoners of war (plain old boards) ... same idea. The first approaches to modeling could be captured just by taking a picture with a digital camera, do not waste time on a fantasy UML layout using a tool until the model becomes more solid. Photographing a board saves a lot of time.

I assume that the use of video conferencing, proposed by Clement Herremann, is good enough to discuss the model, if you can share part of your screen, so everyone who conducts a conference call can see photos of the analyzed model.

Answer 6

Use UML, CRC cards and, like others, write video calls. In addition, services such as digitalsamba will allow you to share your desktop and any documents among any number of participants.

Answer 7

The first thing you need to do is write code that will use your interface. How do you want this code to work and look. Then start writing your code for this interface.

Ask the interface to help you, not fight the interface.

Answer 8

You can try using a collaborative thinking mapping tool, for example http://mind42.com/ It is not designed specifically for modeling classes or action diagrams, for example, but it can help collaborate in the exchange of ideas, is crucial.

In addition, you can use a version control system in which you can store not only prototypes and skeletons of the source code, but also model files (for example, from Rational Rose or your favorite modeling tool).

I used earlier to also store text documents in the original control that contained exceptions from class diagrams, but this was not so useful.

Answer 9

• Make sure you have clearly defined documented requirements.
• Everyone must review the requirements for an overview. One person may be responsible for the initial design. A design document can be as simple as a detailed list of how the requirements will be implemented on your system or as complex as a UML diagram with graphics, depending on the needs of your project.
• Use conference calling to meet and go through the design.
• Use the instant messenger to send links, hash information, and (later) to jointly troubleshoot if necessary.
• Some projects (especially open source) often have an IRC channel where developers and users can communicate, help each other, and sort things out.

Answer 10

SVN or CVS is required, so you should always access your employees and see existing interfaces and descriptions. In addition, all people on the team should use document markers in prototypes for an automated documentation system such as Doxygen. Thus, it is easy to create documentation for all other developers on the fly. This documentation should be available in the repository (mainly in the "doc" folder) so that you can update your working copy every day, as well as receive updated documentation.

Software development is also part of creating a big picture before one line of code has been written. Thus, for the entire project or part of the project, there must be a mindmap diagram, a UML diagram, a block diagram, etc. Therefore, it is easier to understand for other developers who have come to a new project.

Since you have descriptions of the interface with the generated documentation, this is not a problem for creating your prototypes. Due to mindmap, UML, flowchart, etc. You get an idea of ​​all this. Documentation markers should also include something like "@author" so you can easily contact them if you need a deeper description, if something is unclear. This is often a good idea if people use the messenger (MSN, ICQ, ...) so that you can easily contact them. Often his only short question is, so there is no need to call someone or write mail (where you end up getting the answer the next day)

Rapid prototyping is another thing in the game. The question is whether the classes are for a graphical interface or if it is “just” the program logic. There are many tools for the GUI for accessible frameworks that can generate classes, so you only need to implement the internal logic (event handling) and interfaces for your co-worker classes. For other parts, I suggest a UML tool (basically you only need a class diagram). Linux has free tools like ArgoUML. These tools can generate most of the class design for different languages ​​(C ++, Java)

Answer 11

Keep it simple on your blog.

Each developer can publish their ideas and progress, commenting on each other along the way. I have used this in the past and it was interesting.

If there is a client, manager or other interested party, they can see that people are active and working on things.

Answer 12

You can do worse than developing a common dictionary, not only to discuss a problem area, but also for a solution domain. In the field of solutions, instead of talking about specific classes, describe your potential solutions in terms of design patterns .

I am sure that they are already familiar to you, but if they are not there, the template allows you to describe entire sections of the solution in terms of the reusable designs that it will use.