Software Portfolio

WebChat

The Mannerheim League for Child Welfare and the Youth Department, City of Helsinki wanted to host online chats in IRC-Galleria. As the website did not have such functionality back then, I had to figure out how to implement it.

I made some upfront decisions about the architecture because I wanted a system that was easy to integrate into different environments. On the other hand, this was a great opportunity to familiarize myself with the very latest and hottest web technologies.

The architecture was largely as follows:

• The client side was pure static HTML, JavaScript, and CSS. I could have embedded that on my personal website with ease.
• The server side was based on the Java-based Jetty web server. The key classes were Context, Channel, and Member. Integration into other server-side systems happened through subclasses and event listeners.
• The client-server protocol was plain HTTP with JSON objects.
• The interesting part: the client polls for new messages. However, the server kept each request open until a new message arrived. This emerging technique was called Comet or LongPoll. Server-Sent Events (SSE) later provided a standardized alternative.
• The architecture enabled straightforward support for other technologies like WebSocket, XMPP, or even IRC.
• Concurrency control was quite sophisticated and ensured that communication with external, potentially laggy systems, such as databases, did not hang the server.

Features

• Multiple concurrent chat environments and rooms
• Thousands of concurrent users. It was battle-tested with a tad over a thousand users.
• Per-channel moderators
• Ban (kicking out) and gag (follow-only)
• Persistent message backlog
• A queue for one-on-one chats with an on-duty counselor

The chat was also used, in addition to regular public chats, for hosted chats with celebrities. There were musicians, politicians, MP candidates, and so on. The most entertaining applications were livestreamed band gigs where IRC-Galleria users could follow the gig from home and sometimes got a chance to chat with the artists.

IGTV

The IRC-Galleria office got a flat widescreen TV, which was huge: 40 inches! That was back then. Anyway, we got a TV, but appropriate content was lacking. To fill this gap, "IGTV" was born.

IGTV was a real-time photo streamer: when a user uploaded a new photo to IRC-Galleria, it immediately and smoothly appeared on the TV. The system comprised server- and client-side applications, both written in Java. The server sent photos to the client as an XML stream with Base64-encoded image data. The client then passed it on to an animation thread. The first versions used AWT, but I later migrated the display to OpenGL. There were several implementations—the 2D version shown in the screenshot and a fancier 3D version that imitated a film strip. A modern version of such a system would likely use SSE or WebSockets and WebGL.

IGTV once streamed May Day-themed photos on the big screen at the Kamppi shopping mall. There are some video clips on YouTube as well.

IRC-Galleria Election Compass

The 2007 Finnish parliamentary election + Finland's most popular social media website and a user base traditional media could only dream of. IRC-Galleria obviously had to have an election compass of its own.

Candidates gave positive feedback about the ease of use, and users liked the comparison features. It was easy to compare the answers of different parties and user groups. One could also browse candidates from other electoral districts. For some reason, nobody else had that feature. The election compass was later reused for municipal and European Parliament elections.

The implementation was originally supposed to be outsourced, but that plan went belly-up. In the end, I was responsible for pretty much everything related to the design and implementation of the software.

The code was PHP; the calculations happened in the database using SQL queries.

The election compass got quite a bit of media attention and even received an honorary mention in the Grand One 08 competition, in the Best Consumer Service category. \o/

Type-ahead search suggestion (Proof of Concept)

Type a few letters, and you immediately see a dropdown list of choices. That's really basic nowadays, but back then, such a feature was needed in IRC-Galleria as well, so that photos and blogs would be easy to associate with relevant communities.

I prototyped a search server based on an Inverted Index, which scored matches using search terms and community sizes. I also explored the Ternary Search Tree data structure to index the words, but it proved infeasible because of the high number of words and the memory wasted by 64-bit pointers. I eventually ended up using the regular Java TreeMap, which enabled efficient iteration by prefix.

