Serulian:Final Project Description
Project Name:Serulian
Team Members:Chao Cai(ccai@https://www.doczj.com/doc/fb17894205.html,),Joseph Schorr(jschorr@https://www.doczj.com/doc/fb17894205.html,)
Faculty Advisor:E Lewis
1Abstract
Web application development is rapidly gaining popularity.However,the development process itself can be a slow and painful one.To write a web application,one must create a framework and presentation layer for the client side browser,a logic and computational layer for the server,a database querying layer for storage,and often an authentication and access layer for security.This is not counting all the glue that links each layer to all others.We see all this tedious work as a problem,and would like to propose a solution.
Our project,Serulian,seeks to address exactly the issues mentioned above.The goal of the project is to create an easily adoptable development framework for creating powerful web applications.The core mechanism for development in Serulian is BlueSource,a fully typed,object-oriented language with a syntax very similar to existing languages such as C,C++,C#,Java,and JavaScript.In addition,we have provided an XML markup schema for describing the presentation layout of the program on the client side.Finally, we are also including a core library of functionalities and controls as a basis for building larger programs. 2General Overview
Over the last few years,we have seen web application development truly take o?.There is an ever-growing interest in creating applications that are accessible wherever you are,through a conventional web browser. Unfortunately,the web application development process itself is still long and arduous.First,one must learn and use one or more languages to implement the client side,another set of languages for server interactions, and possibly more for database querying.In addition,one must also deal with the infrastructure that glues the server together with the client.Cross-browser compatibility and security are more issues that must be addressed.This is a lot of work,much of which is especially wasteful because,for example,the same protocols to marshal data between the client and the server are written over and over.Even where libraries are pro-vided,the interface still must be learned and matched,despite how simple and repetitive some of this work is.
All web application development is divided into four key components:client side framework and layout, client side scripting,server side scripting,and database.Serulian is an e?ort to address the entire develop-ment system.Basically,it allows developers to write web applications with nearly the same simplicity they would expect from writing desktop applications.We created a new language with features that are designed speci?cally for dealing with such web behavior as querying and updating database tables,transporting data between the server and the client,and even structuring client-side presentation.
First,we’ve created an object-oriented,typed language framework that compiles down into JavaScript. This gives us the JavaScript bene?t of being able to run on web browsers without requiring the user to download additional software,which means that the developer can reach more end users.However,it takes away the unwieldiness of developing in JavaScript,the chaos of its loose typing,and the di?culty of?nding and?xing errors in an interpreted environment.
Second,we encapsulate and abstract much of the glue between client,server,and https://www.doczj.com/doc/fb17894205.html,ing the concept of state,we are able to express work processes such as serialization,transfer,and de-serialization as one abstract notion,and minimize the impedance mismatch problem that arises from client-server-database interactions by unifying data https://www.doczj.com/doc/fb17894205.html,ing server functions,we can extend the server-client unity by providing clear,de?ned entry points between client and server in the form of function invocation,a concept familiar to most https://www.doczj.com/doc/fb17894205.html,ing server classes,we wrap database tables and columns in an
object-oriented representation and allow code to deal with table data directly in code,rather than through indirect queries.
Third,we introduce a presentation layer compatible with major browsers,echoing the theme of reaching the largest user base possible.Its schema and style de?nitions will be reminiscent of such existing technologies as ASP and CSS,which allowing those who are already familiar with those products to easily transition into ours.It will include a wide set of controls out of the box which may easily be tied to written client code,as well as an extensible framework that gives?exibility toward construction of new controls.
3Related Work
In the area of web application development,there are numerous existing technologies that address parts of what we are attempting to do:
?Client side content layout:HTML,DHTML,CSS
?Client side scripting:JavaScript/JScript/ECMAScript,VBScript
?Server side scripting:Perl,PHP
?Server side database access:Oracle/MySQL/PostgreSQL
Our project seeks to provide a simpler,more uni?ed development process by allowing the user to specify the entire web application through just the use of BlueSource without having to worry about underlying client-server interactions that are standard to many web applications.
There has also been e?orts to simplify the web application development process,most notably through the Microsoft’https://www.doczj.com/doc/fb17894205.html,(https://www.doczj.com/doc/fb17894205.html, in particular)and Java’s J2EE.Both these platforms attempt to address the primary issue plaguing web application developers,that of a divide between the server and client side architectures.Currently,and without these platforms,any web application in development must have each half coded seperately in di?erent languages and frameworks,resulting in a large amount of tedium when trying to get them to work together in harmony.Each platform addresses this issue by reducing the work down to coding for the server side,with client side scripting either being generated automatically(in the basic case of J2EE)or having the language used for both client and server be one and the same(in the case of https://www.doczj.com/doc/fb17894205.html, using JScript or VBScript).Ultimately,however,each of these platforms much work within the limitations imposed by the divide,as they merely give the illusion of bridging it.In addition,and perhaps most important,these platforms,by trying to bridge the divide fall the”one-size-?ts-all”dilemma,where they can handle server side and client side well,but neither extraordinarily(in general,they work much bet-ter on the server side,rather than the client side as they have a larger selection of languages to choose from.) Within the academic community there has also been investigations into the architecture of web-based applications2,as well as potential productivity gains from integrating several facets of the application en-vironment3.However,must of this work remains either theoretical or”toy”-ish in nature,without a true infrastructure for large application development.
In terms of speci?c concepts we are introducing,we are able to draw analogies to previous work.For example,the concept of state is much akin to serialization,where every object is transformed into a form for ease of mobility over the network and between logically separate executable entities.We simply took this a step further and introduced the idea of snapshots and entrypoints which,as we will later describe,root state in as a core part of the language.
Server functions on the other hand may remind one of remote procedure calls,which allow for a client to remotely delegate execution to a server,which then returns the requested data when done.We simply once 2Deriving Architectures of Web-Based Applications,by Weiquan Zhao et al.
3A Combined Runtime Environment and Web-Based Development Environment for Web Application Engineering,by Martijn van Berkum et al.
again have built them directly into the language so that with the use of just one keyword,the function may be marked to execute on the server instead of the client.
The querying capabilities of server class have pre-existing roots in The LINQ(Language Integrated Query) Project,which focuses heavily on merging SQL-like syntax with conventional code so that database queries may be more e?ectively integrated into the language.Here,we adopt a similar idea,mapping classes to tables and class instances to columns,allowing for speci?cation of table columns with special class variables, and placing select-from-where structures directly into code expressions.
We feel that our main point of innovation is in integration of all of these seemingly separate concepts into one overarching development framework.Had we implemented each on its own and branded everything as one product,we would not have achieved much at all.Instead,we are combining them to realize the potentials of a greater system.For example,with the concept of state,we can marshal and unmarshal arguments and return values by having the sender simply encode data into state,and having the receiver decode state back into data.Furthermore,just as the original creators of the?rst compilers realized that coding in assembly was too tedious and abstract constructs such as loops and conditionals may ease the development process,we are now realizing that some existing technologies like JavaScript are becoming the new”low-level”,where abstract concepts such as state and server classes may hide a lot of the tedium so that developers may focus on the next steps in creativity.
4Language Features
Here,we will assume familiarity with most aspects of object-oriented programming,and only describe in detail those language features that deviate signi?cantly from existing practice.
4.1The Basics
Our benchmark comparison language will be C#.In C#,each class creates a new derived type.This is no di?erent here,except that we took it a step further and corresponded each primitive type(such as int and string)to a class as well.Each class may have class variables and functions,and in addition may also have more complex constructs such as properties,operator overloads,indexers,and enumerations.Modi?ers such as public,private,and protected have the same meaning here as they do in other languages.Class elements may be declared static,although some constructs such as enumerations are inherently static and hence do not need to explicitly be de?ned as such.
BlueSource adopts single inheritance,but each class may implement multiple interfaces.The type in-heritance tree is rooted at BlueCore.Primitives.Object,and reaches every class in the system.Subtype polymorphism is implemented essentially the same way as in C#,where subtypes may be placed where supertypes are expected.Furthermore,types may have generics similar to Java5and C#2,allowing for the creation of generic container classes such as List.
Within functions,each logical unit of execution is a statement.Statements include local variable decla-rations,expressions,and control?ow structures.Within statements,often expressions are expected to deal with basic units of computation.Expressions may refer to variables on various naming scopes,literals,or be a combination of operators and operands to describe complex operations.
With respect to naming scopes,on the highest level BlueSource uses a namespacing system similar to that of C#.Every class must be declared within a namespace,and every class may be globally accessible from anywhere by their fully namespace-quali?ed name.On the next naming scope level,if class A and class B are declared within the same namespace,then B may refer to A without attaching the namespace pre?x.The third level is that of class elements,so any code within any class element may refer to other class elements on the same class by their name.Fourth,within functions,function parameters and local variables declared within current and parent scopes may be referred.Local naming scopes may be created with curly braces,so that arbitrarily deeply nested scopes may be created.
For an example,see Appendix8.1
4.2State
Our?rst major deviation from the conventional modern-day object-oriented language is the concept of state. The fundamental idea here is that every object,in addition to its native data representation,has an asso-ciated XML representation that we call its state.By default,there is a representation where all member variables are recursively stated,so that upon conversion back from XML into data,we are guaranteed that all needed information may be restored.However,if a developer knows that only certain information is required to save and restore the object’s state,the developer may use a class element named state to write a custom speci?cation.The state construct is a special property containing two portions:a snapshot block that described how to transform data to XML,and a entrypoint block for going from XML back into data.
A major source of tedium when coding web applications is the marshaling and unmarshaling of data when data is sent over the network.State allows for a standard serialized format applicable to all objects, so that dealing with such network protocols are no longer a?rst priority but are rather only an advanced optimization.Even any work left to optimize information storage is simpli?ed,as each class can rely on the fact that all other classes are properly stated to only worry about direct information it is holding,rather
than handling its member variable’s state de?nitions directly.
A second major concern is state preservation of web applications,which is why we originally arrived at the notion of state.Here,we take an analogy to desktop applications where,at the worst,a snapshot of the process’s local memory may allow for somewhat ine?cient saving and restoration.The default XML state of an application is the”local memory”in the web context,so we can save that onto the server,attributing the state to some user if authenticated,or a cookie reference if unauthenticated.In a desktop saving,most applications have much more e?cient saving mechanisms,partially because it is easy to specify which pieces of data to save and restore.The snapshot and entrypoint blocks provide the same ease,so that in a web context the developer may also simply specify what to preserve.
For an example,see Appendix8.2
4.3Server Functions
Server functions allow any function to be marked to execute on the server rather than the client.These are important if there are sensitive operations,for example authentication and database access,that should be handled on the server.Also,if there are frequent database accesses within a code section,then executing that code on the server will reduce the total overhead of transporting data back and forth between the server and the client.Without server functions,a developer would have to learn a server-side language,write the code that will handle the server-side functionalities without many of the features found in BlueSource, and interface with BlueSource’s state system on the raw XML level.With server functions,the developer only needs to add the server modi?er in front of a function,and that code will at runtime execute on the server.The network exchange between client and server will happen upon dispatch and return of the server function,and to the calling function,there will be no apparent di?erence in calling a client function or a server function.All of the network protocol handling will be done implicitly,so that the developer will not have to worry about any of it.
For an example,see Appendix8.3
4.4Server Classes
We next looked into directly interfacing with databases through BlueSource.Here,the two major concerns are creating and updating tables,and querying them.Aiming for an object-oriented data abstraction to tables,we introduce server classes.When a class is marked with server,a table for it is created in the server-side database.In addition to normal class variables,?elds may be created that act like class variables but directly correspond to columns in the database.Each instance of the class,on the other hand,map to a row in the database.When a new instance of the server class is created,a new row is inserted into the database,and modifying the?elds on that instance will result in database updates on the corresponding columns of that row.
For querying database tables,we adopted the LINQ approach of embedding SQL-like syntax directly into the language.As of now,the SQL expression is only valid on the initializer of a local variable declara-tion.The queries are in the”FROM TableName SELECT*WHERE conditions”form,evaluating to a List containing objects of the type corresponding to the queried table.We plan to move to far more complex queries in the future,but this groundwork demonstrates the capabilities of BlueSource to directly integrate table data into its?ow of execution.
For an example,see Appendix8.4
4.5SIML
The Serulian Interface Markup Language(SIML)is an XML format closely integrated with BlueSource to describe the client-side visual layout of the application.Technically,we could have allowed BlueSource to
directly manipulate the browser’s Document Object Model tree,and that option is still available since we are wrapping JavaScript libraries to work with BlueSource.However,as one of our primary goals is ease of development,we sought a more clean and concise format that better conveyed visual information.
Just as every object has an associated string representation in Java and C#,in a web programming con-text it would also be convenient for them to each have an associated layout to be easily embedded directly into the application’s visual layer.By default,an object’s associated SIML representation is as simple as the object’s class name in a string formatted for browser display.However,by creating a template for a class, the developer may de?ne in XML how the class will appear in the browser.For example,if the class is a calculator,then the developer may specify where the display digits(likely a numeric member variable)will be positioned,where each button(likely stored as a List of Button class objects)will appear,and so on. Note that the buttons may then recursively look into their templates to render themselves.
For an example,see Appendix8.5
5Technical Approach
We will now discuss how various aspects of our projects were implemented.
5.1Lexing and Parsing
We used the ANTLR compiler construction framework to create a C#lexer and parser by describing the structure in a grammar?le.Our lexer and parser are LL(k),with a lookahead of4for the lexer and a lookahead of3for the parser.The result of this stage was an AST(named BlueAST)that closely mirrored the original parse https://www.doczj.com/doc/fb17894205.html,ments and whitespace are ignored at the lexer level,while line numbering and?le information is collected at the parser level.In a few locations,due to the complexity of our language,we were forced to employ syntactic predicates,which allow for potentially ine?cient backtracking to simulate”in?nite lookahead”.However,we minimized the usage of such backtracking to reduce the associated performance penalty.Looking forward,we may be able to improve here by converting to LALR parsing in an attempt to remove the necessary backtracking and reduce grammatical ambiguity.
5.2Scoping
Here we’ll discuss how we constructed an intermediate representation suited for the later stages of typecheck-ing and compilation.The term”scoping”is used to represent the building of names for each logical object within the abstract syntax tree.For example,items such as classes,functions,properties,and variables must be scoped,to de?ne how their names are referenced later in code.
5.2.1Annotated AST Generation(BuilderObjects)
We next traversed the BlueAST structure in C#to create an annotated abstract syntax tree representation dubbed BuilderObjects.To describe various sets of AST node types,we created an interface describing the behavior expected from each set.For exampled,anything implemented the IFunction interface would have the properties of a function,including a name,a parameter list,and a return type,whereas anything implementing the IExpression interface may be placed wherever an expression is expected.
Ideally,we would prefer multiple inheritance since many of these behaviors are exactly the same for the majority of expressions.However,we were able to simulate multiple inheritance by having tree nodes derive from a base class named BuilderObject,and de?ning the behavior there.As an extra safety net,for an interface-speci?c function or property,we checked through re?ection that the current object does implement the expected interface before allowing the code body to execute.The C#”is”keyword was very convenient in this respect.
5.2.2Static Type Information(BlueType)
As we generate the AST,we also create objects that store relevant type information to be used in later stages. The class BlueType encapsulates such information as the name of the type,a reference to its base class,and additional information such as the implemented interfaces,type parent,and any generic type parameters. However,because we attempted to generate as much relevant naming,typing,and scoping information in one pass,we run into situations where referred types may still be in raw parse tree form and hence we currently have no information on such types.Hence,we delay the population of most type information to a single second pass where resolution of the types attached to typed items are done.
However,because types may refer to other types because of parent relationships,generic relationships, and so on,some type objects are in fact not resolved when they are?rst accessed and are forced to resolve at that time.This opens up the potential problem of cyclic resolutions,where types are trying to resolve based on information from each other.We have worked around this problem in the current implementation by marking types as resolved before such cyclic dependencies may occur,but a major future improvement here will be to break down type resolution into multiple passes,so that only the class and class element level information are fully collected in the?rst typing pass.Subsequent expressions and statements would then
have full access to this information and will no longer need to defer type resolution as we do right now.This hierarchical approach to type resolution will clear out the cycle problems mentioned above.
5.2.3Namespacing Information(NamespaceRegister)
When a class is created,it may be declared inside any arbitrary namespace.Hence,we need a global namespacing system such that each namespace level contains classes and sub-namespaces on that level.We use namespace registers for this purpose:the Global Namespace Register(GNR)contains references to top level namespace registers,and each of those contain their own classes and https://www.doczj.com/doc/fb17894205.html,spaces may be nested arbitrarily deep in this fashion,but no two namespace elements(interfaces,classes,sub-namespaces) may share the same name.For example,if BlueCore.Primitives.Integer were the only class in the system, then the GNR would contain one entry for the namespace BlueCore,BlueCore would contain one entry for the namespace Primitives,and Primitives would contain one entry for the class Integer.
5.3Static Typechecking
Once the nodes of the abstract syntax tree have been properly scoped and typed,it’s time to verify that the code is actually in working order.Type mismatches can frequently occur,especially in transitioning from an untyped language such as JavaScript to a typed language like BlueSource.
Typechecking is performed in a recursive-descent fashion,from the program level down.In general,each BuilderObject recursively typechecks its children before typechecking itself.On the class and interface levels, naming and inheritance rules are veri?ed.On the statement level,return type conformance and such rules as no break statements outside loops and switches are applied.The majority of operational type conformance and resolution are determined on the expression level,where type relationships apply almost everywhere.At any time,if a type error occurs,the compiler will halt and report the error with as much relevant information as possible.
5.4Compilation
Once the code has been determined to be staticly type-safe,we can then move into compilation.Once again, the strategy is recursive descent.In the current implementation,we simply pass around a CodeBuilder object which accumulates the string to be outputted to the resulting output?le.Many of the simpler constructs are directly translated into their JavaScript equivalent,while more complex elements require extra code to be inserted.For expressions whose type must be veri?ed at runtime such as cast expressions,a runtime type system is maintained.
For each class,a prototype of the class with all its functions,variables,and other class elements are cre-ated.JavaScript allows for functions to be declared and stored into variables,so that we may represent all aspects of a class with a single object and refer to that object when we need to access that class’s members. Each class is saved into its own source?le,loaded only when necessary.Furthermore,a scope?le(extension .bsco)is also created,containing only class level and class element level data in the form of XML.Think of the scope?le as the BlueSource equivalent of an automatically generated header:this is how BlueSource development can be componentized.The scopes act as the interface,hiding the underlying implementation details.
Another major improvement may be applied to this aspect of the compiler.While code accumulation is ?ne for simpler languages,for a language of our complexity it is becoming growingly cumbersome.We are considering,as a next step,designing a linear intermediate language representation that translates down to only simple JavaScript constructs of loops,conditionals,variable declarations,and expressions.BlueSource will?rst map to this internal representation,which then turns into JavaScript,our”assembly”.
5.5Just-In-Time Dynamic Loading
Code retrieval takes up a lot of the load time of a web application.To relieve this burden,we implemented Just-In-Time Dynamic Loading(JITDL)available for all classes.Essentially,when the application?rst starts up,only those classes marked with a Preloaded attribute are directly fetched.The rest of the classes are not immediately loaded,but rather a class shell is created in its place.When the class is?rst accessed, a round-trip to the server replaces the class shell with the actual class de?nition.This reduces initial load time by a potentially enormous amount,since otherwise classes may refer to other classes and create a chain of load dependencies.
5.6State
Despite the novelty of having a language-level correspondence between data and XML,state was not di?cult to implement.Once snapshots and entrypoints are parsed and compiled into JavaScript,they themselves are as XML generating and parsing code blocks,acting as the conversion function between XML and whatever BlueSource object they are attached to.
To take the XML-data interchangibility idea even further,we allow for XML to be declared in code, which are recognized as literals of type XmlNode.We also introduce a”create”function that takes in a type on its generic parameter and a block of XML as its argument,and attempt to apply the entrypoint of the speci?ed type to the XML to instantiate a new data object.This is simply an application of state,and other than syntax parsing,was mostly achieved with just BlueSource code library additions.
We attempted to preserve the notion of reference equality with state.A unique hash is associated with each object in the runtime system,which is stored onto the state of an object.There is a global reference table mapping hash IDs to existing copies of state,so that no state XML is generated twice.When restoring XML back to data,this is also helpful in identifying where two references should point to the same object, so that reference equality comparisons and dependencies are not distorted because of stating and unstating.
5.7Server Functions
State in fact takes care of a very important aspect of server function implementation:marshalling and un-marshalling of data on the two sides of the network.When a server function is invoked,the arguments are stated and sent to the server,the server unstates the arguments,executes the function,and sends the return value back to the client after stating it.The client then unstates the return value and continues on executing as if the server call was a local call.
Originally,we had envision server functions to be a prede?ned set of common library calls written in Perl that BlueSource code may invoke natively,similar to raising system calls.However,we wanted to give users the?exibility to specify what they want executed on the server,as well as the simplicity of applying the BlueSource they already know to the server.Hence,we employed a technology named SpiderMonkey that allowed Perl to execute JavaScript,so that nearly all code written may be executed on either the client or the server.Hence,if a server function needs to make calls to other functions in the program,there is a server copy ready to execute.
The only exceptions are client-speci?c functions such as presentation manipulation(JavaScript alerts are a good example)that must be done on the client,and these may be marked with the”client”keyword.If a server function,in its course of execution,calls a client function,then an exception will be thrown.In the future,we hope to staticly build the call graph and check for execution dependencies,complaining before the compilation stage if there is a server to client dependency anywhere in the system.
5.8Server Classes
Our next step is interfacing with the database.As a reminder,we are binding classes to tables,?elds to columns,and instances to rows.In addition to the columns determined by class?elds,each row also has an
implicit reference ID so that they may be uniquely identi?ed and retrieved quickly.
Table creation and updating are done through wrapper calls in Perl and SQL to the database.Tables are created when the application is?rst deployed,since all relevant tables are staticly determined.Row creation occurs on the instantiation of a new object,and involve simply a call to a prede?ned server function that takes care of SQL-side transactions.Updating are handled in a similiar fashion.Querying involves translating the BlueSource querying expression syntax to the actual SQL syntax,and we have created a translator to MySQL for now.In the future,we plan to make this e?ectively database-platform-independent by providing translators to major database querying languages.
Handling query results is a far more interesting problem.Technically,a very ine?ciency but correct approach would be to simply retrieve the entire returned rowset and use it on the server or state it for the client.However,we thought of scenarios of hundreds of thousands of rows,and wanted Serulian to be able to scale well even against such massive databases.Hence,when queries are invoked,we only return the?rst x rows,betting on the common case that the results will be accessed in order.When a row outside the selected range is requested,we preserve the last set of rows selected,and go to the server to fetch a range of x rows that includes the requested row,exploiting the spatial locality condition that nearby rows may be requested next.In a way,this is very similar to hardware caching,and we can derive some interesting techniques for which rows to choose.As of now,x is a?xed constant defaulted at a reasonable number like 20,but the developer may override that constant to allow for smaller or larger blocks of rows to be fetched at once.In the future,we are considering application of machine learning techniques to adjust parameters such as x to optimal values based on runtime experience.
In this?rst iteration of Serulian,because of time constraints,we sacri?ced e?ciency for correctness in choosing to update synchronously.While synchronous updating may sometimes result in long waits for round-trip results,we are guaranteed data integrity within the database.Currently,to alleviate this problem, we introduced update blocks whereby a developer may defer all database updates until the end of the block. Looking forward,a safe approach for statement-by-statement updates would be to timestamp all rows by the time-of-last-update.If a request to modify a row has been issued by the running program,then we will ?rst fetch its corresponding row in the server.If the time-of-last-update is later than the time of fetch of that row by the running program,then a concurrency exception would be thrown.The default handling of this exception,at the top level,would be to alert the user that the last write could not be done because the underlying data had changed,and request that the user reevaluate the data given the new value in the database.
5.9SIML
At its very core,the implementation of SIML is simply manipulation of the browser’s Document Object Model.Each object is associated with a template,and at runtime,the top presentation level object(usually the Application class)is inserted into the DOM and begins rendering its own template and calling its chil-dren’s render functions.However,SIML is more than just manipulation of standard HTML elements,for that would eliminate the possibility of colorful and stylistic web applications that technologies like Flash o?er. With the introduction of Scalable Vector Graphics(SVG),drawing and rendering shapes in the browser is becoming easier and easier.Taking a forward-looking approach,we adopted SVG to render native Serulian graphical objects such as rectangles and circles,which then build up to more complex layouts.This allows us to scale our graphics to?t regardless of the browser window size,a huge bene?t over rasterized images.
While SVG works on the latest Firefox and Safari browsers,a major downside is that it is not currently supported on Internet Explorer without a plug-in.However,Microsoft(as usual)already has their own ver-sion of vector graphics built into Internet Explorer named Vector Markup Language(VML).Hence,we take a dual compilation strategy:both SVG and VML rendering code is generated from the SIML?les.When the client browser requests the layout of the page,the proper code is returned depending on the requesting browser type.
However,to maintain our focus on application reach and hence cross-browser compatibility,we are considering the possibility of rendering graphics on the server and sending them to the client as images in the future.This will be an all-else-fails plan that will be applied less and less until the old browsers are all but retired.
5.10Other Features
Here we will discuss implementation of features that may not necessarily be crucial to the core functioning of Serulian,but are nevertheless extremely convenient and helpful once implemented.
5.10.1Generics
Type parameterization is in fact one of the most complex features implemented in BlueSource.It allows for simpli?cation of code in a lot of instances,the most canonical being generic collections such as Lists.To implement generics in static typechecking,rather than cloning the class like many other compilers,we decided to directly pass the generic information along in the type and scope objects that are associated with relevant BuilderObject nodes.This is far less memory-intensive,but require much more intricate information-passing. Especially tricky are expression level function invocations and member accessing where generic instances on variable declarations must be preserved,and inheritance chains with generic parents where the generics of each class must be satis?ed with the generic instances of their direct children.The manipulation of these hashtables were originally scattered throughout the BuilderObject tree,but a recent refactoring has allowed us to encapsulate them into the ScopeInstance object,which takes care of typing information and member resolution.
5.10.2Iterators
Taking a page from C#’s implicit iterators,we created a similar iterator construct as a class element that is,while not essential to Serulian,nevertheless a very convenient feature to have.
Iterators within object oriented languages are generally one of the most used,yet least understood and therefore,least implemented,features.In languages such as Java and version1.0of C#,to properly imple-ment an interator,one would have to create a new class for each existing class,derive it from a prede?ned interface,and have it return the items in the proper order using normal coding rules.Although this appears at?rst to be relatively easy to do,in practice,for the more complex data structures,this can be quite tedious.Thus,we felt that having the ability to implement iterators”natively”would be of great bene?t. The usage of iterators is as follows:Within any given iterator construct,the contents of the primary block are the same as any function with a few important di?erences.First,the keyword yield return,is used in place of return.This statement tells the iterator to return the speci?ed expression when the iterator reaches that statement.In addition,a yield in statement allows the developer to return not a single expression,but in fact the contents of another iterator,given by the expression to the statement.Finally,the yield break statement indicates that there are no more items remaining to iterate and that the calling foreach or yield in should terminate.Multiple yield return s may be used to return items,and they are returned in the order in which the yield return statements are encountered.This continues until the end of the code block is reached,or a yield break is encountered.
For an example,see Appendix8.6
The implementation of iterators in Serulian is a bit more complex than it is in C#.Normally,implicit iterators are implemented by simply generating the code into a state machine of sorts,using gotos to continue where the iteration code last left o?.Unfortunately,the goto statement is not supported in JavaScript,and as such,we had to improvise a way around this fact.This simulation is done as follows:A state machine is constructed as in C#,however,each statement that would be compiled into its native form is instead simulated by a set of additional states.A prime example is that of a while loop.In this implementation, a while loop is transformed in a state which checks the condition,a state that executes if that condition is true and a state that jumps after the loop if the condition is false.By having the state machine jump to the
”check”state at the conclusion of each while loop iteration,we can simulate a while loop without actually creating one.This method is used for all other statements,save try-catch,which is not allowed to contain a yield statement,and thus,can be compiled normally.
6Conclusion
In conclusion,we have developed a framework for web application development that aims to be both easy to adopt and powerful to use.We have completed the originally planned goals for the semester and added on many unanticipated language features along the way,such as function level generics,iterators,and even the entire concept of server functions.Looking back,given the time constraints we were under and the other academic responsibilities we had,we are content with our progress to date.Looking back,we should have planned ahead even more for compiler extensibility than we had,to avoid costly refactoring later on.However,we planned enough and introduced enough modularity such that even when the inevitable refactoring occurred on the scoping stage,few things from other stages really needed modi?cation.Other than that,we just wish we had even more time to work on other features,such as more extensive server class queries.
Ultimately,what we made is a fully functional compiler that turned an object-oriented language into a full web application,spanning the entire client-server-database infrastructure.We will be expanding this language and its corresponding compiler beyond the scope of what was done this year,all while using it to code our own web applications from now on.
7References
?Martijn van Berkum,Sjaak Brinkkemper,and Arthur Meyer,”A Combined Runtime Environment and Web-Based Development Environment for Web Application Engineering”,Lecture Notes in Computer Science,Volume3084,Jan2004,Pages307-321
?ECMA,”ECMAScript Language Speci?cation”,1999,
https://www.doczj.com/doc/fb17894205.html,/publications/?les/ECMA-ST/Ecma-262.pdf
?Rajendra Kumar Komandur,”C#Grammar File”,2003,
https://www.doczj.com/doc/fb17894205.html,/grammar/1067486869200/csharp.g
?Terence Parr,”ANTLR Reference Manual”,2005,
https://www.doczj.com/doc/fb17894205.html,/doc/index.html
?W3C,”Scalable Vector Graphics1.1Speci?cation”,2003,
https://www.doczj.com/doc/fb17894205.html,/TR/SVG11/
?W3C,”Vector Markup Language”,1998,
https://www.doczj.com/doc/fb17894205.html,/TR/NOTE-VML
?Weiquan Zhao,David Kearney,”Deriving Architectures of Web-Based Applications”,Lecture Notes in Computer Science,Volume2642,Jan2003,Pages301-312
8Appendix:Code Samples
8.1A Basic Serulian Application
This example de?nes a Square class,declares a new square,and displays its computed area with a message box.
using BlueCore;
using BlueCore.Primitives;
using BlueObjects;
using BlueObjects.JavaScript;
using BlueObjects.Collections;
using BlueObjects.Exceptions;
using BlueObjects.Xml;
namespace ShapeTester{
class ShapeTester:IApplication{
public function
var
Alert(sq.Area().toString());
}
}
class Square{
public var
public var
public var
public Square(int x,int y,int length){
m_Length=length;
m_X=x;
m_Y=y;
}
public function
return(’Square:’+this.Area().toString());
}
public function
return(m_Length*m_Length);
}
}
}
8.2A Serulian Application,With State Block Added
This example expands on the previous one,with a custom XML state de?nition included. using BlueCore;
using BlueCore.Primitives;
using BlueObjects;
using BlueObjects.JavaScript;
using BlueObjects.Collections;
using BlueObjects.Exceptions;
using BlueObjects.Xml;
namespace ShapeTester{
class ShapeTester:IApplication{
public function
var
Alert(sq.Area().toString());
}
}
class Square{
public var
public var
public var
public Square(int x,int y,int length){
m_Length=length;
m_X=x;
m_Y=y;
}
public function
return(’Square:’+this.Area().toString());
}
public function
return(m_Length*m_Length);
}
state{
snapshot{
{
yield m_Length;
}
{
yield m_X;
}
{
yield m_Y;
}
}
entrypoint{
m_Length=int.parse(state->Length.Value);
m_X=int.parse(state->X.Value);
m_Y=int.parse(state->Y.Value);
}
}
}
}
An example of the resulting XML state would be:
20
10
10
8.3A Serulian Application Utilizing a Server Function
Building on the?rst example,here GetArea will actually be executed on the server.This may be a trivial example,but if GetArea included multiple database accesses or sensitive information,then the ability to delegate that procedure to the server will become useful.
using BlueCore;
using BlueCore.Primitives;
using BlueObjects;
using BlueObjects.JavaScript;
using BlueObjects.Collections;
using BlueObjects.Exceptions;
using BlueObjects.Xml;
namespace ShapeTester{
class ShapeTester:IApplication{
public function
var
Alert(GetArea(sq).toString());
}
public server function
//This code will be executed on the server
return(sq.Area());
}
}
class Square{
public var
public var
public var
public Square(int x,int y,int length){
m_Length=length;
m_X=x;
m_Y=y;
}
public function
return(’Square:’+this.Area().toString());
}
public function
return(m_Length*m_Length);
}
}
}
8.4A Serulian Application Utilizing a Server Class and Query
Here,we use a server function GetXs to query from the database a list of x coordinates from all Squares stored in the database.
using BlueCore;
using BlueCore.Primitives;
using BlueObjects;
using BlueObjects.JavaScript;
using BlueObjects.Collections;
using BlueObjects.Exceptions;
using BlueObjects.Xml;
using BlueObjects.Server;
namespace ShapeTester{
server class MyServerClass{
public field
public field
public MyServerClass(Square sq){
Square=sq;
Length=sq.m_Length;
}
}
class ShapeTester:IApplication{
public function
//Create an instance of the server class(this will add a new row
//every time the app is called)
var
//Get the x list
List
foreach(int x in xList){
Alert(x.toString());
}
}
public server function
var
select Square where Length=50;
var
foreach(Square s in results){
xList.Add(s.m_X);
}
return(xList);
}
}
class Square{
public var
public var
public var
public Square(int x,int y,int length){
m_Length=length;
m_X=x;
m_Y=y;
}
public function
return(’Square:’+this.Area().toString());
}
public function
return(m_Length*m_Length);
}
}
}
8.5SIML Example
This is a very simple SIML example that creates a click button template to be applied to the class ShapeTester.
xml:lang="en"lang="en"xmlns:s="urn:serulian:BlueObjects.SIML"> This is the HTML and SIML code that will be displayed on screen for the ShapeTester class Click Me!
8.6A class Implementing an Implicit Iterator
The below example implements an implicit iterator for the points of the square in the Square class.In the
main ShapeTester class,we call this iterator in the foreach loop and yield the single point in the square if it
has a length of0,and all four points otherwise.
using BlueCore;
using BlueCore.Primitives;
using BlueObjects;
using BlueObjects.JavaScript;
using BlueObjects.Collections;
using BlueObjects.Exceptions;
using BlueObjects.Xml;
namespace ShapeTester{
class ShapeTester:IApplication{
public function
var
foreach(Point p in sq){
Alert(p.m_X.toString()+""+p.m_Y.toString());
}
}
}
class Square:IEnumerable
private var
private var
private var
public Square(int x,int y,int length){
m_Length=length;
m_X=x;
m_Y=y;
}
public iterator
yield return new Point(m_X,m_Y);
if(m_Length>0){
yield return new Point(m_X+m_Length,m_Y);
招聘网站设计项目详细设计 第一部分、引言 1.1编写目的 本说明在概要设计的基础上，对招聘网站设计项目的各模块、页面、脚本分别进行了实现层面上的要求和说明。 软件开发小组的产品实现成员应该阅读和参考本说明进行代码的编写、测试。 1.2背景 说明： A、软件系统的名称：招聘网站设计项目 B、任务提出者：668Job在线科技发展有限公司 开发者：北大青鸟Aptech产品开发部 本项目将实现668Job的原型部分，并且在该原型的基础上进行功能的扩展和需求的界定，最终完成的版本将在https://www.doczj.com/doc/fb17894205.html,网站上使用。提供互联网上的求职、招聘登记和搜索服务。 C、本系统将存储用户信息，668Job将与其他的系统共享这些注册信息，共享的系统可能是 668Job电子邮件系统、668Job电子杂志分发系统。 这些系统之间不提供应用程序级别的接口，数据共享通过SQL Server数据库表的公共访问来实现。 本系统将使用SQL Server 2000作为数据库存储系统，SQL Server 2000企业版将由668Job自行购买。 1.3定义 IPO图——输入/处理/输出图，一般用来描述一个程序的功能和机制；
1.4参考资料 相关的文件包括： A、湖人诊所的内部文件《核准招聘网站设计项目》； B、《招聘网站设计项目需求说明》； C、《招聘网站设计项目项目开发计划》； D、《招聘网站设计项目概要设计》； 参考资料： A、北大青鸟Aptech ACCP3.0 Sem2《基于软件开发项目的毕业设计》； B、北大青鸟Aptech ACCP3.0 Sem2《ASP程序设计》； C、国家标准《详细设计说明书（GB8567——88）》； D、莱克公司的人力资源管理项目的详细设计说明； 合同： A、《招聘网站设计项目合同20031102 - 54》； （说明：不同的文档都有第一部分类似的引言部分，这样是为了文档能够在独立使用的时候，能够提供足够的背景信息。）
储蓄业务项目管理计划书 1．简介 项目概述 本项目要开发一个银行系统，系统一共分为储蓄业务、贷款业务、外汇交易、网上银行、信用卡业务和系统管理六个子系统。本团队负责其中的有关储蓄业务 的子系统。通过团队合作开发整个子系统，使团队成员获得软件工程开发的实际训练。本系统采用目前主流的B/S开发架构，将与整个银行系统一起发布。不单独发布。交付的产品包括可执行的文件、源代码、技术文档与用户使用手册等。本系统的开发过程中的主要工作是子系统需求分析、系统总体设计、子系统源代码开发、子系统测试、交付团长进行最后的集成、整个系统的测试。关键里程碑是制定项目管理计划书、制定需求设计规格说明书初稿、制定系统设计报告的初稿、进行子系统运行情况的检查与测试、进行系统集成后的运行情况的检查与测试。项目所需工具是个人电脑和开发工具。进度为11周，工程量为3人/天。 项目范围说明 （1）提交文档：项目管理计划、需求规格说明，设计报告、测试报告、用户使用手册和项目个人总结。其中项目总结为每人一份，每个小组所有成员的总结装订在一起；其余文档每组提交一份。每个团队可将各小组的文档综合到一起，各小组也可自行分开提交，具体方式由团队内部协商确定。所有文档需要提交电子版和打印稿。 （2）源程序检查：一共两次。第一次检查每个小组的子系统运行情况。第二次检查每个团队内六个小组集成后完整的银行系统运行情况，检查完成后需要提交程序源文件和可执行的系统。程序检查安排在上机时间进行。 软件项目计划书的演化 软件项目计划书在第三周周末前经由小组讨论、共同撰写、汇总整合三步骤形成初稿，第四周以后根据项目的进展可以对其进行修改，需要有组员提出修改意，在全体会上讨论通过，并由组长整理修改意见并作出相应的修改。其余组员同步获得更新稿。 2．项目组织管理 过程模型 表1.过程模型表 团队的分工与合作
Project编制施工进度计划图 首先，简单介绍下Project，Project是由微软公司开发的一个国际上享有盛誉的通用的项目管理工具软件，凝集了许多成熟的项目管理现代理论和方法，可以帮助项目管理者实现时间、资源、成本的计划、控制。 咱们今天一块学习下Project的其中一项功能，那就是如何编制施工进度横道图和网络计划图。至于Project其他的功能，如对项目资源的计划和控制、项目成本的计划和控制等，有兴趣的同志可以学习、研究下。 在学习制作横道图和网络图之前，先了解两个概念，什么是横道图和网络图。横道图，也叫条状图，在Project中叫甘特图，“甘特图”视图由两部分组成：左边的表和右边的条形图。条形图包括一个横跨顶部的时间刻度，它表明时间单位。图中的条形是表中任务的图形化表示，表示的内容有开始时间和完成时间、工期及状态(例如，任务中的工作是否已经开始进行)。图中的其他元素如链接线，代表任务间的关系。横道图示例： 图1 横道图 网络图，是一种图解模型，形状如同网络，故称为网络图，主要用于描述项目中任务之间的相关性。在网络图中，以方框节点表示任务，以节点之间的链接线表示任务之间的相关性。网络图示例：
图2 网络图 下面分两部分来讲，分别为横道图编制、网络图编制： 第一部分横道图编制 一、创建新项目计划 (1)单击“文件”菜单中的“新建”。在“新建项目”任务窗格中，单击“空白项目”。Project新建一个空白项目计划，接下来，设置项目的开始日期。 (2)单击“项目”菜单中的“项目信息”。显示项目信息对话框。 (3)在“开始日期”框中，输入或选择“2008年1月8日”，如图3所示。 图3 项目信息对话框
学软件开发，找软件工程师培训学校，北京哪家较好？学软件开发已经受到了广大初高中毕业生的青睐，作为北京地区的学生，选择在哪个学校学习软件开发已经成为广大考生迷惑的问题。而众所周知的北大青鸟软件开发课程是最好的，自然学软件开发去北京北大青鸟佳音校区！ 20世纪90年代以来，全球软件行业作为新兴产业，每年以平均13%的发展速度增长，中国处于价值链低端，产业态需要，国际软件行业的发展，迫使中国软件产品发展迫在眉睫。我国软件产品的整体技术含量和价值含量都比较低，需要培养高素质软件开发人员。国际化产业的需求，国家人才的缺乏导致软件开发成为近年来年较热门的IT专业。 那么我们为什么要选择北京北大青鸟佳音校区软件开发专业呢？其优势如下： 第一、课程系统，全面 北京北大青鸟佳音校区提供的不是单科的培训，而是系统的，全面的软件开发技术的培训，所有课程结构循序渐进。 第二、课程轻重分明 本课程重点是培养Java高级工程师和.net高级工程师，北京北大青鸟佳音校区的宗旨是“让学精一门语言，然后培养学生融会贯通的思想，学活其他语言”，因为软件的发展日新月异，学生只有学
活了程序设计语言，毕业后才能适应软件开发工作，才能在这领域里有所突破。 第三、采用“产学元方式教学” 北京北大青鸟佳音校区在平常的教学过程中，尽可能的将教学内容和企业发展相结合，学生时常可以去企业实践、用课本上的知识来为企业服务，用企业的先进技术带动学校的发展。真正做到学有所长、学有所用。 第四、培养扎实的理论基础 北京北大青鸟佳音校区不仅提供专业编程知识，同时，为了锻炼学生逻辑思维，还设置其他相应课程，比如：高数等，为了让学生全面掌握计算机软件，我们还开设了数据结构、操作系统等课程，为学生的进一步的学习。 第五、实践性强，针对性强 北京北大青鸟佳音校区的课程是与企业完全同步的，每个实践例子都是经过行业专家长期研讨开发出来的，因此在内容组织上，授课方式上都有成熟而先进的经验，确保学员“能够学会”，“学会了能够就业”。 第六、我们重视理论+实践，也注重职业素养的培养。 北京北大青鸟佳音校区的课程关注企业所注重的职业素养的培训，在班级管理，就业训练上都有专门的人员进行负责，保证项目经
软件项目管理计划书 项目名称： 时间：年月日
目录 1.简介 (3) 1.1.项目概述 (3) 1.2.项目主要功能及性能 (3) 1.3.项目交付产品 (3) 1.4.参考资料 (3) 2.项目组织 (3) 2.1.过程模型 (3) 2.2.团队的分工与合作 (4) 3.管理过程 (4) 3.1.管理目标及优先级 (4) 3.2.风险管理 (5) 3.3.监督及控制机制 (5) 3.4.人员计划 (5) 3.5.培训计划 (6) 3.6.风险管理计划 (6) 3.7.项目配置计划 (7) 3.8.计划更新策略 (7) 3.9.项目沟通计划 (8) 3.9.1.项目组会议 (8) 3.9.2.项目报告机制 (8) 3.10.项目的重用计划 (9) 3.11.质量保证活动 (9) 3.11.1.内部审核 (9) 3.11.2.阶段审核 (10) 4.技术过程 (10) 4.1.开发工具、方法和技术 (10) 4.2.软件需交付的文档 (10) 5.开发进度安排及预算 (11) 5.1.进度表格描述 (11) 5.2.开发过程中的资源需求 (11) 5.3.软件管理过程中预算及资源分配 (12) 5.4.项目进度及关键工期设置 (12)
1.简介 1.1.项目概述 1.2.项目主要功能及性能 1.3.项目交付产品 （1）提交文档：项目管理计划、需求规格说明，设计报告、测试报告、用户使用手册和项目个人总结。其中项目总结为每人一份，每个小组所有成员的总结装订在一起；其余文档每组提交一份。每个团队可将各小组的文档综合到一起，各小组也可自行分开提交，具体方式由团队内部协商确定。所有文档需要提交电子版和打印稿。 （2）源程序检查：一共 1.4.参考资料 2.项目组织 2.1.过程模型
湖南文理学院实验报告 时间：2013年12月3日 课程名称：软件项目管理 实验名称：xx学院毕业生就业信息管理系统项目计划书 班级：姓名：同组人： 指导教师评定：签名： 一、实验目的 掌握项目计划书的格式和写作要求，会结合具体项目写作项目计划书。 二、实验要求 1、结合模拟项目写出项目计划书。 2、提交项目计划书一份。 三、实验环境 1．硬件：计算机 2．操作系统：windows平台。 3．相关软件：Microsoft office软件。 四、实验内容 1 引言 1.1 编写目的 为了保证项目团队按时保质地完成项目目标，便于项目团队成员更好地了解项目情况，使项目工作开展的各个过程合理有序，因此以文件化的形式，把对于在项目生命周期内的工作任务范围、各项工作的任务分解、项目团队组织结构、各团队成员的工作责任、团队内外沟通协作方式、开发进度、经费预算、项目内外环境条件、风险对策等内容做出的安排以书面的方式，作为项目团队成员以及项目干系人之间的共识与约定，项目生命周期内的所有项目活动的行动基础，项目团队开展和检查项目工作的依据。 1.2 背景 项目的名称：xx学院毕业生就业信息管理系统。
项目的委托单位：xx学院计算机科学与技术学院软件开发部。 项目的用户（单位）：xx学院各届毕业生。 项目的任务提出者：xx学院计算机科学与技术学院软件开发部。 项目的主要承担部门：xx学院计算机科学与技术学院软件开发部。 项目建设背景：通过本系统可以使xx学院毕业生就业信息管理工作更加合理化、科学化，提高工作的效率，从根本上改变就业管理工作的方式，通过Internet，各院系和学生利用网络的便利，可以直接查询和提交就业信息。在这种系统平台下，可以快速、有效、全面的反映最新的用人单位信息、毕业生基本信息和就业趋势，及时提供高校学生工作管理人员对历届用人单位需求信息的分析统计，及时有效地调查分析大学毕业生的择业趋势和引发的心理问题并进行及时有效的就业指导。可以做到信息的规范管理、科学统计和快速查询，从而减少管理方面的工作量。 1.3定义 Microsoft SQL Server2008：数据库开发环境 Visual Studio 2010：程序开发环境 1.4参考资料 [1]朱少民.软件过程管理.北京：清华大学出版社，2007 [2]朱少民.软件质量保证和管理.北京：清华大学出版社，2007 [3]韩万江，姜立新.软件开发项目管理.北京：机械工业出版社，2004 [4]Harold Kerzner,杨爱华，等.项目管理—计划、进度和控制的系统方法.第9版.北京： 电子工业出版社，2006. 1.5标准、条约和约定 《计算机科学与技术学院毕业生就业信息管理系统立项建议书》 《计算机科学与技术学院毕业生就业信息管理系统项目任务书》 《计算机科学与技术学院毕业生就业信息管理系统项目履行合同》 2、项目概述
1.定义项目 (2) 2.日历的设置 (4) 2.1日历的设置 (4) 2.2日历的共享 (10) 3.设置项目属性 (11) 4.任务分解 (12) 4.1录入任务信息 (12) 4.2工期设定 (15) 4.3任务关联性设定 (16) 4.3.1在条形图中直接拖动 (16) 4.3.2在“前置任务”列中编辑 (17) 4.3.3在“任务信息”中的“前置任务”选项卡中编辑 (17) 4.3.4在“向导“中的“排定任务日程”中编辑 (18)
1.定义项目 在“任务”窗格中单击“定义项目”链接，将出现如图1-1所示的“定义项目”窗格，首先我们需要输入项目的估计开始日期，单击“定义项目”窗格中的下拉框，将出现一个月历，默认的项目开始日期为当前日期。 图1-1 “任务”窗格
图1-2 输入项目的估计开始日期 在设置好项目的开始日期后，选择“保存并前往第2步”链接。 图1-3与Project Server 相关的窗格
接下来将出现与Project Server相关的窗格，如图1-3所示，请选择“否“，保存并前往第三步 图1-4 完成项目定义 最后在图1-4所示的对话框中点击“保存并完成”。 2.日历的设置 2.1日历的设置 如果Project环境中的工作/非工作时间（日历）与实际中的工作/非工作时间（日历）有冲突，编制的项目进度计划肯定是不准确的。Project中的日历指的是项目的工作与非工作时间的设置。编制进度计划时必须首先设置日历，否则做出的计划是与实际脱节的。 在Project中日历有项目日历、任务日历和资源日历三种分类。而Project中默认的日历有4种：标准日历、24小时日历、夜班日历、行政日历。 通常情况下，为一个项目分配日历时，可以通过对“标准”日历的修改来得到，具体修改方法如下：
北大青鸟网上商城系统项目开发计划
J2EE第三小组 目录 1．引言 (2) 1.1编写目的 (2) 1.2项目背景 (3) 1.3定义 (3) 1.4参考资料 (3) 2．项目概述 (5) 2.1工作内容 (5) 2.2条件与限制 (5) 2.3产品 (5) 2.4运行环境 (5) 2.5服务 (6) 2.6验收标准 (6) 3．实施计划 (7) 3.1任务分解 (7) 3.2进度 (7) 3.3预算 ...................................................................................... 错误！未定义书签。 3.4关键问题 ............................................................................... 错误！未定义书签。4．人员组织及分工. (7) 5．交付期限 (8) 6．专题计划要点 (8) 1．引言 1.1编写目的 本计划提供一份合理的项目开发进程表,使所有的开发人员任务明确,步调一致,最终共同准时的完成项目.软件工程的目标是提高软件质量,本计划也是从软件的正确性,性能,易用性,灵活性,可重复性,可理解性等各个方面出发,以提高软件质量为最终目的而制定.读者为参与开发的所有相关人员.
1.2项目背景 说明： A、软件系统的名称：北大青鸟网上商城系统 B、任务提出者：北大青鸟J2EE九月班第三小组 C、开发者：北大青鸟J2EE九月班第三小组 实现完成的系统将作为北大青鸟珠在线销售系统使用，所应用的网络为Internet网络。 D、本系统将是独立的系统，所产生的输出独立。 本系统将使用Oracle9i作为数据库存储系统. 1.3定义 1.4参考资料 相关的文件包括： A、内部文件《北大青鸟网上商城电子商务系统案例研究项目》； B、北大青鸟网上商城电子商务系统案例研究项目分析会议备忘录； C、《北大青鸟网上商城电子商务系统案例研究项目可行性分析》； 参考资料： A、北大青鸟Aptech ACCP3.0 Y2《基于软件开发项目的毕业设计》； B、国家标准《软件需求说明书（GB856T——88）》； C、亚马逊网站的软件需求说明； 合同： A、《北大青鸟网上商城电子商务系统案例研究项目合同20040510 - 2》；
1、在Red Hat Enterprise Linux 4.0系统中，下列提高工作效率的功能中，（）不是bash的功能。（选一项） A 命令行补齐 B 别名 C 使用鼠标复制和粘贴 D 命令历史 2、在Dreamweaver MX中，为了使站点内的页面风格统一，经常使用到模板，以下有关模板的说法正确的是（）。（选一项） A 模板就是库项目 B 模板保存后不能进行修改 C 在模板中可以包含图像、表格等对象 D 模板修改后，必须手动更新应用该模板的网页 3、公司网络采用Windows server 2003单域模式进行管理，要实现域用户user 在域中任意一台计算机上登录时都显示同样的桌面环境，应在用户属性的（）标签中设置。（选一项） A 常规 B 终端服务配置文件 C 环境 D 配置文件 4、在RHEL4系统中，要实现磁盘配额，必须在系统中安装quota软件包，要查询该软件包是否已在当前系统中安装，可以使用的命令是（）。（选一项） A rpm -q quota B rpm -ivh quota C rpm -e quota D rpm -U quota 5、为了确保自身的安全，计算机病毒会采取一些手段来伪装自身，逃避防病毒系统的检查，这体现了病毒的（）特点。（选一项） A 非授权执行性 B 传染性 C 隐蔽性 D 潜伏性 6、某公司网络采用Windows server 2003单域结构进行管理，文件资料分布在域中的多台服务器上，采用（）技术可以使所有文件资料看似存储在一台服务器上。（选一项） A DFS B DNS C DHCP D VPN
7、你是一个Windows server 2003域的管理员，现在你需要创建一个通用安全组帐号，则必须要求域的模式为（）。（选二项） A Windows 2000 混合模式 B Windows2000 纯模式 C Windows Server 2003 模式 D Windows 混杂模式 8、 IOS是Cisco网络设备上运行的操作系统，作为初学者，小王（）可以显示当前模式下支持的所有命令。（选一项） A 使用“show history”命令 B 在提示符下直接输入？ C 在提示符下直接按下Tab键 D 使用“help？”命令 9、对硬盘分区并完成格式化后，就可以开始安装软件了，正确的顺序是（）。（选一项） A 先安装操作系统，再安装应用软件，最后安装驱动程序 B 先安装操作系统，再安装驱动程序，最后安装应用软件 C 先安装驱动程序，再安装操作系统，最后安装应用软件 D 只需要安装操作系统，不需要安装驱动程序 10、你是一个Windows server 2003网络的管理员，网络中有10个用户，部分用户需要能读取和修改ＮＴＦＳ分区上的文件和文件夹，而另外的用户不能对这些文件和文件夹有任何权限，你需要为这些用户设置访问授权，采取以下（）措施能使管理负担最小。（选一项） Ａ在ＮＴＦＳ分区上分别为这些用户帐号设置访问授权 Ｂ创建一个组帐号，将所有用户加入到组帐号中，在ＮＴＦＳ分区上为组帐号设置访问授权 Ｃ创建多个组帐号，将需要具备同样权限的用户加入到同一个组帐号中，在ＮＴＦＳ分区上为这些组帐号设置访问授权 11、在Dreamweaver MX制作的网页中，表单常用来收集用户的信息，如果希望用户能输入自己的信息，而不是在备选项中进行选择，可以使用（）表单元素。（选一项） A 文本区域 B 列表 C 单选按钮 D 复选框 12、在综合布线系统的水平子系统中，从信息插座到配线架的线缆总长度不能超过（）米。 （选一项） A 5 B 12
JS Here Project 2007中文教程（上） Benhao 2010-8-24
目录 Project入门 (3) 1.1 使用Project管理项目 (4) 1.2 启动Project Standard (5) 1.3 启动Project Professional (8) 1.4 视图 (13) 1.5 报表 (18) 1.6 创建新项目计划 (21) 1.7 设置非工作日 (23) 1.8 输入项目属性 (25) 1.9 小结 (26) 创建任务列表 (27) 2.1 输入任务 (27) 2.2 估计工期 (29) 2.3 输入里程碑 (32) 2.4 分阶段组织任务 (33) 2.5 链接任务 (35) 2.6 记录任务 (38) 2.7 检查任务工期 (40) 2.8 小结 (42) 设置资源 (43) 3.1 设置人员资源 (43) 3.2 设置设备资源 (46) 3.3 设置材料资源 (48) 3.4 设置成本资源 (49) 3.5 输入资源费率 (49) 3.6 为单个资源调整工作时间 (51) 3.7 记录资源 (54) 3.8 小结 (54)
Project入门 本章内容： ?了解Microsoft Office Project 2007产品系列 ?了解优秀的项目管理工具如何帮助完成任务 ?启动Project Standard或Project Professional，辨别Project窗口的主要组成部分 ?使用视图以不同方式显示项目计划的详细信息 ?使用报表打印项目计划的详细信息 ?创建项目计划和输入项目开始日期 ?设置项目的工作和非工作时间 ?输入项目计划属性 项目管理是一门实践丰富的艺术与科学。不论您正在参与项目管理，还是将要进行项目管理，阅读本书都是一个绝佳的学习机会。 就其核心而言，项目管理是一种融合技能与工具的“工具箱”，有助于预测和控制组织工作的成果。除了项目，组织还有其他工作。项目(如电影项目)与持续业务(Ongoing Operation)(如工资单服务)截然不同，因为项目是临时性的工作，产生唯一性的成果或最终结果。凭借优秀的项目管理系统，您可以解决以下问题： ?要取得项目的可交付成果，必须执行什么任务，以何种顺序执行？ ?应于何时执行每一个任务？ ?谁来完成这些任务？ ?成本是多少？ ?如果某些任务没有按计划完成，该怎么办？ ?对那些关心项目的人而言，交流项目详情的最佳方式是什么？ 良好的项目管理并不能保证每个项目一定成功，但不良的项目管理却会是失败的成因之一。 在您的项目管理工具箱中，Microsoft Office Project 2007应是最常用的工具之一。本书会介绍如何使用Project建立项目计划(包括任务和资源的分配)，如何使用Project中扩展的格式化特性来组织和格式化项目计划的详细信息，如何跟踪实际工作与计划是否吻合，以及当工作与计划脱轨时如何采取补救措施。 如果是刚刚接触项目管理，可以在此处暂停，先阅读附录A，然后再继续阅读本章。这样做不会占用多长时间，有助于恰当地评估和组织自己的项目日程安排需求，进而利用Project建立稳固的计划。 本书的大部分练习围绕着一个虚构的电影公司 (Southridge Video and Film Productions)展开。您任职于电影公司的可能性不大，但您肯定看过电视广告或电影。每个电视广告或电影就是一个项目，事实上，有一些还是相当复杂的项目，涉及成百上千的资源但时间限制却很严苛。Southridge Video遇到的许多日程安排问题，您可能都会觉得似曾相识，如此一来，
软件开发是IT行业里的高薪职业之一，由于目前就业市场软件开发的人才稀缺，加上高薪的诱惑，吸引了越来越多的人转向了软件开发职业，那么要做软件开发工程师，需要学什么呢？ 软件开发是一项技术性很强的专业，对于没有基础的人来说，分层次分阶段分维度的学习，这样的效果会更好。这里以北大青鸟的软件开发培训课程为例。 北大青鸟的软件开发课程每18个月更新一次，目的是为了紧跟互联网时代的步伐。课程总共分为三个分阶段。每个阶段的课程知识讲解都贯穿了项目，并且为了锻炼学员们的动手能力，每个课程都会有项目案例训练，每一个阶段都会有阶段项目训练。 第一阶段为了强化学员语法和逻辑思维能力训练，注重学习方法和学习习惯的养成，培养团队意识和沟通表达能力。主要有以下这些课程
内容： 1. 课程内容：使用Java理解程序逻辑、使用HTML语言和CSS开发商业站点、C#语言和数据库技术基础、使用C#语言开发数据库应用系统、职业素质导向训练； 2.课程讲解贯穿的项目：MyShopping、MyBank、学生成绩管理系统、MySchoolBase、MySchool; 3.学员动手训练制作的项目案例：MyDVD 、V+网站、QQ数据库管理、QQ用户信息管理、超市商品管理； 4.阶段训练项目：MyKETV 学完这些课程，可胜任的工作岗位有JAVA初级开发工程师、商业网站开发、网页开发人员、即时沟通工具开发人员、非IT专业信息部门的管理信息系统设计、开发、维护岗位等。 北大青鸟：软件开发需要学什么？ 第二阶段为了让学员具备面向对象思想，掌握自我解决问题的方法，掌握职业沟通技巧。主要有以下这些课程内容： 1.课程内容：优化MySchool数据库设计、深入.NET平台和C#编程、深入.NET平台的软件系统分层开发、使用Java实现面向对象编程、使用jQuery快速高效制作网页交互特效、使用JSP/Servlet技术开发新闻发布系统、职业素质导向训练； 2.课程讲解贯穿的项目：网络电视精灵、学生成绩管理系统、电子宠物、新闻发布系统； 3.学员动手训练制作的项目案例：影院售票系统、银行ATM取款机系
project项目管理软件实例分享 导读： 亿图Edraw Project是一款功能强大的企业级国产项目管理软件，可以为企业提供优质的项目管理服务，它已经被越来越多的大型企业所接受，逐渐成为项目管理者必备的管理工具。本文就来为大家介绍一下这款软件的使用。 免费获取甘特图软件：https://www.doczj.com/doc/fb17894205.html,/project/gantt/ Edraw Project 软件的下载与安装 获取Edraw Project软件，是开启项目管理之前的准备工作。从Edraw Project官方网站，即可免费下载这款软件。 完成下载后，双击【EdrawProject.exe】文件，开始确认安装。整个安装过程仅需1分钟左右。
Edraw Project 软件的使用 甘特图是项目管理领域里，最为常用的一种图示。因此，我们可以使用Edraw Project绘制甘特图。在绘制甘特图的过程，你将学会如何新建甘特图，如何添加任务信息，如何生成各类报表等。 1、新建甘特图 新建甘特图的操作较为简单，双击运行软件，单击新建，即可打开画布。 2、添加任务信息 添加任务的方法有三种，分别是顶部菜单栏按钮、右键菜单按钮和快捷键按钮。每一行内容都可以进行编辑。
温馨提示： Edraw Project软件顶部“开始”菜单中拥有丰富的编辑选项，比如插入链接、添加里程碑、降级任务等等，通过这些功能按键，只需简单几步操作就能轻松实现你想要的效果。 3、编辑资源 资源编辑功能是一种高级的甘特图功能，项目管理者可以在该面板设置资源的类型，成本价格以及名称等等。一个任务中会包含多个不同的资源，这些资源的组合会生成各类的报告。
学生宿舍信息管理系统项目计划书
目录 第一章前言---------------------------------------------------------2 1.1项目开发背景-------------------------------------------------2 1.2项目开发目的-------------------------------------------------2 1.3项目开发意义-------------------------------------------------2 第二章范围计划-------------------------------------------------------3 2.1项目工作分解结构--------------------------------------------3 2.2软件生命周期模型---------------------------------------------5 2.2.1软件生命周期模型图示表示-----------------------------------6 2.2.2软件生命周期模型详细文档-----------------------------------6 （一）软件规划----------------------------------------------6 （二）需求开发----------------------------------------------7 （三）软件结构设计-------------------------------------------8 （四）数据库设计-------------------------------------------10 （五）实施-------------------------------------------------10 （六）系统集成----------------------------------------------10 （七）提交-------------------------------------------------11 （八）维护-------------------------------------------------11 第三章进度计划------------------------------------------------------11 3.1甘特图-----------------------------------------------------11 3.2网络图（单代号或双代号）-------------------------------------12
使用Project编制进度计划 1.三套时间的概念与运用 1.1.基准时间 项目进度计划排定后，经审核通过，即可成为指导整个项目施工过程的基准。我们将这一计划中的时间明确记录下来，固定成为所谓的‘基准时间’。这一时间将成为在后续工作中进行对比分析偏差的‘原点’。在PROJECT软件中，工具栏里有跟踪项，然后点击保存比较基准，这里保存比较基准可以是整个项目，也可以是选中的一些节点。选中某些节点进行保存非常适合进度一次不能够完全排好的情况，把已经确认的一些节点的比较基准保存下来，另外一些等计划时间安排好后再进行保存。 1.2.实际时间 在施工的实际过程中，生产人员根据现场当前实际开工的分项工程，和完成的分项工程，在进度计划中填写‘实际时间’，这一组时间是现实的客观记录。 1.3.滚动计划时间 这一计划在最初是和‘基准时间’完全相同的。过程中，随着每一次填写分项工程实际开始时间或结束时间，我们需要马上重新排定进度计划。比如，一个分项工作完成了，我们有了实际完成时间。根据原先确定的各分项工程间的逻辑关系和计划耗用时间，我们可以重新排定全部计划。 为什么要重新排计划呢？因为，如果这项工作脱期了，有可能原先不是‘关键工作’的分项工程，在新的计划中成为了‘关键工作’。也就是说我们的管理和控制重点将发生改变。随着实际时间的填入，不断生成的计划，这就是滚动计划。2.进度计划的操作步骤 1)设置项目开始时间； 2)设定工作时间； 3)添加任务名称;
4)设定任务级别； 5)设定任务间的关系； 6)设置任务工期； 7)保存比较基准； 2.1.设置项目开始时间； 打开工具栏中的“项目信息”，如下图一；设置项目开始时间，如下图二； （图一：） （图二：） 2.2.设定工作时间； Project默认的工作时间一般周六、周日为非工作时间。而建筑工程中编制进度计划是不考虑周六、周日的。所以要将Project中的默认工作时间进行更改，将周六、周日改为非默认工作时间。 操作步骤: 工具->更改工作时间，选择要更改的时间列->将所选的-期设置为非默认工作时间，见下图一、图二；注：非工作时间在Project当中为灰色显示，工作时间为白色显示 （图一：） （图二：） 2.3.添加任务名称 2.3.1.添加新任务； 需要插入一个新的任务，如下图，需要在第8项任务前插入一项新任务，有两种方法
Project项目管理软件哪个好 导语： 随着市场上使用项目管理软件的人数增多，越来越多的项目管理软件被开发了出来，那么到底有哪些好用的项目管理软件呢？本文将盘点分析市面上常见几款甘特图软件，以帮助大家能够找到适合自己的工具。 |Edraw Project 这是一款专业的项目管理软件。可以很轻松的创建甘特图来进行项目规划、资源分配和预算管理等，使用起来也十分的简单容易上手。 软件主要有几个特点： ●易操作：界面设计类似Office，交互简洁，帮助支持方面完善。 ●数据交互：数据与图形双向交互，支持数据导入与导出 ●资源管理：支持自定义资源，支持统计和分析 ●一键报表：多种报表，一键生成，一键打印报表
|Microsoft Office Excel 这是微软办公软件中用于处理表格数据的工具，也是职场人士必装的一款软件。万能的Excel也是能够绘制甘特图，进项项目管理的，只是操作难度偏大，或许是对Excel足够熟练的高手才有机会绘制。 虽然网络上有许多相关的教程，教大家如何使用Excel画甘特图，但教程普遍偏难，且绘制完成的图表也缺乏美观度，不大适合新手使用。 |MindMaster 这虽然是款专业绘制思维导图的软件，但也是专业绘制甘特图的。使用MindMaster有一点你可能会觉得不太方便，就是需要先绘制思维导图，才能生成甘特图。但其实在熟练使用后，该步骤绘制甘特图的效率比其他软件还高。所以，笔者挺推荐大家使用这款软件。它不仅可以画甘特图，还能顺便把思维导图给画了。
|瀚文进度计划软件 瀚文软件是一家较为早期的国产软件开发公司，其自主研发的这款瀚文进度计划软件可用于对工程项目的管理和控制。其软件的界面风格类似早期的Windows软件，但较为熟悉的界面或许更容易上手体验。 这款软件提供较为完善的甘特图功能，可满足基础的绘制需求。但美中不足的是，软件所绘制的甘特图，其风格与现代的审美观略有差距，不够时尚整洁，略为遗憾。
软件项目管理计划书 项目名称：人力资源管理系统 1、简介 (3) 1.1项目概述 (3) 1.2项目交付产品 (4) 1.3软件项目计划书的演化 (4) 1.4参考资料 (4) 2、项目组织 (5) 2.1过程模型 (5) 2.2 团队的分工与合作 (7) 3、管理过程 (8) 3.1 管理目标及优先级 (8)
3.2 风险管理 (8) 3.3监督及控制机制 (10) 3.4人员计划 (11) 3.5培训计划 (11) 4、技术过程 (12) 4.1 开发工具、方法和技术： (12) 4.2软件需交付的文档： (12) 5、开发进度安排及预算 (13) 5.1进度表格描述 (13) 5.2 开发过程中的资源需求 (16) 5.3 软件管理过程中预算及资源分配 (17) 5.4 项目进度及关键工期设置 (17)
1、简介 1.1项目概述 本项目要开发一个人力资源管理系统，本系统将实现对人员信息的详细管理、对学校各个部门的详细管理；重点在加强奖惩制度的实施，以实现激励员工的工作激情，还要加强员工的技能培训，使职工或者教师具有更高的文化水平，提高学校的知名度，培养出高精尖水平的学生。通过团队合作开发整个子系统，使团队成员获得软件工程开发的实际训练。本系统采用目前主流的B/S开发架构，将与整个人力资源管理系统系统一起发布。不单独发布。交付的产品包括可执行的文件、源代码、技术文档与用户使用手册等。 本系统的开发过程中的主要工作是子系统需求分析、系统总体设计、子系统源代码开发、子系统测试、交付组长进行最后的集成、整个系统的测试。关键里程碑是制定项目管理计划书、制定需求设计规格说明书初稿、制定系统设计报告的初稿、进行子系统运行情况的检查与测试、进行系统集成后的运
第一部分：预备课程 预备课程是免费的课程，主要是为哪些对计算机了解不多的学员准备的，计算机常见的操作、办公软件的使用、基本的计算机词汇在这门课程中讲解。 第二部分：第一学期课程 第一学期按先后次序将学习以下的课程： 第一学期课程除了包含前面讲解过的数据库、客户端页面、和四门基础课程之外，还包括了： A、《进入软件编程世界》：这是一门基础课程，讲解软件程序设计所必须知道的基础知识如网络配置和指令、2003操作技巧、常用工作软件的使用等； B、《职业导向训练》：这门课程是用来培养职业素养的，通过学术活动、班级活动、职业素养课程，让我们具备职业人所必须具备的时间观念、表达能力、规范意识等； C、《项目实战》：这门课程包括两部分内容，第一部分内容是针对每门课程设计的“项目案例”，用来组合训练，增加熟练程度、提高项目经验和开发能力，第二部分内容是第一学期结束时要求完成的阶段项目。 第一学期课程体系说明： 1、先学习进入软件编程世界，才能够具备计算机语言学习的基础； 2、第一学期课程结束后，课程的基本语言语法都与课程类似，将对比进行学习； 3、语言是独立的课程，不牵涉到程序编写，学习课程之后，为了缓解学习压力，调整 学习节奏，先学习这门课程；
4、课程和课程共同结合起来完成第一学期的阶段项目；第一学期的项目实战安排如下图所示： 第一学期学习完成后，要求： 在开发技能上： ?熟悉计算机软件技术的基本知识 ?理解程序逻辑、基本的算法 ?使用、表格框架或者布局模式、工具开发静态站点 ?用语言设计和维护数据库 ?核心技能：用开发结构的管理信息系统 在职业素质上： ?树立正确的学习心态、明确职业目标 ?具备时间观念和规则意识 ?基本的语言沟通和表达 ?具备基本的行为礼貌和日常礼仪 第三部分：第二学期课程 第二学期按先后次序将学习以下的课程：
软件工程师综述/行业展望 ——北大青鸟昌平校区提供 引言：软件工程师是一类新兴的职业。与传统的行业相比较，这个行业是随着计算机的发展而逐步发展的，并且，随着信息产业化的飞速发展，软件工程师这个行业不仅让人们越来越熟悉，并且，也吸引着大量人才的涌入，很多人都会通过参加软件工程师培训，或是通过大学专业的选择，加入到这个队伍当中。 当今信息瞬息万变，软件工程师的需求量也逐步加大，从当初单一的编程工作，发展到软件测试工作、宏观管理工作等。人们对于软件工程师这个行业的兴趣越来越大。 软件工程师到底从事什么，软件工程师待遇如何，软件工程师发展前景怎样，人们有许多疑问。本篇文章，通过对软件工程师详细的介绍，让大家真正了解这个行业，并最终指明软件工程师的发展前景，旨在为那些选择的人做一个明确的发展方向。 目录 软件工程师概述 (2) 软件工程师分类 (2) 软件工程师工作内容 (3) 软件工程师待遇 (4) 软件工程师行业展望 (6) 软件工程师要求 (7) 软件工程师认证培训 (8) 软件工程师知识补充 (10)
第一部分：软件工程师概述 定义： 软件工程师主要进行软件前期的项目需求的分析，然后对项目进行风险评估并试图解决这些风险，然后开始进行软件的开发，后期对软件的进度做相关的评估。 现状： 目前国内软件测试工程师的来源主要有三方面：一是以前专业做软件开发的人员后来转行做软件测试，二是从大学招聘的本科或者研究生，三就是通过培训机构招聘的专业学员。 其实，无论通过何种形式，目的在于招聘到优秀的人选，招聘到优秀的工作者，因此，通过参加培训，如北大青鸟培训等，也是不错的选择。 第二部分：软件工程师分类 按级别分类 上面的梯形图明确的表示出软件工程师的四个步骤，如同金字塔
project项目管理软件有哪些 导语： 面对市场上众多的企业项目进度管理软件，有哪些项目管理软件比较好呢？本文将盘点分析市面上常见几款甘特图软件，以帮助大家能够找到适合自己的工具。 |Edraw Project 这是一款专业的项目管理软件。可以很轻松的创建甘特图来进行项目规划、资源分配和预算管理等，使用起来也十分的简单容易上手。 软件主要有几个特点： ●易操作：界面设计类似Office，交互简洁，帮助支持方面完善。 ●数据交互：数据与图形双向交互，支持数据导入与导出 ●资源管理：支持自定义资源，支持统计和分析 ●一键报表：多种报表，一键生成，一键打印报表
|Microsoft Office Excel 这是微软办公软件中用于处理表格数据的工具，也是职场人士必装的一款软件。万能的Excel也是能够绘制甘特图，进项项目管理的，只是操作难度偏大，或许是对Excel足够熟练的高手才有机会绘制。 虽然网络上有许多相关的教程，教大家如何使用Excel画甘特图，但教程普遍偏难，且绘制完成的图表也缺乏美观度，不大适合新手使用。 |MindMaster 这虽然是款专业绘制思维导图的软件，但也是专业绘制甘特图的。使用MindMaster有一点你可能会觉得不太方便，就是需要先绘制思维导图，才能生成甘特图。但其实在熟练使用后，该步骤绘制甘特图的效率比其他软件还高。所以，笔者挺推荐大家使用这款软件。它不仅可以画甘特图，还能顺便把思维导图给画了。
|瀚文进度计划软件 瀚文软件是一家较为早期的国产软件开发公司，其自主研发的这款瀚文进度计划软件可用于对工程项目的管理和控制。其软件的界面风格类似早期的Windows软件，但较为熟悉的界面或许更容易上手体验。 这款软件提供较为完善的甘特图功能，可满足基础的绘制需求。但美中不足的是，软件所绘制的甘特图，其风格与现代的审美观略有差距，不够时尚整洁，略为遗憾。
- 0 -
目录第一章前言 1.1项目开发背景-2 1.2项目开发目的-2 1.3项目开发意义-2 第二章范围计划 2.1项目工作分解结构 2.2软件生命周期模型 2.2.1软件生命周期模型图示表示 2.2.2软件生命周期模型详细文档 （一）软件规划 （二）需求开发 （三）软件结构设计 （四）数据库设计 （五）实施-10 （六）系统集成 （七）提交-11 （八）维护-11 第三章进度计划 3.1甘特图 3.2网络图（单代号或双代号）-12 3.3里程碑图---14 第四章成本计划 4.1成本估算4 4.2成本预算6
第五章人力资源计划--18 5.1项目的组织结构 5.2责任分配矩阵 5.3人力资源管理计划----20 第六章沟通计划 6.1沟通需求1 6.2沟通内容1 6.3沟通方法1 6.4沟通时间安排表 6.5沟通计划维护
第一章前言 1.1 项目开发背景 东方学院本身没有宿舍信息管理系统，一直以来都是通过Excel对各楼层、各宿舍人员进行统计，宿舍信息变更、人员变更之后，不能及时有效地将更改后的信息进行完善，若有大面积的改动，需要大量的人员与大量的时间对宿舍进行核对，有时候因为宿舍成员的不配合，核对工作很难准确的完成。并且现有的奥兰系统虽然能够统计学生信息，能够发布卫生检查结果，但是无法进行宿舍信息的完整统计，无法对宿舍进行全面、系统的管理。我们东方学院学生人数庞大，自管会在做宿舍统计以及宿舍卫生检查与整理的过程中，往往因为宿舍信息的错乱、不完整，反馈的信息也是不完全的，这就导致老师不能完全准确的了解宿舍的真实信息。 1.2项目开发目的 为了更好更方便的对宿舍进行管理，为了更好的了解全院学生宿舍卫生情况、违纪情况对个人综合素质的影响，为了让学生了解自己的宿舍信息、与卫生成绩，从而做到改善，建立宿舍信息管理系统是必要的。 1.3项目开发意义 宿舍信息管理系统的主要功能包括：可以实现对学生宿舍信息的查询功能,包括快速查询功能和分类查询功能；对学生宿舍信息的录入功能,修改功能,删除功能和统计功能。通过系统上述功能实现宿舍管理部门对于学生宿舍信息的日常管理，即方便宿舍管理人员及时全面地掌握学生住宿情况及宿舍分配情况；为用户（管理用户和一般用户，如宿舍管理老师）提供了一些简单的数据查询并输出各种信息等；在实现检索迅速和查找方便的同时,对毕业生以及申请走读的学生做到及时的删除信息，新入校学生很快地进行宿舍安排以及宿舍信息的录入等日常管理。