|
132
|
1 |
<?xml version="1.0" encoding="utf-8"?>
|
|
|
2 |
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
|
3 |
<HEAD>
|
|
|
4 |
<TITLE>2012/13 BSc Projects</TITLE>
|
|
465
|
5 |
<BASE HREF="http://nms.kcl.ac.uk/christian.urban/">
|
|
132
|
6 |
<script type="text/javascript" src="striper.js"></script>
|
|
|
7 |
<link rel="stylesheet" href="nominal.css">
|
|
|
8 |
</HEAD>
|
|
|
9 |
<BODY TEXT="#000000"
|
|
|
10 |
BGCOLOR="#4169E1"
|
|
|
11 |
LINK="#0000EF"
|
|
|
12 |
VLINK="#51188E"
|
|
|
13 |
ALINK="#FF0000"
|
|
|
14 |
ONLOAD="striper('ul','striped','li','first,second')">
|
|
|
15 |
|
|
|
16 |
|
|
|
17 |
|
|
|
18 |
<TABLE WIDTH="100%"
|
|
|
19 |
BGCOLOR="#4169E1"
|
|
|
20 |
BORDER="0"
|
|
|
21 |
FRAME="border"
|
|
|
22 |
CELLPADDING="10"
|
|
|
23 |
CELLSPACING="2"
|
|
|
24 |
RULES="all">
|
|
|
25 |
|
|
|
26 |
<TR>
|
|
|
27 |
<TD BGCOLOR="#FFFFFF"
|
|
|
28 |
WIDTH="75%"
|
|
|
29 |
VALIGN="TOP">
|
|
|
30 |
|
|
|
31 |
<H2>2012/13 BSc Projects</H2>
|
|
|
32 |
<H4>Supervisor: Christian Urban</H4>
|
|
151
|
33 |
<H4>Email: christian dot urban at kcl dot ac dot uk, Office: Strand Building S1.27</H4>
|
|
132
|
34 |
<H4>If you are interested in a project, please send me an email and we can discuss details. Please include
|
|
|
35 |
a short description about your programming skills and Computer Science background in your first email.
|
|
|
36 |
I will also need your King's username in order to book the project for you. Thanks.</H4>
|
|
|
37 |
|
|
143
|
38 |
<H4>Note that besides being a lecturer at the theoretical end of Computer Science, I am also a passionate
|
|
132
|
39 |
<A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker</A> …
|
|
|
40 |
defined as “a person who enjoys exploring the details of programmable systems and
|
|
|
41 |
stretching their capabilities, as opposed to most users, who prefer to learn only the minimum
|
|
|
42 |
necessary.” I am always happy to supervise like-minded students.</H4>
|
|
|
43 |
|
|
|
44 |
<ul class="striped">
|
|
|
45 |
<li> <H4>[CU1] Automata Minimisation</H4>
|
|
|
46 |
|
|
143
|
47 |
<p>
|
|
|
48 |
<B>Description:</b>
|
|
132
|
49 |
<A HREF="http://en.wikipedia.org/wiki/Deterministic_finite_automaton">Deterministic finite automata</A>
|
|
|
50 |
have many uses in Computer Science, for example for lexing
|
|
|
51 |
program code. In order to improve their run-time, automata need to be minimised, that
|
|
|
52 |
is transformed into equivalent automata with the smallest possible number of state
|
|
|
53 |
nodes.
|
|
|
54 |
</p>
|
|
|
55 |
|
|
|
56 |
<p>
|
|
|
57 |
There is a little known method for minimising deterministic finite
|
|
|
58 |
automata by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
|
|
|
59 |
Janusz Brzozowski</A>.
|
|
|
60 |
This method first reverses the edges of an automaton, which produces
|
|
|
61 |
a potentially non-deterministic automaton. The non-deterministic automaton is
|
|
|
62 |
then determinised using the usual powerset construction. This is repeated
|
|
|
63 |
once more and voila you obtain a minimised version of the automaton
|
|
|
64 |
you started with. It is rather surprising that this method works at all:
|
|
|
65 |
the powerset construction might produce an automaton with an exponentially
|
|
|
66 |
larger number of states, completely contrary to the idea of minimising the
|
|
|
67 |
number of states. The task of this project is to implement this method, check that
|
|
|
68 |
it actually works with some examples and
|
|
|
69 |
compare it with more traditional methods for automata minimisation
|
|
|
70 |
(in terms of run-time, code complexity, etc). Examples can be
|
|
133
|
71 |
obtained by translating regular expressions into automata. A natural extension
|
|
|
72 |
of the project is therefore to implement a recogniser for regular expressions
|
|
|
73 |
following, for example, this <A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A>.
|
|
132
|
74 |
</p>
|
|
|
75 |
|
|
|
76 |
<p>
|
|
|
77 |
<B>Literature:</B>
|
|
|
78 |
A good place to start with this project are the wikipedia articles
|
|
|
79 |
<A HREF="http://en.wikipedia.org/wiki/DFA_minimization">here</A> and
|
|
|
80 |
<A HREF="http://en.wikipedia.org/wiki/Powerset_construction">here</A>.
|
|
|
81 |
The authoritative <A HREF="http://infolab.stanford.edu/~ullman/ialc.html">book</A>
|
|
|
82 |
on automata is by John Hopcroft and Jeffrey Ullmann (available in the library).
|
|
|
83 |
There is also an online course about automata by Ullman at
|
|
|
84 |
<A HREF="https://www.coursera.org/course/automata">Coursera</A>, though IMHO not
|
|
|
85 |
done with love. There
|
|
|
86 |
is also the book <i>Automata and Computability</i> by
|
|
|
87 |
<A HREF="http://www.cs.cornell.edu/~kozen/">Dexter Kozen</A> including more
|
|
|
88 |
advanced material about automata.
|
|
|
89 |
Finally, there are millions of other pointers about automata
|
|
145
|
90 |
minimisation on the web. Finally, I will give a lot of the background in
|
|
|
91 |
my Automata and Formal Languages course (6CCS3AFL), which starts in September.
|
|
132
|
92 |
</p>
|
|
|
93 |
|
|
|
94 |
<p>
|
|
|
95 |
<B>Skills:</B>
|
|
|
96 |
This is a project for a student with an interest in theory and some
|
|
|
97 |
reasonable programming skills. The project can be easily implemented
|
|
|
98 |
in languages like
|
|
|
99 |
<A HREF="http://www.scala-lang.org/">Scala</A>,
|
|
|
100 |
<A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,
|
|
|
101 |
<A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>,
|
|
|
102 |
<A HREF="http://www.python.org">Python</A>, etc.
|
|
|
103 |
</p>
|
|
|
104 |
|
|
|
105 |
<li> <H4>[CU2] Equivalence Checking of Regular Expressions</H4>
|
|
|
106 |
|
|
143
|
107 |
<p>
|
|
|
108 |
<B>Description:</b>
|
|
132
|
109 |
Solving the problem of deciding the equivalence of regular expressions can be used
|
|
|
110 |
to decide a number of problems in automated reasoning. Recently,
|
|
|
111 |
<A HREF="http://www.cs.unibo.it/~asperti/">Andreas Asperti</A>
|
|
|
112 |
proposed a simple method for deciding regular expression equivalence described
|
|
|
113 |
<A HREF="http://www.cs.unibo.it/~asperti/PAPERS/compact.pdf">here</A>.
|
|
|
114 |
The task is to implement this method and test it on examples.
|
|
133
|
115 |
It would be also interesting to see whether Asperti's method applies to
|
|
132
|
116 |
extended regular expressions, described
|
|
|
117 |
<A HREF="http://ww2.cs.mu.oz.au/~sulzmann/manuscript/reg-exp-partial-derivatives.pdf">here</A>.
|
|
|
118 |
</p>
|
|
|
119 |
|
|
|
120 |
<p>
|
|
|
121 |
<B>Literature:</B>
|
|
|
122 |
The central literature is obviously the papers
|
|
|
123 |
<A HREF="http://www.cs.unibo.it/~asperti/PAPERS/compact.pdf">here</A> and
|
|
|
124 |
<A HREF="http://ww2.cs.mu.oz.au/~sulzmann/manuscript/reg-exp-partial-derivatives.pdf">here</A>.
|
|
|
125 |
Asperti has also some slides <A HREF="http://www.cs.unibo.it/~asperti/SLIDES/regular.pdf">here</a>.
|
|
|
126 |
More references about regular expressions can be found
|
|
145
|
127 |
<A HREF="http://en.wikipedia.org/wiki/Regular_expression">here</A>. Like in
|
|
|
128 |
[CU1], I will give a lot of the background pf this project in
|
|
|
129 |
my Automata and Formal Languages course (6CCS3AFL).
|
|
132
|
130 |
</p>
|
|
|
131 |
|
|
|
132 |
<p>
|
|
|
133 |
<B>Skills:</B>
|
|
|
134 |
This is a project for a student with a passion for theory and some
|
|
|
135 |
reasonable programming skills. The project can be easily implemented
|
|
|
136 |
in languages like Scala
|
|
|
137 |
<A HREF="http://www.scala-lang.org/">Scala</A>,
|
|
|
138 |
<A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,
|
|
|
139 |
<A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>,
|
|
|
140 |
<A HREF="http://www.python.org">Python</A>, etc.
|
|
|
141 |
Being able to read <A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>
|
|
|
142 |
code is beneficial for the part involving extended regular expressions.
|
|
|
143 |
</p>
|
|
|
144 |
|
|
|
145 |
<li> <H4>[CU3] Machine Code Generation for a Simple Compiler</H4>
|
|
|
146 |
|
|
143
|
147 |
<p>
|
|
|
148 |
<b>Description:</b>
|
|
132
|
149 |
Compilers translate high-level programs that humans can read and write into
|
|
|
150 |
efficient machine code that can be run on a CPU or virtual machine.
|
|
|
151 |
I recently implemented a very simple compiler for a very simple functional
|
|
|
152 |
programming language following this
|
|
|
153 |
<A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-toplas.pdf">paper</A>
|
|
|
154 |
(also described <A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-tr.pdf">here</A>).
|
|
|
155 |
My code, written in <A HREF="http://www.scala-lang.org/">Scala</A>, of this compiler is
|
|
|
156 |
<A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/compiler.scala">here</A>.
|
|
|
157 |
The compiler can deal with simple programs involving natural numbers, such
|
|
|
158 |
as Fibonacci numbers
|
|
|
159 |
or factorial (but it can be easily extended - that is not the point).
|
|
|
160 |
</p>
|
|
|
161 |
|
|
|
162 |
<p>
|
|
|
163 |
While the hard work has been done (understanding the two papers above),
|
|
|
164 |
my compiler only produces some idealised machine code. For example I
|
|
|
165 |
assume there are infinitely many registers. The goal of this
|
|
133
|
166 |
project is to generate machine code that is more realistic and can
|
|
|
167 |
run on a CPU, like x86, or run on a virtual machine, say the JVM.
|
|
132
|
168 |
This gives probably a speedup of thousand times in comparison to
|
|
|
169 |
my naive machine code and virtual machine. The project
|
|
|
170 |
requires to dig into the literature about real CPUs and generating
|
|
|
171 |
real machine code.
|
|
|
172 |
</p>
|
|
|
173 |
|
|
|
174 |
<p>
|
|
|
175 |
<B>Literature:</B>
|
|
|
176 |
There is a lot of literature about compilers
|
|
|
177 |
(for example <A HREF="http://www.cs.princeton.edu/~appel/papers/cwc.html">this book</A> -
|
|
|
178 |
I can lend you my copy for the duration of the project). A very good overview article
|
|
|
179 |
about implementing compilers by
|
|
|
180 |
<A HREF="http://tratt.net/laurie/">Laurie Tratt</A> is
|
|
|
181 |
<A HREF="http://tratt.net/laurie/tech_articles/articles/how_difficult_is_it_to_write_a_compiler">here</A>.
|
|
|
182 |
An introduction into x86 machine code is <A HREF="http://ianseyler.github.com/easy_x86-64/">here</A>.
|
|
134
|
183 |
Intel's official manual for the x86 instruction is
|
|
144
|
184 |
<A HREF="http://download.intel.com/design/intarch/manuals/24319101.pdf">here</A>.
|
|
132
|
185 |
A simple assembler for the JVM is described <A HREF="http://jasmin.sourceforge.net">here</A>.
|
|
|
186 |
An interesting twist of this project is to not generate code for a CPU, but
|
|
|
187 |
for the intermediate language of the <A HREF="http://llvm.org">LLVM</A> compiler
|
|
|
188 |
(also described <A HREF="https://wiki.aalto.fi/display/t1065450/LLVM+IR">here</A> and
|
|
143
|
189 |
<A HREF="http://llvm.org/docs/LangRef.html">here</A>). If you want to see
|
|
|
190 |
what machine code looks like you can compile your C-program using gcc -S.
|
|
132
|
191 |
</p>
|
|
|
192 |
|
|
143
|
193 |
<p>
|
|
|
194 |
<B>Skills:</B>
|
|
132
|
195 |
This is a project for a student with a deep interest in programming languages and
|
|
|
196 |
compilers. Since my compiler is implemented in <A HREF="http://www.scala-lang.org/">Scala</A>,
|
|
|
197 |
it would make sense to continue this project in this language. I can be
|
|
|
198 |
of help with questions and books about <A HREF="http://www.scala-lang.org/">Scala</A>.
|
|
|
199 |
But if Scala is a problem, my code can also be translated quickly into any other functional
|
|
|
200 |
language.
|
|
|
201 |
</p>
|
|
|
202 |
|
|
|
203 |
<li> <H4>[CU4] Implementation of Register Spilling Algorithms</H4>
|
|
|
204 |
|
|
143
|
205 |
<p>
|
|
|
206 |
<b>Description:</b>
|
|
132
|
207 |
This project is similar to [CU3]. The emphasis here, however, is on the
|
|
|
208 |
implementation and comparison of register spilling algorithms, also often called register allocation
|
|
|
209 |
algorithms. They are part of any respectable compiler. As said
|
|
|
210 |
in [CU3], however, my simple compiler lacks them and assumes an infinite amount of registers instead.
|
|
|
211 |
Real CPUs however only provide a fixed amount of registers (for example
|
|
|
212 |
x86-64 has 16 general purpose registers). Whenever a program needs
|
|
|
213 |
to hold more values than registers, the values need to be “spilled”
|
|
|
214 |
into the main memory. Register spilling algorithms try to minimise
|
|
|
215 |
this spilling, since fetching values from main memory is a costly
|
|
|
216 |
operation.
|
|
|
217 |
</p>
|
|
|
218 |
|
|
|
219 |
<p>
|
|
|
220 |
The classic algorithm for register spilling uses a
|
|
|
221 |
<A HREF="http://en.wikipedia.org/wiki/Register_allocation">graph-colouring method</A>.
|
|
|
222 |
However, for some time the <A HREF="http://llvm.org">LLVM</A> compiler
|
|
|
223 |
used a supposedly more efficient method, called the linear scan allocation method
|
|
|
224 |
(described
|
|
|
225 |
<A HREF="http://www.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf">here</A>).
|
|
|
226 |
However, it was later decided to abandon this method in favour of
|
|
|
227 |
a <A HREF="http://blog.llvm.org/2011/09/greedy-register-allocation-in-llvm-30.html">
|
|
|
228 |
greedy register allocation</A> method. It would be nice if this project can find out
|
|
|
229 |
what the issues are with these methods and implement at least one of them for the
|
|
|
230 |
simple compiler referenced in [CU3].
|
|
|
231 |
</p>
|
|
|
232 |
|
|
|
233 |
<p>
|
|
|
234 |
<B>Literature:</B>
|
|
|
235 |
The graph colouring method is described in Andrew Appel's
|
|
|
236 |
<A HREF="http://www.cs.princeton.edu/~appel/modern/java/">book</A> on compilers
|
|
|
237 |
(I can give you my copy of this book, if it is not available in the library).
|
|
|
238 |
There is also a survey
|
|
|
239 |
<A HREF="http://compilers.cs.ucla.edu/fernando/publications/drafts/survey.pdf">article</A>
|
|
|
240 |
about register allocation algorithms with further pointers.
|
|
|
241 |
</p>
|
|
|
242 |
|
|
143
|
243 |
<p>
|
|
|
244 |
<B>Skills:</B>
|
|
132
|
245 |
Same skills as [CU3].
|
|
|
246 |
</p>
|
|
|
247 |
|
|
|
248 |
<li> <H4>[CU5] A Student Polling System</H4>
|
|
143
|
249 |
|
|
132
|
250 |
<p>
|
|
|
251 |
<B>Description:</B>
|
|
|
252 |
One of the more annoying aspects of giving a lecture is to ask a question
|
|
|
253 |
to the students and no matter how easy the questions is to not
|
|
|
254 |
receive an answer. Recently, the online course system
|
|
|
255 |
<A HREF="http://www.udacity.com">Udacity</A> made an art out of
|
|
|
256 |
asking questions during lectures (see for example the
|
|
|
257 |
<A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A>
|
|
|
258 |
course CS253).
|
|
|
259 |
The lecturer there gives multiple-choice questions as part of the lecture and the students need to
|
|
|
260 |
click on the appropriate answer. This works very well in the online world.
|
|
|
261 |
For “real-world” lectures, the department has some
|
|
|
262 |
<A HREF="http://en.wikipedia.org/wiki/Audience_response">clickers</A>
|
|
|
263 |
(these are little devices part of an audience response systems). However,
|
|
|
264 |
they are a logistic nightmare for the lecturer: they need to be distributed
|
|
|
265 |
during the lecture and collected at the end. Nowadays, where students
|
|
|
266 |
come with their own laptop or smartphone to lectures, this can
|
|
|
267 |
be improved.
|
|
|
268 |
</p>
|
|
|
269 |
|
|
|
270 |
<p>
|
|
|
271 |
The task of this project is to implement an online student
|
|
|
272 |
polling system. The lecturer should be able to prepare
|
|
|
273 |
questions beforehand (encoded as some web-form) and be able to
|
|
|
274 |
show them during the lecture. The students
|
|
|
275 |
can give their answers by clicking on the corresponding webpage.
|
|
|
276 |
The lecturer can then collect the responses online and evaluate them
|
|
|
277 |
immediately. Such a system is sometimes called
|
|
|
278 |
<A HREF="http://en.wikipedia.org/wiki/Audience_response#Smartphone_.2F_HTTP_voting">HTML voting</A>.
|
|
|
279 |
There are a number of commercial
|
|
|
280 |
solutions for this problem, but they are not easy to use (in addition
|
|
|
281 |
to being ridiculously expensive). A good student can easily improve upon
|
|
|
282 |
what they provide.
|
|
|
283 |
</p>
|
|
|
284 |
|
|
|
285 |
<p>
|
|
|
286 |
The problem of student polling is not as hard as
|
|
|
287 |
<A HREF="http://en.wikipedia.org/wiki/Electronic_voting">electronic voting</A>,
|
|
|
288 |
which essentially is still an unsolved problem in Computer Science. The
|
|
|
289 |
students only need to be prevented from answering question more than once thus skewing
|
|
|
290 |
any statistics. Unlike electronic voting, no audit trail needs to be kept
|
|
133
|
291 |
for student polling. Restricting the number of answers can probably be solved
|
|
132
|
292 |
by setting appropriate cookies on the students
|
|
|
293 |
computers or smart phones.
|
|
|
294 |
</p>
|
|
|
295 |
|
|
|
296 |
<p>
|
|
|
297 |
<B>Literature:</B>
|
|
|
298 |
The project requires fluency in a web-programming language (for example
|
|
|
299 |
<A HREF="http://en.wikipedia.org/wiki/JavaScript">Javascript</A>,
|
|
|
300 |
<A HREF="http://en.wikipedia.org/wiki/PHP">PHP</A>,
|
|
143
|
301 |
Java, <A HREF="http://www.python.org">Python</A>,
|
|
|
302 |
<A HREF="http://en.wikipedia.org/wiki/Go_(programming_language)">Go</A>,
|
|
|
303 |
<A HREF="http://www.scala-lang.org/">Scala</A>,
|
|
132
|
304 |
<A HREF="http://en.wikipedia.org/wiki/Ruby_(programming_language)">Ruby</A>)
|
|
|
305 |
and possibly a cloud application platform (for example
|
|
|
306 |
<A HREF="https://developers.google.com/appengine/">Google App Engine</a> or
|
|
|
307 |
<A HREF="http://www.heroku.com">Heroku</A>).
|
|
|
308 |
For web-programming the
|
|
|
309 |
<A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A>
|
|
|
310 |
course at <A HREF="http://www.udacity.com">Udacity</A> is a good starting point
|
|
|
311 |
to be aware of the issues involved. This course uses <A HREF="http://www.python.org">Python</A>.
|
|
133
|
312 |
To evaluate the answers from the student, Google's
|
|
|
313 |
<A HREF="https://developers.google.com/chart/image/docs/making_charts">Chart Tools</A>
|
|
|
314 |
might be useful, which ar also described in this
|
|
|
315 |
<A HREF="http://www.youtube.com/watch?v=NZtgT4jgnE8">youtube</A> video.
|
|
132
|
316 |
</p>
|
|
|
317 |
|
|
143
|
318 |
<p>
|
|
|
319 |
<B>Skills:</B>
|
|
132
|
320 |
In order to provide convenience for the lecturer, this project needs very good web-programming skills. A
|
|
|
321 |
<A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker mentality</A>
|
|
|
322 |
(see above) is probably very beneficial: web-programming is an area that only emerged recently and
|
|
|
323 |
many tools still lack maturity. You probably have to experiment a lot with several different
|
|
|
324 |
languages and tools.
|
|
|
325 |
</p>
|
|
|
326 |
|
|
140
|
327 |
<li> <H4>[CU6] Implementation of a Distributed Clock-Synchronisation Algorithm developed at NASA</H4>
|
|
143
|
328 |
|
|
140
|
329 |
<p>
|
|
|
330 |
<B>Description:</B>
|
|
141
|
331 |
There are many algorithms for synchronising clocks. This
|
|
140
|
332 |
<A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A>
|
|
141
|
333 |
describes a new algorithm for clocks that communicate by exchanging
|
|
|
334 |
messages and thereby reach a state in which (within some bound) all clocks are synchronised.
|
|
143
|
335 |
A slightly longer and more detailed paper about the algorithm is
|
|
|
336 |
<A HREF="http://hdl.handle.net/2060/20110020812">here</A>.
|
|
141
|
337 |
The point of this project is to implement this algorithm and simulate networks of clocks.
|
|
140
|
338 |
</p>
|
|
|
339 |
|
|
144
|
340 |
<p>
|
|
140
|
341 |
<B>Literature:</B>
|
|
141
|
342 |
There is a wide range of literature on clock syncronisation algorithms.
|
|
|
343 |
Some pointers are given in this
|
|
|
344 |
<A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A>,
|
|
|
345 |
which describes the algorithm to be implemented in this project. Pointers
|
|
|
346 |
are given also <A HREF="http://en.wikipedia.org/wiki/Clock_synchronization">here</A>.
|
|
140
|
347 |
</p>
|
|
|
348 |
|
|
143
|
349 |
<p>
|
|
|
350 |
<B>Skills:</B>
|
|
141
|
351 |
In order to implement a simulation of a network of clocks, you need to tackle
|
|
140
|
352 |
concurrency. You can do this for example in the programming language
|
|
141
|
353 |
<A HREF="http://www.scala-lang.org/">Scala</A> with the help of the
|
|
|
354 |
<A HREF="http://akka.io">Akka</a> library. This library enables you to send messages
|
|
|
355 |
between different <I>actors</I>. <A HREF="http://www.scala-lang.org/node/242">Here</A>
|
|
|
356 |
are some examples that explain how to implement exchanging messages between actors.
|
|
140
|
357 |
</p>
|
|
|
358 |
|
|
132
|
359 |
</ul>
|
|
|
360 |
</TD>
|
|
|
361 |
</TR>
|
|
|
362 |
</TABLE>
|
|
|
363 |
|
|
143
|
364 |
<P>
|
|
|
365 |
<!-- Created: Tue Mar 4 00:23:25 GMT 1997 -->
|
|
132
|
366 |
<!-- hhmts start -->
|
|
143
|
367 |
Last modified: Wed Sep 12 16:30:03 GMT 2012
|
|
132
|
368 |
<!-- hhmts end -->
|
|
|
369 |
<a href="http://validator.w3.org/check/referer">[Validate this page.]</a>
|
|
|
370 |
</BODY>
|
|
|
371 |
</HTML>
|