Molpher
Finished: October 2012Language: C++
IDE: NetBeans
License: GNU GPL
Keywords: chemical space, molecules, drug discovery, parallelization, dimension reduction, visualization
Molpher is a scalable and interactive software tool to aid exploration of
chemical space,
the vast universe containing all possible
compounds.
Many areas of chemical biology, such as
drug discovery,
rely heavily on chemical libraries offering compounds usable in the
industrial processes. Given a set of molecules with desired characteristics,
Molpher explores their common neighborhood based on structural similarity,
as it represents promising part of the chemical space to find new additions
into those libraries. In order to decrease the chance of missing interesting
parts of the space, Molpher offers the human researcher to observe and
interactively alter the exploration process. Generated subspace is expected
to be further tested for synthesizability and biological activity by other
software tools. Among main features, Molpher offers optimized parallel
exploration algorithm,
compound logging, dimension-reduced visualization of chemical space and
interactive widget-based GUI. Codebase is extensible in terms of additional
morphing operators, chemical fingerprints, similarity measures and
visualization strategies to allow further experiments. The important property
of Molpher is that it is split into two components - server responsible for
complex background calculations and client responsible for visualization and
interactive GUI. Both components can run on different machines and communicate
over the network. As of writing this, server can use only single multi-core
processor, but it was designed to be extensible for the whole cluster of
multi-core processor machines in the future. Molpher was created by a
team of 5 student developers
during a period of
9 months
to get credit for
Software Project.
My responsibility in the team was project management, overall project architecture and
implementation of parallel exploration algorithm and dimension reduction algorithm
in the server component.
[homepage]
[documentation]
[sources]
[download]
Scalability Improvement of Gerbil
Finished: October 2012Language: C++
IDE: Microsoft Visual Studio
License: GNU GPL
Keywords: scalability, optimization, parallelization, background calculations, gerbil
As a student accepted into the
ESA Summer of Code in Space 2012
program, I was given a chance to participate in the development of multispectral image viewer
Gerbil developed at
University of Erlangen.
Analysis of multispectral images
has variety of applications,
for example remote sensing,
astronomy or analysis of cultural heritage. Before my involvement in the
project, Gerbil already provided wide range of advanced features and novel
methods for multispectral image analysis. However, it did not scale well
towards bigger input images because of single-threaded execution and
unnecessary wasting of memory. Since multispectral images are often so large,
that it is on the limit of what is provided by nowadays personal computers (as of 2012),
both regarding computational power and available memory, there was a strong
demand to avoid unnecessary redundancies and to exploit parallelism opportunities.
My task was to improve scalability, optimize memory consumption, parallelize
code and improve GUI responsiveness. To achieve this, I partially redesigned
Gerbil internals, put most of the calculations to background thread, prepared
GUI for asynchronous updates, improved calculations to reuse already calculated
data and to exploit most of the inherent parallelism. The parallelization
was done mainly by using
TBB library,
but I also used
SSE2 instructions
and CUDA toolkit. All the
optimizations together led to the significantly faster calculations, more
usable GUI and ability to open images with higher resolution or with higher
number of bands.
[homepage]
[documentation]
[sources]
Graphics Stack for HelenOS
Finished: August 2012Language: C
IDE: NetBeans
License: BSD 3-Clause
Keywords: graphics stack, gui, compositor, drawing library, widget toolkit, helenos
For my diploma thesis, I designed and implemented basics of graphics stack
and graphical user interface for micro-kernel operating system
HelenOS. Before that,
HelenOS was equipped only with console-based interface. The implemented
stack is complete on all levels in its breadth, but implementation depth is
obviously limited due to the fact that it was created by just one person.
You can watch the stack presentation in the
screencast
showing all the implemented features. On the lowest level, there is an
elementary framework for graphics drivers including the support for multiple
monitors. The most important part of the stack is compositor server.
Application windows are rendered to off-screen surfaces that are
subsequently transformed and blended onto the screen framebuffer. Among the
supported transformations is translation, zooming, rotation and
transparency. Required
matrix transformations,
alpha-compositing,
filtering,
masking,
font rendering, drawing context and drawing functions are all provided by
another part of the stack - drawing library. Then, on top of the stack,
there is widget toolkit providing resizable windows,
window decorations,
event loop,
scene tree,
signal-slot mechanism
and object hierarchy of widgets.
You can inspect the original source code of the stack in the
development branch.
The stack was also merged into HelenOS
mainline
where it will be further developed and optimized by HelenOS developer community.
[homepage]
[screencast]
[documentation]
[branch]
[mainline]
Port of GNU binutils to HelenOS
Finished: September 2011Language: C
IDE: NetBeans
License: BSD 3-Clause
Keywords: port, assembler, linker, posix, gnu binutils, toolchain, helenos
As a student accepted into the
Google Summer of Code 2011
program, I was given a chance to participate in the development of micro-kernel operating system
HelenOS. My task was to port
GNU assembler and
GNU linker to the
HelenOS. To complete this task, it was also necessary to enhance HelenOS
native C library and to create
POSIX compatibility library.
Fellow GSoCer was simultaneously working on the port of
Portable C Compiler,
so in the end we had a basic toolchain to build binaries from sources inside
HelenOS. The early demonstration of the toolchain can be viewed in this
screencast.
The ported toolchain will also serve as a base for long-term strategic goal
of HelenOS to become self hosting.
As for my experience from the development, it was very interesting to be
part of the established team that heavily depends on the
decentralized revision control
and various forms of communication (wiki, mailing list, IRC chat, monthly meetings).
Since HelenOS is ported to almost all existing architectures, I have also
became familiar with a number of emulators - especially
QEMU and
GXemul.
If you want to investigate the binutils port further, I suggest you to
begin by reading
documentation
and README file in the
package.
[homepage]
[screencast]
[documentation]
[branches]
[mainline]
[package]
alpOS
Finished: February 2011Language: C++
IDE: Microsoft Visual Studio
License: -
Keywords: mips32, operating system, kernel, threads, synchronization, memory management, system calls
Educational
operating system
for
MIPS R4000 processor.
System was created during university studies to get credit for
Operating systems.
It was developed by a 3-member team during a period of 4 months.
More specifically, the task was to create a
kernel
and a basic
runtime library
for user-mode applications. Because of the extent of the task, each team
could choose whether to focus on multi-processing, memory management or
user-mode processes. Chosen part of the system was expected to be almost
full-featured, while the rest of the system could be simplified. Our team chose memory
management. In the beginning, we were given processor manual, definition
of runtime library
API,
set of tests, GNU toolchain
and virtual machine
emulating the processor, memory and basic devices. The development itself
was a very interesting experience as it was not possible to rely on the stuff
normally available to the application programmer - e.g. standard library,
integrated development environment and debugger. Investigation of a bug
usually meant to read the source code and trace it manually by textual
outputs. In the end, the produced operating system contains
preemptive multitasking,
mutual exclusion,
virtual address spaces,
page tables,
heaps,
memory protection,
system calls,
support for a single user-mode process
with unlimited amount of threads,
handling of a keyboard input and finally output to the serial console.
Note that it is not possible to publish sources - for one thing I don't have an
approval to do so by my team colleagues, but mainly it would be unfair
to the future students of the course. You can find more information on the
website devoted to the course (Czech only).
[more information]
mlc
Finished: April 2010Language: C++
IDE: Microsoft Visual Studio
License: -
Keywords: Pascal, compiler, code generation, stack machine, register machine
Compiler
of the Mlaskal programming language (educational subset of the
Pascal).
Compiler was created during university studies to get credit for
Compiler Principles and
Compiler Design.
In these courses, student is given a source code skeleton containing basic
data structures and routines for I/O handling and manipulation of identifier
table. Furthermore, test sources,
assembler
definition and
virtual machine
are available during the development of the compiler. Task is to successively
create lexical analyzer, syntactic analyzer, semantic analyzer and code
generator. Lexical analyzer is generated with the help of
flex so it is sufficient to just
describe the lexical elements in terms of
finite-state machine.
Similarly, syntactic analyzer is described as a
context-free grammar
and then generated by
bison.
Semantic analyzer and code generator are programmed directly without any
tools. Code generation is split into two phases. Firstly, the code is
generated for an abstract machine with an infinite
stack.
Then, the generated assembly code is further analyzed and transformed for a
machine with a finite number of
registers.
Such code transformation is further divided into a number of sub-phases -
splitting the code into blocks, allocation of registers to the variables,
generation of spill code (to swap variables for which there is no register
left) and finally assembling the code blocks into the resulting binary file.
Usually, code generator also contains several optimization sub-phases - this
is however not the case for this educational compiler as it would raise the
complexity of the task by an another order of magnitude. In order to
maintain fair play among the students, it is not possible to publish
sources of the compiler. More information can be found on the websites of
the mentioned university courses (Czech only).
[more information]
[more information]
GraphRec
Finished: March 2010Language: C++
IDE: Qt Creator
License: GNU GPL
Keywords: visualization, graph embedding, movement on graph, video capturing
GraphRec is a visualization tool oriented on the animation of moving
entities on the generic middle sized graph (several hundred nodes).
Typical input for GraphRec is created by some independent software that
generates solutions for centralized path planning problems. The main
motivation for creating GraphRec was to provide a way to find bugs and
optimization opportunities in these solutions. Since animation can be
captured to image or video files, GraphRec can be used as a presentation
tool as well.
More info is provided in the
subsection devoted to this project.
[homepage]
[package]
Chopok
Finished: January 2010Language: R
IDE: R
License: GNU GPL
Keywords: simulation, ski lift, statistics
Statistic simulation of two-stage ski lift. Passenger arrivals for both
stages are characterized by
Poisson distribution.
Furthemore, situation is complicated by an optional transfer from the first
stage to the second stage. Apart from simulation itself, program also
provides answers for questions risen in the specification (written in
Slovak language) - e.g. lift utilization, queue length. Program was created
during university studies to get credit for
Probability and Statistics.
Program was developed and tested in
R
statistical environment. If you are a student, who is looking for an
inspiration here before doing some similar homework, please note that some
tasks from the specification are probably not solved entirely or correctly
(i.e. although it was rated very well, maximum number of points wasn't
reached).
[specification]
[documentation]
[package]
CorWX
Finished: May 2009Language: C#
IDE: Microsoft Visual Studio
License: GNU GPL
Keywords: emulation, parsing, assembler
Program CorWX is a modified version of the CorW
simulator ported to the
WPF
graphical subsystem. Therefore, GUI related parts of the source code were
rewritten to the
XAML
markup language. Program was created during university studies to get credit
for
C# Language and .NET Framework
and
Advanced .NET Programming.
To launch the program, make sure you have installed at least
MS .NET Framework 3.5 SP1.
Unlike in case of CorW, program package contains also commented sources.
Documentation is available only in Czech.
If you find yourself reading a Redcode parser, note that when I wrote the
program I had no previous knowledge of automata and grammars, so it
could be definitely written better. Also the GUI shall not be taken
as an inspiration, as it has many flaws. While the main window is finally
resizable (in comparison with CorW), memory array rendering is even slower.
Therefore, I made it possible to disable the rendering completely and let the
emulation proceed by several orders of magnitude faster.
[specification]
[user documentation]
[programmer documentation]
[package]
LZWCD
Finished: May 2009Language: Prolog
IDE: SWI-Prolog
License: GNU GPL
Keywords: compression, Lempel–Ziv–Welch
Experimental implementation of
LZW
compression algorithm in the logic programming language
Prolog.
Program contains two main predicates - one for compression and the other
for decompression. As a parameter, the predicates take name of the input or
output file. Because programs written in Prolog have inherently exponential
complexity, the size of input data shall be less than approximately 500kB
to get reasonable run times. Therefore, the program shall be regarded as an
experimental demonstration of compression written in logic programming
language, not as a practically usable tool. Program was created during
university studies to get credit for
Non-procedural Programming.
Although program was developed and tested in
SWI-Prolog
interpreter, it should be possible to try it in other interpreters as well.
Program package contains commented sources and test data.
[package]
cllaus
Finished: December 2008Language: C++
IDE: Microsoft Visual Studio
License: GNU GPL
Keywords: simulation, cellular automata
Program is a simulator of
cellular automata.
World in which the simulation occurs consists of the finite two-dimensional
plane divided into rectangular cells. Each cell can be either dead or alive.
Time is divided into discrete time steps, called generations, between which
the transitional function is simultaneously applied to the neighborhood of
each cell, rendering the particular cell either dead or alive in the next
generation. More specifically, program implements well-known transitional
function called
Conway’s Game of Life,
which was first mentioned in the
article
written by
Martin Gardner
in October 1970 issue of
Scientific American.
Program was created during university studies to get credit for
Programming in C++.
GUI and synchronization is programmed with help of
Qt4 framework.
Note that the GUI is very minimalistic and was created just for the sake of
testing. It is thus not very scalable - especially zooming out can cause
program to crash, as there is no decrease in level of detail applied.
It would be very interesting to port the grid rendering to some modern
graphical component in Qt framework which allows unlimited zooming.
Then, it would be possible to see very large automaton like
Caterpillar
completely zoomed out. Program package contains commented sources and test
data.
[user documentation]
[programmer documentation]
[package]
Gate Network Simulator
Finished: December 2008Language: C#
IDE: Microsoft Visual Studio
License: CPOL
Keywords: logic gates, simulation
Simulation of interconnected user-defined
logical gates.
Format of the gate network definition is precisely described
in the included specification (in Czech). Declarations of elementary logic gates
can be grouped into more complex compositions. When executed,
program builds the network defined in the input file and waits until
the user provides logical values for network inputs. When those inputs are set,
program performs the simulation. After the network internal state is
stabilized, final logical values are fetched from the network outputs and
displayed to the user together with the number of time steps required for
the stabilization. Program was created during university studies to get
credit for
C# Language and .NET Framework.
To launch the program, make sure you have installed at least
MS .NET Framework 3.5.
Program package contains commented sources and test data.
[specification]
[package]
CorW
Finished: August 2008Language: C#
IDE: Microsoft Visual Studio
License: Freeware
Keywords: emulation, parsing, assembler
Technically, program is an emulator of an abstract machine (processor and
memory array) and an interpreter of a special assembly language called
Redcode. It is one of the
so called MARS (Memory Array Redcode Simulator) that were inspired by the
article
written by
A. K. Dewdney
in May 1984 issue of
Scientific American.
MARS serves as a host for fights, called
Core Wars,
between programs, called warriors, written in Redcode. When
warriors are loaded into a shared memory space, emulator starts to execute
one instruction of each warrior per cycle. Note that initially each warrior
is characterized by exactly one instruction pointer. Warriors employ
different strategies to be successful - e.g. forking itself into more
threads, hijacking opponent threads or bombarding the memory with
non-executable instructions. Program implements the standardized version
of Redcode, more specifically latest draft revision
ICWS '94 3.3.
Program was created during university studies to get credit for
Programming II.
To launch the program, make sure you have installed at least
MS .NET Framework 3.5.
Program package contains test warriors and the standard mentioned above.
Sources are not included. Documentation is available only in Czech.
Note that the GUI of the program is not designed very well - window size is
fixed and rendering of the memory array is too slow (especially for bigger
arrays).
[documentation]
[package]
Výtahy
Finished: April 2008Language: C#
IDE: Microsoft Visual Studio
License: CPOL
Keywords: simulation, elevators
Discrete simulation
of elevators inside a building. Elevator groups, agents and their travel
requests can be either generated or manually typed into the input window.
Elevator scheduling within a group is planned heuristically by a dispatcher
entity. Output of the program consists of simulation runtime and average
waiting time for each unique set of input parameters. Output data are
prepared in
CSV
format so it could be further used (e.g. to draw a plot). Program was
created during university studies to get credit for
Programming II.
Becuse the architecture was firstly prototyped as
UML
diagrams, the resulting program is a demonstration of a very clean
object-oriented design. The GUI, on the other hand, was assembled together
very quickly and is thus very slow and clumsy. To launch the program, make
sure you have installed at least
MS .NET Framework 3.5.
Program package contains commented sources. UML diagrams are also available
for download. Please note, however, that all material related to the program
is written only in Czech language.
[uml]
[package]
Komprese
Finished: February 2008Language: Pascal
IDE: DEV-Pascal
License: CPOL
Keywords: compression, Huffman Encoding, RLE
Data compression based on
Huffman Encoding
and
Run-Length Encoding.
Implemented algorithms provide reasonable compression of text and bitmaps.
Make note, however, that the implementation is limited by splitting data
strictly into bytes - that means compression will not be effective on
multi-byte characters and other than 8-bit bitmaps. Program was created
during university studies to get credit for
Programming I.
Program package contains commented sources and test data. Note that sources,
comments, specification and documentation are all written in Czech language.
[specification]
[documentation]
[package]
Sorter
Finished: May 2007Language: Pascal
IDE: DEV-Pascal
License: CPOL
Keywords: sorting, benchmark
Graphical demonstration of
sorting algorithms
based on element comparison. Program generates random sequence of numbers
and sorts it by a selected algorithm. There is also a benchmark to compare
time complexity
of the algorithms. Program was made as a preparation for secondary school
final exam. If you are a novice-programmer and are able to read the commented
source (in Czech), it can be very well used for educational purposes.
[package]
Solver
Finished: May 2007Language: Pascal
IDE: DEV-Pascal
License: CPOL
Keywords: calculator, equation solving, numerical methods
Calculator that offers evaluation of arithmetic expressions and solution to
equation with one unknown variable. It is possible to use elementary
functions, to store temporary results, to set up precision and to limit
interval when searching for equation solution. To find equation roots, there
are a few
numerical methods
of a different complexity implemented. To make the program more user-friendly,
usage help is accessible from the main menu. Please note that the program
was made as a preparation for secondary school final exam and as such it is not
finished nor intended to be actually used. If you read through commented
sources (in Czech), you will find very naive attempt to implement some of
the elementary functions on my own. This causes some calculations either to
lose precision or to be completely wrong. When writing the program, I wasn't
fully aware of what it takes to create a precise and optimized implementation
of such functions. Also note that sources are somewhat over-commented.
[package]
ENIGMA Crypter
Finished: March 2007Language: Object Pascal
IDE: Borland Delphi
License: GNU GPL
Keywords: cryptography, cipher, enigma
Program is a text crypter and decrypter which is using
Enigma
cipher from the second world war. More specifically, it implements basic
version of Enigma which was used by units of
Wehrmacht and
Luftwaffe at
the beginning of war. Program is using the same inner mechanism so it is
compatible with the original Enigma (i.e. it is possible to decrypt German
messages from the beginning of war if you know the key). Compatibility is
not guaranteed for later versions of Enigma as those had more scramblers
and different inner connections. Program was created at secondary school
as a part of contest project
Dějiny kryptologie that explored
the topic of cryptology history. Program package contains commented sources.
Please note that most of the material related to the project is available
in Czech language only. If you visit program homepage, you can also download
English version of the executable. If you find yourself reading the sources
of the program, please keep in mind that this was practically the first
serious program I wrote and that during that time I had no formal
programming education (as you can see from the repeated code patterns, I did
not even fully understand the procedural paradigm). Program also does not
scale very well for longer input text because the text is stored and
manipulated directly in GUI text boxes.
[homepage]
[package]