The paper presents a new idea of knowledge representation for students studying software engineering by developing artifacts and software components accumulated in libraries or repositories for further reuse. The idea is based on the concept of assembly line by V. Glushkov, further elaborated by Soviet and foreign specialists (A. Ershov, V. Lipaev, J. Greenfield, G. Lenz, Y. Bai, M. Fowler). The paper introduces the elements of program factory: reusable components, their interfaces, and assembly lines for designing and assembling complex software products from components. It is shown that modern operating environments provide prerequisites for such factories. The students' program factory, implemented at Taras Shevchenko Kiev National University, is then described. The technologies behind the factory, as well as its goals are studied.
The paper presents the elements of programs factories: reusable components (RC) and their interfaces, assembly lines for designing and assembling complex programs from RCs. It is shown that modern operating systems provide tools for creating specialized programs factories (MS.NET AppFabric, SOAFab, SCAFab, IBM VSphere, CORBA, etc.). Factories are built by different commercial structures for software product development, as well as for studying purposes (e.g., the programs factory implemented in Taras Shevchenko Kiev National University for the assembling artifacts from disciplines that are studied at the university). The purpose of such factories is to study computer science, software engineering, programming technology and software systems with electronic textbooks, develop applied projects and thus train highly competent professionals in software industry.
Over last decades a huge amount of various programs has been accumulated in the informational world that may be used as end products for complex programs development. Therefore, a new approach has been formed in programming, namely reusability – reuse of ready-made software resources (reuses, assets, services, components, etc.), hereafter referred to as reusable components (RC). This term is used in informational world to represent new knowledge acquired over researches in certain fields of computer science. Being needed for somebody, it may be used in solving certain problems concerning similar artifacts as well as for development of new software systems (SS), applied systems (AS) or software product families (SPF).
All software artifacts and RCs may be stored in public warehouses (libraries,
repositories) that may be searched by professionals to identify the necessary data for
implementation in their own research activities. That is, reuse of ready-made
resources becomes a capital-intensive activity in the field of software engineering and it
is particularly important that universities possess so-called factories for scientific
artifacts, programs and RCs needed by other students and professionals. With these
factories, students may participate in industry development of scientific artifacts for
mass use [
Based on such innovative ideas, Prof. E. Lavrischeva proposed fourth-year students at KNU to establish the first programs factory over the course of theoretical and practical labs on software engineering. This factory is focused on artifacts, software development, and repository maintenance. Students’ programs factory operates on the web site (http://programsfactoty.univ.kiev.ua) since December 2011. The web site has been visited by more than 5,000 people – students, scientists and teachers. 2
History of Software Industry in USSR. An idea of industry for computers and
supporting software has been formulated by Academician V. Glushkov at Cybernetics
Institute of NAS of Ukraine in 1960s-1970s. Under his guidance, a family of small
computers ‘Mir’ (1967–1975) has been developed together with a language of
analytical and formula transformations for solving differentiation, integration and
formula calculus problems. In addition, other computers (Dnepr, Dnepr-2, Kyiv-67, 70,
macro-conveyor etc.) have been elaborated with auto code-typed programming
languages (PL) to develop information processing programs and automated management
systems (AMS) for various organizations and enterprises. For their development, the
problems of software quality and increase of production of reusable components have
been investigated with computers at state institutions [
In 1975 V. Glushkov first formulated the concept of assembling conveyor consisting from technological lines for software products (SP). The core of Glushkov’s paradigm is to accelerate the transition from programming as an art to industrial methods of SP production in order to solve various economical, business, scientific problems with automated management systems.
Then (1978), software development as joint scientific-technical production and the
projects requesting for automating SP creation have been decreed. The first pilot
factory for software engineering was established for mass production of various AMSs
(1978, Kalinin); but, because of lack of ready-made programs and immaturity of
programming technology for industry production, the factory had lasted for two years
and was closed [
V. Glushkov’s idea concerning programs factories is now running at the several
industrial factories explored by different authors theoretically and in practice [
Visual Studio Team Suite based on contracts G. Lenz’s program factory utilizing UML in .NET Assembling, configuration and certification of global scientific-technical software on the European Grid factory Compositional (assembling) programming by E. Lavrischeva for developing software products from reuses, services, artifacts, and so on Experimental KNU factory
Careful analysis allowed singling out the key components of programs factories
[
The elements listed are the fundamentals of SP production industry at the factories that operate at major foreign software companies such as Microsoft, IBM, Intel, Apple, Oberon etc. At the KNU students’ programs factory, these fundamentals are implemented as certain lines for programs and scientific artifacts, which are the best among student-developed programs factories.
The authors of the KNU programs factory consider it an integrated infrastructure
for organizing production of mass usage SPs that are needed for customers and users
from the fields of computer science, state government, commerce etc. The factory is
equipped with technology lines (TL) or product lines [
Web Site of KNU Programs Factory. The main objectives for the web site are: improving students’ skills in software development using the system for exchange of KNU students’ certified software products and scientific artifacts; increasing SP quality and reliability; and learning to support the methods of SS industrial production.
The web site presents lifecycle models, SP building lines, the line for program production with the help of MS.NET platform, and examples of student programs. Obligatory requirements are maintained during certification to store software products in the repository of the factory (the library pool).
The main activities on the factory site are: Organizing program and artifact development Familiarizing students with tools and methods for program and SS development Representing students’ software products in the repository Citing excerpts from articles and textbook materials concerning various disciplines The factory is equipped with tools that allow broadening its functionality by specifying new software artifacts and storing them in the repository for further reuse. Each artifact is uniformly documented based on WSDL, IDL standard used in Grid global project. 3
Development of Technological Lines. Technological lines are created at the
technological pre-production stage [
The RC model for component-based development has the following specification: RC = {T. I, F, Imp, S}, (12) where T is type, I is interface, F is functionality, Im is implementation, and S is interoperability service.
Basic operations over components are: Specifying components and their interfaces (pre- and post-conditions, which must be satisfied by the caller) in such languages as IDL, API, WSDL, etc. Maintenance of components, reuses and artifacts in the component repository for search, change and future integration into applied systems Integration of components into applications, domains, applied systems, software product families, etc.
All aspects of RC development and their usage in SP and software product families are goals for reusability disciplines and building material for these systems.
Applied system is a collection of software means (or functions of SS), including
general tools (DBMS, protection systems, system services, etc.), constructed
subsystems or components together with the tools for marshalling from one AS to another
[
Product Lines at SEI. Product lines and product family (PF) is defined in ISO/IEC FDIS 24765:2009 (E) – Systems and Software Engineering Vocabulary: “Product line is a set of products or services that share a common, managed set of features satisfying the specific needs of a particular market segment or mission and that are developed from a common set of core assets in a prescribed way. Synonym: product family”.
SEI professionals propose the two models for representation of activities for SS development, namely engineering and process ones.
The engineering model assumes the three activities, namely RC development, PF development through RC configuration and management of the both above activities.
The activity for RC development presupposes PF scoping and production planning of SS collection accounting for the context of SS usage, production limitations and the chosen strategy. The PF development activity includes designing each specific SS implementation based on the set of developed RC, and building software systems according to the PF implementation plan. The management activity is based on balancing activities for RC development and PF maintenance tasks, and includes both organizational and technical management.
According to the process model, a set of processes is performed at the two levels,
namely domain engineering, being also referred to as the development “for reuse”,
and application (or SS) engineering – the development “with reuse” [
From the theoretical standpoint, program factories are based on the assembling conveyor that includes a collection of various more or less complex production lines for software artifacts, programs and RCs. Conveyor lines contain process execution using system tools or technological modules that automate process execution for obtaining interim or final results.
From the perspective of information technology, the factory provides the data processing toolset for the transition from individual programming of particular resources to the industry of mass-usage SP. The factory increases SP development productivity during each lifecycle process due to use of RCs that possess the necessary functionality with due quality guaranteed by their developers. The assembling (composition, configuration) line may benefit through reduction of efforts because of use of readymade artifacts or RCs stored in the repository.
Home Publications
Learning
Repository
Contacts
Link Searching for RC
Select Platform All Platforms
Select OS All Platforms
Searching for manuals Select Manual (if necessary)
All Books Searching for publicationsSelect category (if necessary)
All category Input text for Searching
Search
Learning Home
Literature
“Software Engineering” Manual
Author: Lavryscheva Katerina Myhailovna Generic Line for particular programs production in MS.NET An Example of student’s program with the Line Software Products sertifying for storing them in Repository Assembling with Conveyor Line for Software Products Assembling from RCs and Processes Software Product Line You may ask questions Recent Reusable Components (RC)
Repository Shingles algorithm Dzubenko Artem Moxiecode System Aronov Andriy Dzubenko Artem
Recent Books
Learning APPLICATION 2 .
The List of Standards. “SoftwareEngineering”Manual APPLICATION 1 .
The Glossary of Terms. “SoftwareEngineering”Manual Abbreviations& Denotations. “SoftwareEngineering”Manual
Visitors: 5242
Programs Factory Technological Lines. The TL development is as a rule
matched with some lifecycle, e.g., implemented in the MS.NET environment with
guides, frameworks, programming languages, common libraries templates, system
tools that support new subject-oriented languages such as Domain Specific Language,
etc. For complex SP development, an assembly (compositional) line is proposed, as a
tool for composing RCs using their interfaces from various interim libraries within
development environments, as well as from RC repositories (Fig. 1). The figure
shows the main page of the web site of the factory: lines 1, 2, 3, 4 and a text-book for
e-learning fundamental aspects of software engineering [
The assembling conveyor has four implemented technological lines [
Web Site Lines. The depicted TL for learning C# programming is designed according to the ISO/IEC 12207 standard of lifecycle processes while allowing for .NET specifics as to how to perform the following design tasks: Exploring demands on software products, singling out features and methods for automated generation Fixing requirements on implementations of SP functions for the domain Specifying software elements or artifacts, documenting their passport data and interfaces with a WSDL-like language Storing created software artifacts and programs in the repository
The line for repository maintenance includes the mechanisms for stored RCs being uniformly documented with their WSDL passports, as well as the tools for selecting ready-made RCs and artifacts from the repository based on their passport data, functions and relevant solution examples (see Fig. 3). This line is pertained to the processes for quality assessment of artifacts or programs created, verifying them from the perspective of reliability and quality.
The line for AS development at the factory includes the tools for engineering of
specific required components using various PLs, programs and artifacts, both just
developed and selected from repository; the line also supports building multilingual
RCs and marshalling non-relevant types of data exchanged by the components [
The line for remote e-learning with the dedicated Software Engineering textbook
[
Design of Programs Factory. At the students’ factory, Visual Studio .NET licensed by KNU is used as the foundation for the programs factory; capabilities of MS.NET platform in providing tools for multilingual AS development and support using the components in C#, C++, Basic, etc., are utilized as well. Consequently, third-party software developers for the factory may not be limited to the choice of a single PL.
The factory web site is developed using PHP programming language, and, for its
external representation, HTML5, CSS3 and JavaScript. The system core is
independently engineered by the authors with relying on known web frameworks [
Teaching students the aspects of software industry at Ukrainian universities is at its initial stage. To solve several education problems, we have introduced a new approach to e-learning various aspects of SE, which assists in acquiring knowledge on software industry.
A new concept for breaking down the software engineering disciplines (Fig. 4),
which is necessary in industrial factory production, was proposed [
In our opinion, all the SE disciplines considered above and their theoretical
foundations must become the independent subjects to be taught to students specializing in
the field of SE with the orientation toward the industrial production of SPs from
readymade components (reuses, services, assets, and so on) [
Approach to Teaching SE. The SE educational course must include intertwined
theoretical and practical fundamental positions and achievements in software
development and integration [
The students learn and apply them on practice with the use of system tools,
artifacts or programs developed by other students. Certain students’ achievements are
certified by the teacher and can be added to the repository of the factory
In terms of teaching SE, the author’s first textbook (2001), written in Ukrainian
[
The result of the authors’ work is an experimental programs factory web site, accessible on the Internet using address http://www.programsfactory.univ.kiev.ua/. This web site is proposed for e-learning product line development at the high school institutions on the specialties of informatics, computer sciences, information systems and technology.
The following concrete lines are established at the factory: Production of reusable components and artifacts Development of console applications, DLL component libraries, local Windows applications with C# in VS.NET Developing Java programs (a manual by I. Habibulin) Assembling programs from RCs in MS.NET environment E-learning software engineering with dedicated textbooks on the web site in Ukrainian (sestudy.edu-ua.net) and in Russian (intuit.ru)
The prospects of future factory evolution are its further adjunction with new resources in the field of software engineering being yet prepared by the students, namely: Description of the process of development of complex programs and SS using DSL language (Eclipse-DSL, Microsoft DSL Tools) Transformation of general data types into fundamental data types from the perspective of the standard ISO/IEC 11404-2007 generation tools Ontological representations of new disciplines for study (e.g., computational geometry, lifecycle domains, verification) New applied product lines for business developed with appropriate mechanisms; SEI product lines approach, and so on