Portfolio

• Experimental programming platform (mostly C++)
• Internet applications
  • Self-service hosting system (Perl, C, PHP)
  • Generic internet shop (Perl)
  • Auctions (C)
  • Misc (Perl, C, PHP)
• Games
  • Hobbit, the Polish version (Common Lisp, C++)
  • Gun (C)
  • Grucha (C++)
  • Raiders (C++)
• Misc
  • Investigation of reactions of unconjugated dienes with dichlorocarbene (C++)
  • Logo interpreter (C++)

From July 2003 to August 2006 I worked for HS Partner Pro-Test S.A. at the Research and Development Division. I was responsible for the development of an experimental programming platform. The main aim of this project was to enable people with little or none programming knowledge to build quickly complete applications, working both under MS Windows and GNU/Linux. The system consists of:

• The widget toolkit. The widgets are painted with direct calls to Xlib/WinAPI. The code responsible for the look and behavior of widgets is separated into the dynamically loaded plugins, therefore one can alter the widgets' properties, or even add new widgets, without recompiling the entire platform. I have contributed various changes and improvements to almost all widgets, and created some from scratch (including the most sophisticated widget, DBGrid).
• The abstraction layer, which hides the details of communication with different databases. The DBMS-specific parts are also separated into the dynamically loaded libraries.
• The scripting language PROL, loosely based on Interbase's PL/SQL. I have made small adjustments to the language core, and implemented most of its standard library.
• The system that allows for the connection of various database-related operations to the users' actions on widgets, without writing any PROL code. This includes the presentation and editing of data, the filtration (both in memory filtration, and by constructing the WHERE-part of the SQL query), the navigation across the set of records, searching and sorting, and so on. This part was implemented entirely by me.
• The tool for the preparation of reports, including the graphical report designer.
• The RAD tool, with the complete text editor for writing the PROL code and the SQL queries. I have added some functionality to this editor (Cut/Copy/Paste, Find/Replace).

At the time of my leaving, the first application using this technology had already been created. It was called ProFIRR, and it was an incident management tool, with the elements of a CRM tool. Is is presently used internally at HSPPT.

• different kinds of accounts:
  • mail account,
  • www account - providing disk space on http server, with the possibility of serving static HTML pages, as well as the PHP and CGI scripts,
  • www account with additional MySQL database access;
• the possibility of creating instantly working accounts via the web interface;
• the possibility of reading mail with either pop3 or web interface for mail accounts;
• the possibility of using arbitrary address aliases and creating sub-accounts for mail accounts;
• a web shop included along with the creator module for www accounts, which allows users to customize their shops for arbitrary field and choose the most appropriate graphics variation;
• the possibility of registering domains and creating subdomains for www accounts, with arbitrary directory used as a document root;
• the possibility of creating an arbitrary number of databases and accessing them with a convenient web interface for accounts with MySQL access;
• an administration module;
• scalability: one can add new servers without changing the software.

The programs are written mostly in Perl and PHP (a small part in C). The system elements created by me from scratch are:

• WWW applications:
  • application which allows clients to create accounts and maintain them (this includes creating a web shop that best fits their needs),
  • a generic web shop
• a PAM module that consults with the database whether the user should be able to access ftp or pop3 services.
• For security reasons CGI scripts should never be run with superuser permissions. To avoid this, all actions that demand such permissions - like creating accounts or changing users' passwords - are performed by a daemon program, to which a CGI script connects through the TCP socket, tells what to do and gives appropriate parameters. The daemon program runs as root. Also, doing things that way allows the CGI script to run on a different machine than the host on which the accounts are created.
• A script which runs periodically (e.g. once every 24 hours) and checks whether all accounts are paid for, whether download limits are not exceeded, and performs certain cleaning actions in the database.
• Additional scripts used for maintaining the consistency between informations in the database and the actual system state.

• CMS
• the internal administration/billing module

• webmail program,
• web interface for users' databases - phpMyAdmin,
• a program which chroots users' CGI scripts to their home directiories and sets uid and gid for them.

The system has been deployed at http://etap.pl

I designed and implemented the application, which can be used as a web shop in any field without any changes in the code and with arbitrarily configurable graphics. Some of the product's features are:

• administration via a web interface;
• arbitrary depth of the category tree;
• ease in adding new products and moving a product between categories;
• different prices for wholesale customers;
• fully configurable delivery method and payment form;
• possibility of discounts for products and groups of products;
• order tracking;
• searching by: any from the configurable parameters (like producer, color, size), category, price, keyword;
• adding of products to the basket by the user at any moment; logging in (or - for new customers - registration) is needed only at the ordering stage;
• a constant view of a short description of basket state (number of products and total price);
• an order confirmation by e-mail;
• the statistics of best and worst selling products;
• an elegant separation of code and html, thanks to the Template Toolkit module.