The final algorithm necessitated some iteration and tuning, as short prefixes resulted in enormous subtrees; think about the search terms "un" and "sc". In addition to Uncle Scrooge, every search target with words starting with those prefixes had to be scored. Caching of short prefixes and the merge algorithm for intersections proved efficient.

My part in the project was limited to the proof of concept described above. Colleagues developed it into a functional product, comprising both the server and client-side JavaScript. The server was based on Jetty.

Intarray PHP extension

PHP's array data structure was bloated (this isn't necessarily the case anymore; I'm not sure). At the same time, it was a linked list and a hash table. Handling large quantities of scalar numbers with it would have been, frankly speaking, a ridiculous idea. It was not only slow, but it used enormous amounts of memory.

In IRC-Galleria, several features necessitated operations with 32-bit integer arrays. Some examples:

• Is the user ID online? (binary search of an array of online users)
• Find the friends another user and I have in common (intersection of two intarrays)
• Store members of a group into a cache in an efficient manner
• And so on

The problem was that serializing such integer arrays was abysmally slow in PHP and consumed excessive memory in both PHP and Memcached. I then came up with an idea: what if these integer arrays were just regular PHP strings encoding an int32 array? No serialization required, and memory consumption would be as efficient as possible (without compression). I thus wrote a PHP extension in the C programming language, which enabled various efficient operations on these arrays, like binary search, intersection, union, difference, etc. The Intarray extension is available on GitHub.

IRC bot and client

For some reason, everyone had to write their own IRC client. I wrote one too, and built a bot and a chat GUI on top of it. I practiced writing abstract and modular code in Java.

Later on, the bot was used for many purposes in IRC-Galleria. For example, it was used to verify someone as an IRC user (I mean, a user of IRC-Galleria who is also an IRC user—they are not the same thing), or to grant admin rights for an IRC channel listed in IRC-Galleria. In the latter case, the bot temporarily joined an IRC channel and figured out who really was an operator on that channel.

The bot had, of course, various basic features like XML configuration, a user database, remote management through a web browser or IRC protocol, various basic IRC bot functions like giving automatic operator privileges upon joining, dynamic ban control, egg timer, etc.

I was planning to release it as open-source software, but I didn't have enough time and energy to write proper documentation. Releasing poorly documented software wasn't compatible with my quality standards.

Midlet Donut

I studied information technology at a university of applied sciences for a while (but I dropped out, as I focused on IRC-Galleria, which was becoming profitable). Anyway, as a school exercise, I implemented some eye-candy on a mobile phone using Java. I had ported my 32-bit graphics routines to Java some time ago and implemented applets exhibiting some fancy 3D graphics. Porting the routines to a midlet, which is kinda a Java applet running on a phone, required converting all the arithmetic to fixed-point—cell phones did not handle floating-point numbers. The result was cute, and a Nokia 6600 ran it at an impressive rate of six frames per second.

The original Java applet is available on a separate page.

WWW Content Management System (CMS)

You might know Drupal and WordPress. They are content management systems. I also built one for myself, and because it ended up being pretty good, it was eventually used by some customers of Business DataBases Oy.

Briefly:

• Pages formed a hierarchical site map.
• Each page could have group-specific access rights, which were inherited by its child pages.
• Page templates were created with JavaServer Pages (JSP). Navigation was implemented using a tag library. A multilevel hierarchical site map, or any part of it, could also be rendered easily using the tag library.
• A page template could contain multiple dynamically editable areas.
• A version history was kept for changes.
• Pages could contain "plugins" that provided functionality similar to portlets.
• The software was written in Java (as you may have guessed by now), with PostgreSQL as the database.
• I was also developing a VFS (Virtual File System) that would have abstracted the handling of pages and files. That part, however, never quite got finished.

ProSales webstore

I got to know Java EE originally when implementing a webstore. The interesting part was that one could sign up for various courses through it. The tech stack in brief: Tomcat, Struts 1.0, JSP, PostgreSQL, a home-grown ORM implementation.

