Molpher

Finished: October 2012
Language: 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 2012
Language: 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 2012
Language: 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 2011
Language: 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 2011
Language: 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 2010
Language: 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 2010
Language: 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 2010
Language: 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 2009
Language: 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 2009
Language: 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 2008
Language: 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 2008
Language: 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 2008
Language: 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 2008
Language: 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 2008
Language: 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 2007
Language: 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 2007
Language: 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 2007
Language: 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]