wiki:DEVELOPMENT_OVERVIEW

Version 51 (modified by boyan, 16 years ago) (diff)

--

  1. 0. The Setup
  2. 1. The Project
  3. 2. The Process
  4. 3. The Product
  5. 4. Extras

0. The Setup

This is a step-by-step tutorial for installing the tools used during Sophie2 development.

Accounts creation. In order to communicate with team members, you must create the following accounts:

  • Google groups: ​Developers Mail Group, ​Users Mail Group. You must have a gmail account to apply for membership.
  • Skype account: provide it to our Human Resource Manager and you will be included in the group chat.
  • SVN/Trac accounts: ask someone from the team for these.

Workstation setup. Every machine in the office should have at least two users: one for private usage (you choose your username and password) and one for public usage(ask a team member for the username and password). A text editor is necessary (for example, Notepad++, you can download it from ​http://notepad-plus.sourceforge.net/uk/site.htm). Other important software: web browser, PDF reader, Flash player, Skype, Sophie (​http://sophieproject.cntv.usc.edu/).

SVN setup. Subversion (SVN) is the version control system that we use. On Windows you can use TortoiseSVN (download it from ​http://tortoisesvn.net/download). The official site of SVN is ​http://subversion.tigris.org/. There you can find SVN binaries for other OSs. You must install the Subversion client in order to continue to the next step.

Repository setup. Once you have installed SVN, you can download the repository on your own machine. Basically, this means you will have your copy of the project. In Windows, just choose a folder on your drive, right click and select SVN Checkout. Further explanation for the repository links / structure / rules for committing can be found at PLATFORM_STANDARDS_REPOSITORY. Just before you continue to the next step, you should know how to submit a file to the repository (for example, your daily report).
1) Create the new file in the desired folder (for reports, it is /manage/reports/{current iteration}/. The format of reports is explained below, in the "Process" chapter).
2) Use "svn add" to schedule the file for committing to the repository.
3) Use "svn commit" to commit it. Attention: committing without comment is NOT allowed!
A sample book about subversion can be found at ​http://svnbook.red-bean.com/.

JDK. Since Sophie2 is written in Java, it requires Java Development Kit (JDK) in order to develop it, and Java Runtime Environment to run it. JDK can be downloaded and installed from ​http://java.sun.com.

Maven setup. Maven is a software tool for Java project management and build automation. Downloads and installation instructions are located at ​http://maven.apache.org/download.html. A tutorial for building with Maven is written here: PLATFORM_DEPLOYMENT_BUILD_MAVEN. If you build the project with maven, you would probably need to open sophie2-platform/old/lib/readme.txt and read the bottom lines.

Eclipse setup. The software platform we use for developing Sophie 2 is Eclipse. First of all, the installation. Download the latest eclipse version from ​http://www.eclipse.org/downloads/ and install it to your computer. Then, modify your compiler settings according to the COMPILER_SETTINGS document. The next two steps, Subclipse installation and Maven integration, are described in PLATFORM_INFRASTRUCTURE_OVERVIEW. The most important for these is that they are eclipse plugins, which integrate the subversion and maven functionalities in Eclipse. The M2 plugin is required for loading our maven project in eclipse. Once you have installed the plugins, you can follow the steps from PLATFORM_DEPLOYMENT_BUILD_ECLIPSE, which describes how to import Sophie2 in Eclipse and run the FakeAuthor configuration.
You already have everything needed to develop Sophie2 :)

1. The Project

The Goal. The most important part of a project is its goal. So, the goal of our project is to take the good aspects of Sophie and optimize them, add features as well as to remove others.

Schedule. The Sophie2 project is split into about 600 tasks, each with one or more revisions (in total, about 2000). These tasks have several states, and you will learn about them in the next chapter. The tasks are divided into 12 sprints (iterations). Each sprint is about 1 month long. The methodology used for the schedule of the project is not exactly SCRUM, but is similar to it. For more information what SCRUM is, read ​http://en.wikipedia.org/wiki/Scrum_(development).

Layers. Task names are also grouped in several development layers:

  • PLATFORM: specifies coding standards, platform structure, plugin structure, as well as tools for building the project.
  • CORE: the smallest layer; it provides fundamental functionalities for every part of the platform. It includes the properties library (ProLib), logging, and modularity.
  • BASE: provides basic GUI (menus, halos, palettes, layout).
  • MAIN and EXTRA: they contain the main functionality, which makes Sophie2 a complete platform. These two are split according to the dependencies, so that MAIN does not depend on EXTRA.
  • SCS: Sophie community server. It includes the Trac system we use, the Subversion, provides information for the external contributors.
  • S2S: Sophie2 server. This is the server product.
  • SUPPORTING_ARTIFACTS: the project schedule, the backlog and the process are categorized as supporting artifacts.
  • END_PRODUCT: here are a few tasks related to application tuning and creating user help.

Additional. The non-development side of the project is described in the PROJECT_OVERVIEW document. This includes information about t Astea Solutions, Sophie, the license we use, and other useful things.

2. The Process

This chapter includes the states of each task until it is completed, the rules you have to follow when performing a task, some good/bad examples. The "writing reports" thing is also placed here.
Generally speaking, every task must first be analyzed, then a design must be made, and finally the design is implemented. If the task is a coding one, its implementation is tested. After each phase, a review is made. The tasks, sorted by iterations, can be looked at http://sophie2.org/trac/roadmap. The exact task states and much more are described and regularly updated at PROCESS. This document is fundamental, so read it carefully. Also, tasks are of several different types. For an explanation what the types are, read PLATFORM_STANDARDS_GENERAL.
Every state of a task is important. However, here are the existing recommendations for performing various actions:

The process is executed with the help of Trac - the issue tracking system we use. If you have problems with using it, go to TracGuide.

3. The Product

Design. Here will be some of the main design features, which are present in Sophie2.

  • Plugins: software units. In the context of our project, "plugin" is the same as module or bundle. In Eclipse, they are actually represented as different projects. Have a look at platform structure. There you can see where modules are located and what their structure is. Decomposition to plugins of Sophie 2 is one of the most important things to do for the project. If you need to create a new module, one of the ways to do this is described in how to create a new module.
  • Extensions / Extension points: these are used to reverse the dependencies so that we cannot have cyclic dependencies in the project. The other advantage of extensions is that they provide extensible functionality.
  • Editions: different standalone subsets of the Sophie 2 platform. Sophie 2 has 3 editions: Author, Reader and Server. The page dedicated to editions provides information about the plugin editions structure.
  • Distributions: the distribution is the end product a user will see on his/her hard drive after installing the edition. In order to be fully functional, a distribution has to provide executables and/or some other needed resources. The problem here is the way we provide these things, and the solution is the /distrib directory (look again at platform structure).
  • High-level design. This refers to the Model-View-Controller (MVC) design pattern. Its purpose is to define how the model and the view interact with each other. There is an MVC tutorial at CORE_MVC_BASE. There is a problem with the standard MVC pattern: it is too complicated for this particular project. This is why Properties are introduced here. So, each model in Sophie 2 is defined by a property. This way the controller is replaced by Logics, and this simplifies the whole pattern. The properties are represented by the ProLib library, and you can read the important Properties tutorial here: PRO_LIB_CORE_TUTORIAL. This page defines useful code templates for properties.

4. Extras

You will certainly encounter a problem you cannot resolve on your own. You can find help:

Useful Links:

Comments:

You can write your comments here.