Conference PaperPDF Available

Performance analysis of the parallel code execution for an algorithmic trading system, generated from UML models by end users

Authors:
Conference Paper

Performance analysis of the parallel code execution for an algorithmic trading system, generated from UML models by end users

Abstract and Figures

In this paper, we describe practical results of an algorithmic trading prototype and performance optimization related experiments for end-user code generation from customized UML models. Our prototype includes high-performance computing solutions for algorithmic trading systems. The performance prediction feature can help the traders to understand how powerful the machine they need when they have a very diverse portfolio or help hem to define the max size of their portfolio for a given machine. The traders can use our Watch Monitor for supervising the PNL (Profit and Loss) of the portfolio and other information so far. A portfolio management module could be added later for aggregating all strategies information together in order to maintain the risk level of the portfolio automatically. The prototype can be modified by end-users on the UML model level and then used with automatic Java code generation and execution within the Eclipse IDE. An advanced coding environment was developed for providing a visual and declarative approach to trading algorithms development. We learned exact and quantitative conditions under which the system can adapt to varying data and hardware parameters.
Content may be subject to copyright.
Performance Optimization and Code Generation from
Customized UML Models: An Example of End-User
Programming for An Algorithmic Trading System
Dr. Ga´etan Hains and Chong Li
Lab. d’Algorithmique, Complexit´e et Logique
Universit´e Paris-Est Cr´eteil, France
Dr. Youry Khmelevsky
Unit 5 Mathematics, Statistics, Physics, Computer Science
Okanagan College and UBC Okanagan, Kelowna, BC, Canada
Abstract
In this paper, we describe practical results
of an algorithmic trading prototype and per-
formance optimization of end-user code gen-
eration from customized UML models. Our
prototype includes high-performance comput-
ing solutions for algorithmic trading systems.
The prototype can be modified by end-users
on the UML model level and then used with
automatic Java code generation and execution
within the Eclipse IDE. An advanced coding
environment was developed for providing a vi-
sual and declarative approach to trading al-
gorithms development. We learned exact and
quantitative conditions under which the system
can adapt to varying data and hardware pa-
rameters.
Copyright c
2013 Dr. Ga´etan Hains, Chong Li,
Dr. Youry Khmelevsky. Permission to copy is hereby
granted provided the original copyright notice is repro-
duced in copies made.
1 Introduction
Algorithmic trading systems are widely used
by pension funds, mutual funds, hedge funds,
market makers and other institutional traders
to manage market impact, risk, and to provide
liquidity to the market. The technologies of
information processing and high-performance
computing, such as the parallel bridging model
- SGL [1] [2], are essential for such systems.
The initial “Algorithmic Trading System
Prototype” prototype was developed in COSC
319 Software Engineering Project course at
University of British Columbia Okanagan
(UBC O) in Canada, in collaboration with the
international student research project spon-
sors, Laboratoire d’Algorithmique, Complexit´e
et Logique (LACL) in Universit´e Paris-Est
(UPE) in France. It was developed as a new
approach for special-purpose programming
language code generation from UML models
by designing and programming a new plugin
for Eclipse IDE, and a library of predefined
functions for the plugin [3].
Figure 1: End-User UML Diagram of the On-line Stock Information Sources.
The goal in developing the prototype was
to enable end-users to modify the software
application without programming or support
from programmers. Current code generation
tools were built upon with respect to func-
tionality requested by clients for a hedge fund
in Paris. The prototype allows end-users to
create simple business related UML diagram
(see a UML diagram example on Figure 1)
and to generate code used in calculating
moving averages [5]. The Eclipse Modelling
Framework (EMF) [8] and Java programming
language were used only for the prototype.
The business domain area of the prototype is
real-time algorithmic trading for a hedge fund
in Paris. A simplified Domain Model (DM)
of the Prototype is shown in Figure 2 [3] (see
more explanation in the next section). The
technologies of high-performance computing,
such as the parallel bridging model - SGL [1],
are essential for such systems so as to ensure
that complex strategies can process stock-
exchange data as millisecond rates [2]. There is
an a enormous demand placed on developers,
who have to concurrently address financial
algorithms, parallel computing, compiler
mis-optimization, and hardware technologies.
[3], etc. In response to this, it was proposed
to develop an advanced coding environment to
provide a visual and declarative approach for
developing trading algorithms, which would
generate portable bit-code on a Low-Level
Virtual Machine (LLVM) [3].
The environment incorporated several fields:
financial trading strategies like mean-reversion
[9] or/and pair-trading [10]; parallel computing
and HPC models (e.g. SGL model [1] [2]),
real-time trading systems, as well as compi-
lation and code generation of programming
languages, etc.
In this paper we present an improved
real-time algorithmic trading system proto-
type with performance data and analysis.
Additionally, we have conducted performance
experiments to learn exact and quantitative
conditions under which the system can adapt
to varying data and hardware parameters.
In the first experiment, in Section 3, we
show how the financial-data stream processing
can scale to a variable number of incoming
streams and/or a variable number of hardware
processing elements. Globally the performance
model is a linear relationship between process-
Figure 2: Simplified Domain Model of the Real-Time Trading System Prototype.
ing rate, number of cores, and the number of
incoming streams. The experiments also reveal
exact threshold values related to real-time
processing and Java garbage collection. For
each parameter we describe a method whereby
our automatic code generation can adapt a
priori to optimize performance.
We also outline the scheme’s adaptation
to distributed-memory parallel processing in
the presence of multiple streams and multiple
processing elements. Further, we show how the
financial-data stream processing can scale to a
variable number of incoming streams and/or
a variable number of hardware processing
elements.
2 The System Prototype
Design and Implementa-
tion
2.1 Design
The DM of the prototype is shown in Figure 2
[3]. We tried to avoid the traditional method
in which code is generated several times
from very high-level abstract to high-level
programming languages, then to middle-level
and low-level programming languages, until
machine code is reached. Instead, UML
diagrams were used for the front-end and
Java (as a first step before an LLVM version)
as the back-end to generate executable code
directly from high-level specification. Inves-
tigation into specifying algorithmic trading
strategies using UML business models (see
Figure 1), model-driven development [12], and
automatic code generation for general purpose
programming languages was carried out [3], [5].
Additionally, reverse engineering [11] was
used to extract design models for the devel-
oped source code. The resulting prototype is
capable of generating code from UML business
models and predefined Java libraries; code
generation is used to produce executable code
from models, as discussed in [12].
2.2 Implementation
A Java code-generating prototype takes infor-
mation from a UML diagram (see Figure 1)
and creates real-time Java applications, sup-
porting parallel processing [5], [3]. As shown in
Figure 3: Example of the .ecore XML file.
Figure 4: The Parsed Data Example.
Figure 2, EMF is used to create a specification
for the plugin by using UML models. Using
the EMF plug-in the prototype is able to
produce a UML diagram of the specifications,
which is stored as an XML file known locally
as an .ecore file (see an xample on Figure 3).
The relevant information is extracted from the
.ecore file by using a simple Java parser, which
gathers the required methods from the library
and adds them to the generated output. The
parsed data example is shown in Figure 4.
The code generator then calls the parser which
takes UML data and creates the Stock Watch
Monitor Java application (Stock Watch). The
Stock Watch application collects data from
Yahoo in real-time and produces a table with
the data results, as shown in Figure 5 [5].
More information about prototype imple-
mentation can be obtained from the project
Figure 5: Real-Time Stock Watch Monitor with the Graphical Stock Information Diagram.
documentation [5] and from [3].
3 Optimization by code
generation
Having demonstrated a small but realistic
system based on our ”no-programming”
paradigm, we wish to extend its adaptive
features to non-functional properties like
performance.
As a first step in this direction, we have con-
ducted experiments in measuring performance
to learn exact and quantitative conditions un-
der which the system can adapt to varying data
and hardware parameters. In the first experi-
ment, we show how financial-data stream pro-
cessing can scale to a variable number of incom-
ing streams and/or a variable number of hard-
ware processing elements. Globally the perfor-
mance model is a linear relationship between
processing rate, number of cores and number of
incoming streams. But the experiments also re-
veal exact threshold values related to real-time
processing and Java garbage collection. For
each parameter we describe a method whereby
our automatic code generation can adapt a pri-
ori to optimize performance. We also outline
the scheme’s adaptation to distributed-memory
parallel processing in the presence of multiple
streams and multiple processing elements.
3.1 Experimental setup
The performance experiments we have con-
ducted consisted in processing streams of
real-time financial data from Yahoo finance
(dated June 2012) incoming at the rate of
1 record per second. Each input stream is
a sequence of quotation values for one stock
“symbol” among the following: GE, INTC,
YHOO, NVDA, ZNGA, EBAY, MU, ORCL,
GOOG, MSFT, RIMM, DELL, RY, BNS,
CSCO, SIRI.
An automated trading strategy will gen-
erally process incoming data one at a time,
accumulate some statistics, and issue orders
BUY, SELL, or NIL. We have generated
test “strategies” that compute a standard
deviation on the stock value and, to balance
the very-low frequency of incoming data
(HFT or High-frequency trading often runs
at maximal rates of hundreds of input-order
loops per second), we have artificially repeated
the computation a large number of times
within each input-output loop. Each loop’s
computational result is of no importance but
it represents a typical computation in HFT
since trading automata are often built from
decision trees using sliding statistics on the
input stream(s).
The generated Java code was run on a Sam-
sung portable computer with a 2-core Intel i5
processor running at 1.8GHz with 4GB of RAM
and Windows 7 Pro as 64-bit O.S.
3.2 Performance data and analy-
sis
Each performance experiment takes as in-
put between 1 and 16 streams, each one
corresponding to a particular stock symbol.
One processing thread has been generated to
process each input stream, as described above
and without synchronization between them.
For each thread and at each loop we have
measured the accumulated system time Tacc
in ms since the beginning of execution. Data
is buffered locally so there is no internet
transport delay to account for. The initial
record is already loaded when computation
starts and it is assumed that a new one arrives
every second. The real-time constraint for each
thread is thus to maintain Tacc <(1000ms)×n
where nis the number of loop runs since the
start. The application-specific performance
value we have computed is called overtime
and is computed as Tacc (1000ms) ×n. In
other words the experiments will measure the
conditions for keeping overtime negative i.e.
staying within real-time operations where the
process issues market orders no slower than
market data is received.
For example the 1-symbol (one financial
instrument data stream) experiment used the
input stream MSFT, one thread, and was
measured for 38 loop runs (see Figure 6). The
graph below shows the evolution of overtime
with the number of loops runs executed. The
full set of measurements for this experiment is
given in the Table 1.
Processing remains within real-time for 26
seconds and then takes a very steep evolution
to go up to 4.5 seconds behind real-time. We
attribute this sharp effect to Java garbage-
collection marked GC! in the table, as it is
Table 1: Performance data for the 1-instrument
experiment
Symbol Exec(ms) Nb. loops Over-time(ms)
MSFT 1866 1 -134
MSFT 2857 2 -143
MSFT 3913 3 -87
MSFT 4902 4 -98
MSFT 5904 5 -96
MSFT 6908 6 -92
MSFT 7902 7 -98
. . . . . . . . . . . .
MSFT 8903 8 -97
MSFT 9903 9 -97
MSFT 10905 10 -95
MSFT 11914 11 -86
MSFT 12904 12 -96
MSFT 13905 13 -95
MSFT 14904 14 -96
MSFT 15905 15 -95
MSFT 16905 16 -95
MSFT 17903 17 -97
MSFT 18916 18 -84
MSFT 19906 19 -94
MSFT 20905 20 -95
MSFT 21911 21 -89
MSFT 22904 22 -96
MSFT 23906 23 -94
MSFT 24910 24 -90
MSFT 25905 25 -95
MSFT 26942 26 -58
MSFT 28039 27 39 (GC!)
MSFT 29041 28 41 (GC!)
MSFT 30216 29 216 (GC!)
MSFT 31215 30 215 (GC!)
MSFT 32349 31 349 (GC!)
MSFT 33382 32 382 (GC!)
MSFT 34394 33 394 (GC!)
MSFT 35392 34 392 (GC!)
MSFT 36381 35 381 (GC!)
MSFT 37415 36 415 (GC!)
MSFT 38409 37 409 (GC!)
MSFT 39450 38 450 (GC!)
visibly not the effect of an accumulating (time)
delay, rather the effect of accumulating space
in the thread’s work space.
A defensive approach to this phenomenon
would be to measure the accumulating memory
Figure 6: Overtime vs Ticks.
consumption, allowing a-priori prediction of
the garbage-collection start time. However,
this would only allow the system to preven-
tively stop this thread before it damages
overall performance, not to prevent the end
of its’ real-time execution. A more aggressive
approach would be for our system to generate
code in a language where memory manage-
ment is explicit (C, C++, Ada or OCaml with
mutable variables) so that the memory leak is
avoided.
The 2-symbol experiment used two input
streams, instruments MSFT and INTC, two
independent threads to process them, param-
eters Tacc,nand overtime were tabulated for
each one up to 30 seconds. Because of the
unpredictable behaviour of thread scheduling,
it is not practical to predict/observe reliably
which threads will be slowest to arrive at each
loop cycle. In this case we compute overtime
as formula Tacc (1000ms) ×nfor the slowest
thread at each loop. The graph below shows
the evolution of overtime with the number of
loop runs executed.
With this setup, computation stays well
within real-time by a margin of more than
300ms, but the last few ticks show a degra-
dation that might announce the garbage
collection we had observed in the 1-symbol
measurements.
The 4-symbol experiment used input streams
for instruments GE, GOOG, INTC, MSFT,
and also four independent streams to process
them over 30 seconds. This time the overtime
stayed at about twice that for two symbols and
two threads: from -988ms, deteriorating slowly
up to -971, and then a sharp deterioration
during the last few seconds. The progress from
one to two and four threads appear to show
that overtime is (negatively) proportional to
the number of streams and threads, but that
is not the case. The 8-symbol experiment used
input streams for instruments GE, DELL,
SIRI, YHOO, GOOG, INTC, EBAY, MSFT
and as many independent threads to process
them. The overtime values were in fact very
close to those for the 4-symbol experiment.
Over 30 seconds they varied from -956ms to
-155 very regularly. We explain this progres-
sion by the accumulation of delays that can
be projected to non real-time processing after
about 40 seconds in this case.
The 16-symbol experiment used input
streams for instruments GE, INTC, YHOO,
Figure 7: Two-Symbol Experiment: Overtime vs Ticks.
NVDA, ZNGA, EBAY, MU, ORCL, GOOG,
MSFT, RIMM, DELL, RY, BNS, CSCO,
SIRI, and sixteen independent streams to
process them over 30 seconds. The evolution
of overtime is displayed in the graph below.
The progress is clearly linear and we explain
it by the accumulation of processing delays at
every loop. A subset of the full measurement
data for this experiment is shown in the Table
2.
Similar observations were made with 10, 12
and 14 instruments: when the two hardware
cores are sufficiently loaded, overtime evolves
linearly with time. However, the initial level of
overtime is not easily predicted from the num-
ber of symbol and threads.
3.3 Scaling up the hardware and
number of streams
Let us now outline solutions for scaling up
the experiments so that more threads can be
processed, and (positive) overtime delayed
for as long as possible, then ultimately avoided.
Let us assume that garbage collection can
be avoided by explicit memory management in
the target language of our generated code.
Assume also a fair thread scheduler or,
more natural for parallel processing, processes
in place of threads. This will result in the
elimination of variability between the various
thread processing loops; in normal situations
each one should run at the same speed, hence
avoiding load-balancing problems even on a
distributed-memory architecture.
If our 16-symbol experiment was run on a 4,
6, or 8-core system, the portion of timing re-
sponsible for the accumulated delay would be
divided, respectively, by 2, 3, or 4. This would
lead to a linear (in fact affine) decrease with the
number of cores, a trend that would be visible
in the initial parts of those experiments. If a
large architecture is benchmarked in this man-
ner, it becomes a simple matter to extrapolate
the sufficient number of cores to process our
streams in guaranteed real-time. Since those
measurements are quickly and easily performed
within a few minutes (or in advance) they can
become part of the automatic code generation
process and thus ensure real-time processing for
a known duration. This type of optimization
can be completely automated and even hidden
from the user if enough hardware resources are
Figure 8: Sixteen-Symbol Experiment: Overtime vs Ticks.
available.
3.4 Application to parallel port-
folio analysis
Financial risk management and some trading
strategies require real-time computations that
process a whole portfolio of symbols at each
input-decision loop. In pure computational
terms this amounts to a situation similar to
the one we have experimented with so far,
except that a single trading strategy program
inputs data from all streams in the portfolio
and outputs related trading orders repeatedly.
If the number of input streams is sufficiently
large like in our 8- to 16-symbol experiments,
then it is possible to structure a strategy
as a parallel program whose processes input
(subsets) of stream values, compute locally,
communicate and arrive at a global trading
decision based on global statistics.
Such a loop body is typical of data-parallel
computation and our recent work on the SGL
model [1] [2] has shown how to benchmark and
extrapolate performance for such programs.
SGL is a variant of Valiant’s Bulk-synchronous
parallel processing (BSP) and a generalization
of Map-Reduce. It can deal with hierarchical
and heterogeneous architectures that are now
very common. It assumes algorithm regular-
ities like those we have observed here, bench-
marks the architecture’s loop-processing speed,
network latency and network bandwidth. From
those parameters and the main data size factors
it becomes possible to extrapolate performance
to very large, even unavailable architectures in
a reliable way. We therefore propose that the
automatic code generation scheme presented in
this paper can be adapted with an SGL-like
performance model and data-parallel code gen-
eration, coupled with automatic adaptation to
given performance constraints.
4 Conclusion
We have provided here a case study for
performance optimization and code generation
from customized UML models, for the example
of a real-time algorithmic trading system
prototype. During the case study, an advanced
coding environment was developed for provid-
ing a visual and declarative approach used in
the development of algorithmic trading strate-
gies. This visual and declarative approach
prevents errors related to different tools, and
greatly simplifies developer challenges arising
from the need to focus on financial algorithms,
Table 2: Partial performance data for the 16-
instrument experiment. ”Max” is the maxi-
mum over-time over the 16 instruments (sym-
bols).
symbol Exec(ms) N. loops Over-time Max.
GE 778 1 -1222 -595
INTC 1233 1 -767 -
YHOO 1234 1 -766 -
NVDA 1248 1 -752 -
ZNGA 1249 1 -751 -
EBAY 1267 1 -733 -
MU 1301 1 -699 -
ORCL 1323 1 -677 -
GOOG 1336 1 -664 -
MSFT 1341 1 -659 -
RIMM 1343 1 -657 -
DELL 1343 1 -657 -
RY 1369 1 -631 -
BNS 1371 1 -629 -
CSCO 1404 1 -596 -
SIRI 1405 1 -595 -
GE 2034 2 -966 - 593
INTC 2226 2 -774 -
YHOO 2233 2 -767 -
ZNGA 2253 2 -747 -
MU 2297 2 -703 -
ORCL 2318 2 -682 -
NVDA 2321 2 -679 -
GOOG 2329 2 -671 -
MSFT 2341 2 -659 -
DELL 2355 2 -645 -
. . . . . . . . . . . . . . .
ORCL 31603 30 603 841
RY 31615 30 615 -
DELL 31647 30 647 -
MU 31660 30 660 -
ZNGA 31661 30 661 -
GE 31688 30 688 -
BNS 31714 30 714 -
RIMM 31715 30 715 -
SIRI 31722 30 722 -
GOOG 31723 30 723 -
INTC 31723 30 723 -
YHOO 31745 30 745 -
EBAY 31746 30 746 -
NVDA 31777 30 777 -
MSFT 31809 30 809 -
CSCO 31841 30 841 -
. . . . . . . . . . . . . . .
parallel computing and coding, etc. The coding
environment utilizes a visual and declarative
approach to developing algorithmic trading
strategies from financial specifications. A new
library of mathematical functions for stock
interactions and a code generating plug-in
for Eclipse were developed and implemented[3].
Additionally, we have conducted perfor-
mance experiments to determine exact and
quantitative conditions under which the sys-
tem can adapt to varying data and hardware
parameters. From these experiments we have
shown how the financial-data stream process-
ing can scale to a variable number of incom-
ing streams and/or a variable number of hard-
ware processing elements. For each parameter,
we describe a method whereby our automatic
code generation can adapt a priori to optimize
performance. We also outlined the scheme’s
adaptation to distributed-memory parallel pro-
cessing in the presence of multiple streams and
multiple processing elements. The automatic
code generation scheme presented in this paper
can be adapted with an SGL-like performance
model and data-parallel code generation, cou-
pled with automatic adaptation to given per-
formance constraints.
Future Work
The Prototype is a part of the ongoing joint
research and software engineering project
between Laboratory of d’Algorithmique,
Complexit´e et Logique Universit´e Paris-Est
Cr´eteil, France, Okanagan College and UBC
Okanagan, Canada. In this project, we
are attempting to design and implement an
end-user programming environment where
end-user code generation is accomplished
through interaction with customized business
UML models, and a predefined library of
functions. Additionally, the high-performance
computing solutions are to be implemented for
algorithmic trading systems from high-level
abstract models to low-level programming
languages by implementing the Low Level
Virtual Machine compiler infrastructure [4].
The current version of the prototype was
implemented for the Windows OS only, but
our clients wish to use multi-platform imple-
mentation, especially Linux. We started a
Spike Project in the COSC 470 SW Engineer-
ing Project course at Okanagan College in the
Fall 2012, but the porting was not finished suc-
cessfully. We are hoping to finish the Windows
based version migration in the Fall 2013.
Acknowledgements
Our thanks go to student software devel-
opment, software engineering and student
research project sponsors: IBM, Oracle, Mi-
crosoft, Vmware, VODA Computer Systems
Ltd. and for supporting us.
We would like to thank to Amazon.com for
four grants in 2010 - 2014.
Additional Authors
COSC 319 SW Engineering Project’s Team
Epik 2012, UBC Okanagan, Kelowna, BC,
Canada: Brandon Potter, Jesse Gaston,
Andrew Jankovic, Sam Boateng and William
Lee.
Kurt Fitz, undergraduate student of Bach-
elor of Information System program in Com-
puter Science department, Okanagan College,
Kelowna, BC, Canada.
About the Authors
Dr. Ga´etan Hains is Professor of Com-
puter Science at Universit Paris-Est Crteil,
Paris, France. He is member of Lab.
d’Algorithmique, Complexit´e et Logique,
Paris, France. He has cross-appointment as
researcher at EXQIM SAS Paris. His email
address is gaetan.hains@u-pec.fr.
Chong Li is a PhD Candidate of Computer
Science at Universit Paris-Est Crteil and
member of Lab. d’Algorithmique, Complexit´e
et Logique as well. His email address is
sglichong@gmail.com.
Dr. Youry Khmelevsky is Professor in Com-
puter Science at Okanagan College, Kelowna,
BC, Canada and Adjunct Professor in Com-
puter Science at Unit 5 Mathematics, Statis-
tics, Physics, Computer Science at UBC
Okanagan, Kelowna, BC, Canada. His email
address is Youry.Khmelevsky@UBC.ca.
References
[1] C. Li and G. Hains. (2011, Jul.)
A simple bridging model for high-
performance computing. High Per-
formance Computing and Simulation
(HPCS), 2011 International Confer-
ence on , pp.249-256. [Online]. Available:
http://dx.doi.org/10.1109/HPCSim.2011.5999831
[2] C. Li and G. Hains. (2012, Apr.) SGL:
towards a bridging model for heterogeneous
hierarchical platforms. Int. J. High Perfor-
mance Computing and Networking, Vol.
7, No. 2, pp.139151. [Online]. Available:
http://dx.doi.org/10.1504/IJHPCN.2012.046371
[3] Y. Khmelevsky, G. Hains and C. Li.
(2012, May) Automatic code generation
within student’s software engineering
projects. In Proceedings of the Seven-
teenth Western Canadian Conference
on Computing Education (WCCCE
’12). ACM, New York, NY, USA,
29-33. DOI=10.1145/2247569.2247578
[Online]. Available:
http://doi.acm.org/10.1145/2247569.2247578
[4] The LLVM Compiler Infrastructure. [On-
line]. Available: http://llvm.org/
[5] B. Potter, J. Gaston, A. Jankovic, S.
Boateng, and W. Lee (2012, Apr.)
Parallel Code Generation Plug-in XML
to Java Plug-in Project Documentation.
Team Epik. COSC 319 “SW Engineer-
ing Project” Final Project Report, Com-
puter Science Department, University of
British Columbia Okanagan, Kelowna, BC,
Canada.
[6] Y. Khmelevsky (2011, May). Research
and teaching strategies integration at
post-secondary programs. In Proceed-
ings of the 16th Western Canadian
Conference on Computing Educa-
tion (WCCCE ’11). ACM, New York,
NY, USA, 57-60. [Online]. Available:
http://doi.acm.org/10.1145/1989622.1989638
[7] Y. Khmelevsky. (2009, May) Software
development pro-jects in academia. In
Proceedings of the 14th Western Canadian
Conference on Computing Education
(Burnaby, British Columbia, Canada, May
01 - 02, 2009). R. Brouwer, D. Cukierman,
and G. Tsiknis, Eds. WCCCE ’09. ACM,
New York, NY, 60-64. [Online]. Available:
http://doi.acm.org/10.1145/1536274.1536292s
[8] Eclipse Modeling Framework
Project (EMF) [Online]. Available:
http://www.eclipse.org/modeling/emf/
[9] Mean reversion (finance). [Online]. Avail-
able: http://is.gd/1yHRhJ
[10] Pairs trade. [Online]. Available:
http://en.wikipedia.org/wiki/Pairs trade
[11] G. Canfora, M. Di Penta and L. Cerulo.
(2011, Apr.) Achievements and challenges
in software reverse engineering. Commun.
ACM 54, 4, 142-151. [Online]. Available:
http://doi.acm.org/10.1145/1924421.1924451
[12] S. Zschaler and A. Rashid. (2011, Jul.)
Towards modular code generators us-
ing symmetric language-aware aspects.
In Proceedings of the 1st International
Workshop on Free Composition (FREECO
’11). ACM, New York, NY, USA, Ar-
ticle 6 , 5 pages. [Online]. Available:
http://doi.acm.org/10.1145/2068776.2068782
[13] F. Mischkalla, D. He and W. Mueller.
(2010, Mar.) Closing the gap between
UML-based modeling, simulation and syn-
thesis of combined HW/software systems.
In Proceedings of the Conference on Design,
Automation and Test in Europe (DATE
’10). European Design and Automation As-
sociation, 3001 Leuven, Belgium, Belgium,
1201-1206.
[14] B. Potter, J. Gaston, A. Jankovic,
S. Boateng, and W. Lee (2012, Apr.)
Parallel Code Generation Plug-in XML
to Java Plug-in Project Documenta-
tion: Source Code and Design Diagrams.
Team Epik. COSC 319 “SW Engi-
neering Project” Final Project Report,
Computer Science Department, Uni-
versity of British Columbia Okanagan,
Kelowna, BC, Canada. [Online]. Available:
http://sourceforge.net/projects/pestplugin/files/
... He taught for about 20 years bulk-synchronous parallel (BSP) programming, which is based on a paradigm of global synchronous communications allowing a realistic performance ("cost") model -that leads to portable and scalable algorithm design, or in the case of beginner students, the realistic prototyping of parallel algorithms without parallel machine. We already introduced BSP parallel programming paradigm into small applied research projects successfully [34] and continue our educational development. ...
... This is both an exercise in declarative numerical programming, and a systematic introduction to performance benchmarking and modelling. In previous research projects sophomore and upper level students successfully investigated servers workload and many different applications/game servers performance issues [34], [26], [27], [35], but those projects were too complex for the freshman students. After observing this problem we adapted our tasks and research projects for very young, but skillful students. ...
Preprint
Full-text available
In this paper, we discuss the educational value of a few mid-size and one large applied research projects at the Computer Science Department of Okanagan College (OC) and at the Universities of Paris East Creteil (LACL) and Orleans (LIFO) in France. We found, that some freshmen students are very active and eager to be involved in applied research projects starting from the second semester. They are actively participating in programming competitions and want to be involved in applied research projects to compete with sophomore and older students. Our observation is based on five NSERC Engage College and Applied Research and Development (ARD) grants, and several small applied projects. Student involvement in applied research is a key motivation and success factor in our activities, but we are also involved in transferring some results of applied research, namely programming techniques, into the parallel programming courses for beginners at the senior- and first-year MSc levels. We illustrate this feedback process with programming notions for beginners, practical tools to acquire them and the overall success/failure of students as experienced for more than 10 years in our French University courses.
... A number of educational research papers on student competitions' design and evaluation are already published [11], [12], [13], but in our short paper here, we discuss the educational impact on introductory programming courses via organization of student competitions and student participation in annual programming competitions. ...
Preprint
Full-text available
In this short paper we report on student programming competition results by students from the Computer Science Department (COSC) of Okanagan College (OC) and discuss the achieved results from an educational point of view. We found that some freshmen and sophomore students in diploma and degree programs are very capable and eager to be involved in applied research projects as early as the second semester, and into local and international programming competitions as well. Our observation is based on the last 2 educational years, beginning 2015 when we introduced programming competitions to COSC students. Students reported that participation in competitions give them motivation to effectively learn in their programming courses, inspire them to learn deeper and more thoroughly, and help them achieve better results in their classes.
... funding for 3 years in 2015. Many students were able to publish undergraduate research papers and presented their results at research conferences, including WCCCE [6], IEEE SysCon [7], VisioGame, IEEE SAI [8] and [9], IEEE Par-compTech [10], IEEE HPCS [11], IEEE CCECE (two papers were accepted just in 2016), and some other papers were accepted by professional conferences. A student research paper was recognized as the best research paper at VisioGame2014 [12]. ...
Conference Paper
Full-text available
In this paper we discuss ten years of teaching of "Projects in Computer Science" (COSC 224), "Software Engineering" with the following "Software Engineering Project" capstone projects (COSC 470 and COSC 471 respectfully) at the Computer Science Department of Okanagan College (OC). We included "Object-Oriented Systems Analysis and Design" (COSC 236) course in the discussion, which was used for the initial systems analysis and design in the Fall before the project development in COSC 224 in the Winter, as it was suggested by the students in several anonymous program reviews. Also we provide retrospective analysis and evaluation of capstone projects, starting from very small artificial projects, then moving on to projects with international industrial sponsors and sponsors from universities. Then, after many discussions with the students and within our department we decided to work with local small companies instead of large international corporations and universities. Starting from 2013 many capstone projects in both COSC 236/224 and COSC 470/471 supported applied research projects at Computer Science department, especially those that were related to the projects supported by the "Natural Sciences and Engineering Research Council of Canada (NSERC)" in 2014--2016.
Data
Full-text available
Data for the working paper "A Study of the Evolution and Current State of Automated Trading"
Conference Paper
Full-text available
In this paper we discuss several capstone student projects conducted by the students at University of British Columbia, Okanagan campus (UBCO) and at Okanagan College in different years. The aim of the projects was to demonstrate how end-users could update code for an industrial application (an algorithmic trading system) without any programming skills and programming experience. Another goal was to improve performance for the applications collection of stock information from online public sources by introducing parallel code execution on multi-core personal computers. Real algorithmic trading system requirements were used as a case study. An Eclipse Modelling Framework was used to generate Java code from a UML business model, which can be modified by unexperienced business users. Moreover, code execution can be scaled to a specific computer architecture and hardware for better performance and better computer resources utilization, especially if a business user wants to collect and analyze a long list of stocks. The last section of the paper focuses on performance optimization and analysis.
Article
Full-text available
This paper introduces the Scatter-Gather parallel-programming and parallel execution model in the form of a simple imperative Scatter-Gather Language (SGL). Its design is based on past experience with bulk-synchronous parallel (BSP) programming and BSP language design. SGL's novel features are motivated by the last decade's move towards multi-level and heterogeneous parallel architectures involving multi-core processors, graphics accelerators and hierarchical routing networks in the largest multiprocessing systems. The design of SGL is coherent with L. Valiant's multi-BSP while offering a programming interface that is even simpler than the primitives of bulk-synchronous parallel ML (BSML). SGL appears to cover a large subset of all BSP algorithms while avoiding complex message-passing programming. Like all BSP-inspired systems, it supports predictable, portable and scalable performance. Moreover, SGL's explicit data distribution will allow automatic or programmable load-balancing.
Article
Full-text available
In this paper, we describe the integration of research and new teaching strategies into computer science and engineering departments at universities and colleges related to the automatic code generation, automatic development tools and integrated environments within student software (software) engineering and research projects. A significant amount of current software engineering research is conducted within the context of computer science, computing and engineering departments or colleges. However, every computer department has its own experiences, successes or pitfalls in Software Engineering and software development teaching and student research integration, which would be useful to share and discuss with the education community. We will discuss our experiences and results from seven years of teaching Software EngineeringCoSc 470/471 and Projects in Computer Science CoSc 224 (PCS) in Computer Information Systems (CIS) diploma and Bachelor of Computer Information Systems (BCIS) degree programs at Okanagan College (OC), Université Paris-Est Créteil (UPEC), France and almost 2 years of teaching at University of British Columbia Okanagan (UBC O). We suggest possible ways of integrating Software Engineering research and teaching strategies by using many different industrial software Engineering tools, development workbenches, frameworks and environments to automatize code generation and speed up student project development within student capstone projects into computer science departments at universities and colleges.
Chapter
Full-text available
We think that over the next few years, the goal of interactive systems and services will evolve from just making systems easy to use (even though that goal has not yet been completely achieved) to making systems that are easy to develop by end users. By now, most people have become familiar with the basic functionality and interfaces of computers, but they are not able to manage any programming language. Therefore, they cannot develop new applications or modify current ones according to their needs. In order to address such challenges it is necessary a new paradigm, based on a multidisciplinary approach involving several types of expertise, such as software engineering, human-computer interaction, CSCW, which are now rather fragmented and with little interaction. The resulting methods and tools can provide results useful across many application domains, such as ERP, multi-device services (accessible through both mobile and stationary devices), and professional applications. Key words. tailorability, end user programming, flexibility, usability
Conference Paper
Full-text available
This paper introduces the Scatter-Gather parallel-programming and parallel execution model in the form of a simple imperative language named SGL. Its design is based on experience with Bulk-synchronous parallel (BSP) programming and BSP languages. SGL's novel features are motivated by the last decade's move to multi-level and heterogeneous parallel architectures involving multi-core processors, graphics accelerators and hierarchical routing networks. The design of SGL is coherent with Valiant's Multi-BSP while offering a programming interface even simpler than the primitives of Bulk-Synchronous parallel ML (BSML). SGL appears to cover a large subset of all BSP algorithms while avoiding complex message-passing programming. It allows automatic load balancing and like all BSP-inspired systems, predictable, portable and scalable performance.
Conference Paper
Full-text available
UML is widely applied for the specification and modeling of software and some studies have demonstrated that it is applicable for HW/SW codesign. However, in this area there is still a big gap from UML modeling to SystemC-based verification and synthesis environments. This paper presents an efficient approach to bridge this gap in the context of Systems-on-a-Chip (SoC) design. We propose a framework for the seamless integration of a customized SysML entry with code generation for HW/SW cosimulation and high-level FPGA synthesis. For this, we extended the SysML UML profile by SystemC and synthesis capabilities. Two case studies demonstrate the applicability of our approach.
Article
The Communications Web site, http://cacm.acm.org, features more than a dozen bloggers in the BLOG@CACM community. In each issue of Communications, we'll publish selected posts or excerpts.twitterFollow us on Twitter ...
Article
As users continue to grow in number and diversity, end-user programming is playing an increasingly central role in shaping software to meet the broad, varied, rapidly changing needs of the world. Numerous companies have therefore begun to sell tools enabling end users to create programs. In parallel, ongoing academic research is aimed at helping end-user programmers create and adapt new kinds of programs in new ways. This special interest group meeting will bring together the community of researchers and companies focused on creating end-user programming tools, thereby facilitating technology transfer and future collaboration.
Article
In this paper, we describe the integration of research and teaching strategies into computer science and engineering departments at universities and colleges. A significant amount of current software engineering research is conducted within the context of computer science, computing and engineering departments or colleges. Similarly, computer and computing science, electrical and software engineering degree programs are being developed by such academic units as well as within engineering colleges. However, every computer or engineering department has its own experiences, successes or pitfalls in software engineering and software development teaching and student research integration, which would be useful to share and discuss with the education community. In this paper we discuss the experiences and results from five years of teaching Software Engineering (SE) and Projects in Computer Science (PCS) in Computer Information Systems (CIS) diploma and Bachelor of Computer Information Systems (BCIS) degree programs at Okanagan College (OC). Also we provide possible ways of integrating research and teaching strategies into computer science departments at universities and colleges as well as our preliminary results.
Article
A significant amount of current software engineering research is conducted within the context of computer science and computing departments or colleges. Similarly, software engineering degree programs are being developed by such academic units as well as within engineering colleges [1]. However, every computer or computing department has its own experiences, successes or pitfalls in software engineering (SE) and software development (SD) teaching, which would be useful to share and discuss with the education community. In this paper we discuss the experiences and results from four years of teaching "Projects in Computer Science" in Computer Information Systems (CIS) Diploma and "Software Engineering" in Bachelor of Computer Information Systems (BCIS) Degree programs [2] at Okanagan College. Also we provide analysis and evaluation for several already finished and current projects. The class teaching in both programs was organized into two parts. The learning of SD in the CIS as well as SE in the BCIS programs were synchronized with the practical SD and SE projects with real sponsors from industry and academia in small and medium size groups of students (3--6 members in SD and 5--11 members in SE projects). Students developed their final projects incorporating four main Rational Unified Process phases [3] and 4--7 short iterations typical to the Agile SD process. Additionally, in the SE projects students learned and used Extreme Programming (XP) iterative process [4]. In several projects students successfully combined Software prototyping [5] with Agile SD and Rapid Application Development (RAD) tools [6]. Instructors supervised and supported students in the role of sponsors or mediators. Many student groups were able to develop impressive, high quality final project applications and systems. The sponsors provided very positive feedback and references for most of the projects.
Article
Model-driven engineering, especially using domain-specific lan-guages, allows constructing software from abstractions that are more closely fitted to the problem domain and that better hide technical details of the solution space. Code generation is used to produce ex-ecutable code from these abstractions, which may result in individ-ual concerns being scattered and tangled throughout the generated code. The challenge, then, becomes how to modularise the code-generator templates to avoid scattering and tangling of concerns within the templates themselves. This paper shows how symmet-ric, language-aware approaches to aspect orientation can be applied to code generation to improve modularisation support.