I have held the position of leading programmer in a team that implemented the http://www.ebid.pl auctions system. It is a database application written in C (the choice of technology wasn't mine), which - counting with the unavailable from the outside world administration module - is approximately 20000 lines long. The task of parsing the GET and POST parameters, and of generating the HTML pages from the templates, is performed by a proprietary library written in C. I was also one of the developers that worked on that library.

I have implemented several web applications that were never deployed or ceased to be available for various economic reasons:

• internet dating system (C)
• the content management solution (Perl), with
  • the complex system of permissions
  • the file repository
  • the ability to generate static html pages
• logging in and registration module for a web portal (C)
• interface for filling data into a weather service (PHP)

I have never taken part in the process of development of a commercial game. However, I have experience in the design and implementation of games.

I implemented in Common Lisp a Polish-language remake of a classical ZX Spectrum interactive fiction, The Hobbit. The program makes full allowance for language constructs such as conjugation, declension and inverse sentences, i.e., one can write for example "do drewnianej srebrny włóż klucz skrzyni" or "oprócz ohydnego wszystkie trolle zabij".

You can find the details here (Attention! It's all in Polish!).

Gun is a networking first person shooter, written in C and using the svgalib library. The game consists of two programs - the server and the client. The server is responsible for game logic and is common for all players. Every player runs his/her own client program which displays the graphics and reads the keyboard input. The clients communicate with the server via the UDP protocol. The graphics is created with the ray casting algorithm. The game works in the 320x200 resolution and uses 256 colors.

download

Two dimensional arcade game. The player controls the movement of a green pear with the keyboard. The aim is to catch the non-orange monsters and avoid the orange monsters which can kill you. After catching 40 non-orange monsters the player is provided with a gun, and can shoot the orange monsters as well as the remaining non-orange monsters. The background is smoothly scrolling and some of the monsters have more than ten frames of animation. In principle Grucha can work in any resolution, but it looks best in 640x480 or in 800x600 pixels. The game is written in C++ and uses the svgalib library.

Two dimensional arcade game. The player uses the mouse to control a small rocket equipped with three guns (each of the guns fired by different mouse button). The aim is to shoot the UFO ships and not get caught. The game has many levels. The higher the level is, the more UFO ships appear simultaneously on the screen and they move quicker. At the end of each level one has to shoot a big orange mother ship. After completing the seventh level the player is rewarded with the machine gun, which means that he/she can fire more than one missile at a time. The game is written in C++ and uses the svgalib library.

Let us consider a reaction in which a hydrocarbon with two equivalent double bonds is attacked by the dichlorocarbene (CCl₂). It leads to mixture of diene, monoadduct and diadduct, e.g.:

From our understanding of reaction mechanisms, one can propose conjectures as to whether the carbene reacts quicker with the diene or with the monoadduct, and how it depends on the catalyst used. To test such conjectures, the amount of diene and the products of its reaction with dichlorocarbene are experimentally measured as a function of the amount of CCl₂ used, and the results are inserted into a mathematical model describing the reaction course. From this fitting we obtain the coefficient k, which indicates how many times the carbene reacts quicker with the monoadduct than with the diene.

I wrote the program which can be used to perform such operation, i.e. to numerically solve (using the forward Euler scheme) the set of differential equations describing the reaction course for different k values, and to ascertain which k best fits the experimental data (the least squares method), and plot a graph illustrating such fit.

(1 mol), CHCl3 (4.5 mol), 50% NaOH (8 mol), TEBA (2.5% mol)

By replacing TEBA with TMACl as catalyst, the second double bond was found to react approximately 7 times slower than the first.

(1 mol), CHCl3 (4.5 mol), 50% NaOH (8 mol), TMACl (2.5% mol)

For more details see:
Michał Fedoryński, Reactions of haloforms in a catalytic two phase system - effects of solvent and catalyst on the reaction course, Publishing House of the Warsaw University of Technology, Warsaw 1999.

Logo interpreter (C++)

I also implemented an interpreter of a simplified version of Logo programming language. It is simplified because there are no string or list types - however, numerical variables, loops, conditional instruction and user-defined subroutines with recursion are supported.

The program is written in C++. There is a svgalib version, as well as the X-Window System version and version which runs as an xscreensaver-hack.

Here is an example of a Logo code and its effect (you may note that all commands are in Polish):

OTO PASEK :D :N JEŚLI N=0 NAPRZÓD D JEŚLI N<>0 [ PASEK D/3 N-1 LW 60 PASEK D/3 N-1 PW 120 PASEK D/3 N-1 LW 60 PASEK D/3 N-1 ] JUŻ OTO PŁATEK :D :M POWTÓRZ 3 [ PASEK D M PW 120 ] JUŻ LW 90 PŁATEK 250 5 KONIEC;