Discussion forum

It was sometime around the year 2001. When working at eQ Online, the pioneering Finnish online stock broker, I developed a discussion forum for eQ's customers. Requirements: fast, reliable, great usability. There was a similar competing discussion forum, provided by Arvopaperi (Securities) magazine, but it was incredibly slow. My forum, on the other hand, proved to be very fast. It was built using PHP and MySQL, and with an efficient caching technique, it easily delivered 100 pages per second on a 500 MHz dual Pentium III.

The first versions of IRC-Galleria

IRC-Galleria was a journey, and it has always had its own entry on this list. Although it eventually became the most successful social media website in Finland, it was initially just a small hobby project of some of my friends. It was immediately popular. And slow.

I joined that hobby project, refactored its architecture to use a database—MySQL back then—and revised its web design. Most of the original code was written by Maza. Later on, we founded a company, Dynamoid Oy, to run IRC-Galleria, and I had various technical lead roles in it.

Table Component for AWT/Swing

eQ Online's streaming application needed a table component that could be updated very efficiently. Java Swing's JTable, with all its MVC sophistication, was a bit too heavyweight, so I experimented with a more straightforward approach.

The first versions were pure AWT, but later I brought Swing's JScrollPane into the mix. The original AWT version was extremely efficient even with almost arbitrarily large tables, but the code was so low-level that there were quite a few compatibility issues between different Java and browser versions. The screenshot shows one of the first AWT versions.

SupaGL

I wrote a small graphics library with 32-bit, alpha-blended, anti-aliased graphics. The code was written in plain ANSI C, very portable, and worked on many operating systems. I used it to create stock charts, which were much prettier than those on competitors' websites. Nowadays such graphics are standard, but in the year 2000, they were an exception.

Unnamed, unfinished game project

This wasn't exactly an original concept, honestly. There were plenty of similar flying-and-fighting-in-a-cave games in Finland: AUTS, KOPS, Wings, Rocket Chase, etc. On the other hand, my main motivation was to learn the SDL graphics library and some C++. The project never finished, but I still implemented nice alpha-blended, parallax-scrolling graphics. All flying objects were instances of C++ classes.

Minesweeper clone for TI-85 calculator

TI-85 has an 8-bit Z80 CPU. Somebody had implemented a C compiler for it—not just for the CPU, but for the calculator. It did no optimizations, but it nevertheless compiled a C subset into Z80 assembly. Two-dimensional arrays were unsupported, and so was dynamic memory allocation. I don't remember the details, but somehow I ended up writing a Minesweeper clone for the calculator using the C compiler. The game has a page on ticalc.org.

I later rewrote the game in pure assembler, adding a scrollable screen. The rewrite shrank its size from roughly 6 kB to 4 kB. But alas, I have lost its source and binary :-/

Graphical group calendar

In the summer of '96, I worked for my big brother's company. I used Microsoft Visual Basic to write a group calendar that displayed events from multiple people or resources concurrently in the same view. The horizontal axis was configurable for the time within a single day or as a linear time axis, freeing the vertical axis for concurrent people or resources. The calendar became an integral part of a CRM application and was used extensively by its users.

Nation on Fire BBS advertisement

Before the World Wide Web, bulletin board systems (BBS) were the online forums where people chatted and shared files. To access them, you had to use a landline and modem. Between the years 1994 and 1996, I had my own BBS. It had two nodes, i.e., two phone numbers that people could connect to, and those nodes were connected through Ethernet; very rare back then.

It was common for a small interactive advertisement application to be added when a file, like a zip or rar archive, was uploaded to a BBS. Those had to be small, to not bloat the files, and impressive, to make people call your BBS.

I wrote a small animated, text-mode advertisement using i386 assembly. The size of the binary, which included both the compiled code and graphics, was just 1003 bytes. Source and binary are available: nofsrc.zip.