Branching out, get the architect!

Starting next month my company, Quartex Components, is finally branching out!

I will be available for personal tutoring, group based training sessions and helping your company get to grips with cloud development using Smart Mobile Studio. Why limit your product to just native when you can tap into the biggest market in the world? A market where node.js is the name of the game. And with Smart Pascal you get to enjoy working in a language you already know.

Quartex Components are branching out, now you can get training by the inventor of Smart Smart Mobile Studio and author of the RTL

Let me show you how to re-apply your hard-earned Delphi skills – and tap into the biggest economy in the world: cloud and the web. Learn to write clustered, scalable servers that runs everywhere. Learn to work with your existing Delphi infrastructure while taking full advantage of all the new and exciting possibilities at your disposal.

With Smart Pascal you are no longer bound to a particular platform or chipset. Services you write and build on Windows runs without any change on Linux and Unix. With Smart Mobile Studio you can finally establish a large stack of services to power your infrastructure in record time.

Not happy with your provider? With Smart compiled code moving to a better provider is no longer the monumental task it used to be. Copy the files over, install node.js and re-start the system. If the server is x86, ARM, PPC or MIPS is of no consequence.

Node.js is here to stay, and so is Smart Mobile Studio. The first and best RAD development platform for the cloud.

Hire the A team

At Quartex Components we write custom controls for breakfast, programming languages for lunch and service stacks for dinner. We are full stack developers in the true sense of the word: from low-level drivers to system services, all the way to custom filesystems, database engines or large, secure online desktop frameworks.

Smart Mobile Studio, here running the Smart Workbench project

Perhaps all you need is an App for your company? One that runs on all known mobile devices from the same codebase? Low maintenance, push notifications, dynamic content; You came to the right place! No matter if you want iOS, Android or FireTV – we can cover them all.

Perhaps you need a custom kiosk system? One that should work with touch displays running on a low-cost SBC (single board computer). No matter if you need one or 100, stand-alone or networked – these are projects we have experience with.

What can I do for you?

  • Individual tutoring in Smart Pascal
  • Group based training sessions in Smart Pascal
  • Convert existing desktop applications into web applications
  • Deliver system services, both native Delphi and Smart based node.js
  • Write compilers and advanced parsers
  • Create kiosk systems and help you find the right hardware
  • Write custom controls for both Delphi and Smart
  • Deliver mobile applications for all known device
  • Build large-scale cloud applications and infrastructures
  • Data conversion
  • Write database engines from scratch
  • Deliver drivers for both Delphi and Smart Pascal

What were my previous 3 projects?

As the original author of Smart Mobile Studio I have been heavily involved in its evolution. My latest project was a 12 month sprint where the goal was to bring the Smart Mobile Studio RTL up to speed. This meant almost a clean re-write of the entire run-time library:

  • All visual controls have been re-written from scratch
  • Introduction of storage device drivers to unify storage between browser, node.js and phonegap
  • Implemented a virtual filesystem from scratch (the browser has no such concept)
  • Implemented Tweening, a time accurate animation framework
  • Implemented hardware accelerated CSS animation
  • Implemented accurate font measurement mechanics (which does not exist under HTML / JS by default)
  • Implemented TClientDataset from scratch under Smart
  • Low level memory allocation and read / write API
  • Low level buffer and stream API
  • Implemented the entire node.js high level class framework
    • Server architecture
    • HTTP and HTTPS servers
    • UDP Client and Server
    • WebSocket (WS) and WebSocket-Secure (WSS)
  • Introduced binary, chainable codec classes
    • Base64 for binary (browser only support text)
    • RC4 encryption with cyclic key modification
    • Mime / URL codecs
  • Implemented TStream and descendants from scratch
  • Re-wrote and fixed all demos
  • And much, much more ..

Prior to this project, which represents a huge body of work, I implemented a full desktop environment suitable for large-scale applications, routers and NAS web front-ends.

The Smart Desktop provides a number of features making it perfect for large applications

This project has itself been re-written in response to the refactoring of the Smart RTL, but serves as the foundation for large web applications. It provides the following services:

  • Secure and reliable websocket message server
  • User account based server access
  • Filesystem over websocket, access to personal files and shared folders
  • Storage Device Driver API, capable of consuming popular online services such as Dropbox, Azure, Amazon and other storage providers.
  • Support for ZIP archives, these files can be mounted as drives
  • Full Windowing Manager and Window framework
  • Capable of executing cross domain Apps inside a window
  • Modern menu system, iPad / Tablet aware for easy touch navigation

To showcase the technology I build in some novelty features

  • Support for MC68000 line of processors, meaning the desktop has a module that executes and runs Amiga compatible games and applications
  • DosInABox support, older x86 software can likewise execute in a window
  • Asm.js compiled version if the game Quake 3, running full speed at 60 frames per second

While initially meant as a showcase, the desktop client / server technology has become a product in its own right. As of writing 3 companies has licensed the system and use it as the foundation for business applications. With its close to Delphi like access to files, be they local in the browser cache or remote on a server, it is perfect for serious applications such as accounting, medical software and online instrumentation.

My third project was the design and implementation of a bytecode assembler. This is a fundamental building-block for programming language development. The LDEF standard and parsers represents a rock solid foundation on which to build new and exciting languages.

The assembler was first implemented in Smart Pascal, and is thus portable as a node.js application. A second version was implemented in Delphi.

This assembler is presently being added to HexLicense, our license management component suite for Delphi. Allowing our customers to write sensitive and mission critical code segments – that is then compiled to a bytecode block using instructions known only to the publisher.

This technique helps protect their products since debugging and hacking a standard unknown (and by nature easily randomized and obfuscated) is virtually impossible.

Hire a Delphi and Smart Pascal Ninja

I am well-known in the Delphi community, I help, teach and run several groups dedicated to object pascal on social media such as Facebook. I think people have seen what I am capable of when it comes to Smart Mobile Studio and Delphi.

Well, I can now offer my services for those who need to get up to speed on Smart Pascal, needs a fresh Smart project – or a cool Smart App ready for the store!

Get in touch!

Our Christmas discount

discountThis Christmas you can get our FMX, VCL and VJL package with a whopping $40 discount! That is a significant saving for a great product!

The license gives you full access to both our classical and next-generation engines:

  • 12 month subscription
  • Full source code
    • VCL version
    • FMX version
      • Windows
      • OS X
      • iOS
      • Android
    • Smart Pascal version
      • All mobile platforms
      • HTML5 applications
      • node.js client and server
  • Solid documentation
  • Easy to use and drop into existing projects
  • Ships with examples
  • Support via E-mail


The next generation HexLicense formula and license generator is Ironwood. This has been in the making for some time and is through the beta phase. We have used the absolute latest RTL for Smart – which will be in circulation within a few weeks. So you are getting the absolute latest to play with – which is can be used by both visual and node.js projects.

By acting now you not only save money but you also get a great deal on our classical Delphi components. Most importantly however, is that the discount buys you access to our next generation components. The next generation components which will retail at a higher price.

Embarcadero Delphi

With Ironwood for Delphi you have a tried and tested license management system at your disposal. But now you get two! You get the classical THexLicense package – now extended with a wide set of new and powerful components and classes.

Again, this package will retail at a higher price and forms the basis of our future cloud based licensing services.

By acting now you secure early access!

Smart Pascal

With mobile application development taking place more and more through HTML5 and phonegap – not to mention that node.js is quickly becoming a market standard server-side, compilers that targets the JavaScript virtual machine is becoming increasingly important.

Especially for traditional languages like Delphi and C++.

With access to Ironwood for Smart Pascal, your existing VCL and FMX products can continue to function as they do right now – while you move your licensing mechanisms to the cost-effective, scalable and portable node.js cloud servers.

Why pay huge amounts of money to rent a full virtual instance to host a native Delphi service – when you can do the exact same under node.js and Smart for but a fraction of the price? Not to mention the many benefits node brings to the table.

Buy Now Button with Credit Cards

Note: This is a time limited offer. Only the link above this text is valid for this discount.

Presenting HexLog

Tønsberg, Vestfold, Norway 14.10.2016

Quartex Components is proud to present our latest product: HexLog. A journal and log system for Embarcadero Delphi and C++ builder developers. HexLog will be available for the VCL framework and Firemonkey. It supports all platforms including mobile devices (Android and iOS).

Logging vs. journaling

logformatsMost log systems on the market deals with errors. They capture exceptions, performs stack traces and offer ways of delivering this information back to the developer. Delphi developers are blessed with top of the line products, products like Eurekalog and Madexcept. Both these products covers debugging and dealing with exceptions professionally.

HexLog is designed for program-flow logging, also known as journaling. This is where services and applications log their activities regardless. This type of logging is actually a requirement for software delivered to governments and corporations around the world.

Example: The Norwegian government operates with the KITH standard, which is a framework of XML definitions covering hundreds of document, message and data structures. Internationally there are at least seven different frameworks.

One of the requirements of journal-logging is that it should be stored in a format readable by human beings (text, xml, json). The second criteria is that the content, the actual information logged to a journal, should be understandable for non-developers. It should present information that clearly defines what the program is doing, when it was executed and most importantly: why.

Medical software has rigid rules for user activity and program journaling

Get rid of last-minute logging

hexlog_fmxWhen developing system services developers often end up with text file logging. At Quartex Components we have consulted on countless projects the past 10 years, and we have noticed that the majority of developers – even large companies, more often than not end up with a pure “write text to a file” style logging. The worst case being constantly loading, saving a TStringlist.

With a tight deadline and focus on delivering the functionality, logging is often added at the last possible moment. As a result the content of the log and the format in which it is written rarely lives up to standards. Let alone being useful for non developers.

Hexlog and get it right

hexlogAt Quartex Components we take journaling and program-flow logging seriously. Our core journaling component actually gives you advanced features like multi-file storage; meaning that the component will automatically split the log-file into parts in the background. But even though the log consists of many files, you access it like it was a single file.

HexLog is also thread safe, built from the ground up to be accessed by more than one thread. We have also included thread safe value and object envelope classes, designed to make sharing values between threads safe, easy and practical.

Select your format

Hexlog ships with several writer components: text, xml, json and journal. As the names imply the writer is in charge of shaping the output to a specific format. Simply drop the writer component on a form or datamodule and connect it to the central THexLog component, and that’s it!

Abstract storage

Hexlog implements a storage mechanism that is flexible. You can store directly to disk with THexBufferFile, to memory with THexBufferMemory and to zip archives with THexBufferZip.

But perhaps you want to integrate the logging with your backend servers? Simply drop a THexBufferOwner on your form or datamodule and capture 5 simple events. It gives you full control over the data-flow and you can ship the data anywhere you wish.

Multifile API

helpJournaling critical services that performs many tasks means large logs. A typical journal log in the oil-industry is about 1 gigabyte per 24 hour cycle. As you can probably imagine, auditing a one gigabyte text file is not something you want to do. Especially not when the audit is due to a critical system crash and you need to locate the error quickly. With a high-end customer breathing down your neck you really don’t want to jump head first into a file of that size.

To remedy this we developed our multi-file API. Our journal storage component will actually split up the log into pieces, based on the size limitations you set. But you access the log as if it was a single file.

The journal component will calculate offsets, keep track of the files that make up the journal (stored in the journal index file) and do all the grunt-work for you. It actually has more in common with a database engine than a traditional log system.

The components

HexLog includes the following components. It is easy to extend the codebase with your own formats, and through the owner components (THexLogBufferOwner, THexLogWriterOwner) you can easily take charge of how the data looks and where it goes.

  • THexLog
  • THexLogBuffer
    • THexLogBufferMemory
    • THexLogBufferFile
    • THexLogBufferOwner
  • THexLogWriter
    • THexLogWriterXML
    • THexLogWriterJSON
    • THexLogWriterText
    • THexLogWriterJournal
    • THexLogWriterOwner

Protect mechanisms

shieldAs mentioned previously HexLog ships with a unit of generics field and object envelopes. A protection envelope is essentially a thin class wrapper around either an intrinsic datatype or a class instance, where access to the memory or object is automatically handled through classical locking mechanisms.

Using mutexes or critical sections to protect values, especially those shared between threads and processes, is nothing new. But our protection classes simplifies this greatly and also solves it with elegance and ease.

LMyValue: TProtectedValue<integer>;

// create an envelope that protects an integer
LMyValue := TProtectedValue<integer>.create;

// You can also define read/write access
LMyValue := TProtectedValue<integer>.create([lvRead]);

// assign a value, read-write locking is handled
// automatically
LMyValue.value := 1200;

// Perform a locked procedure with exclusive access
// to the value
LMyValue.Synchronize( procedure (var data: integer)
    data := 1200;

HexLib comes with the following protected envelope classes:

  • TProtectedValue
  • TProtectedObject
  • TProtectedObjectList

By using the envelope classes to protect access, the objects themselves can be shared between threads without any of the problems traditionally associated with multi-threading.

You can also use these envelopes for fields in components to make rock-solid, thread safe controls.

Estimated availability

HexLog will enter its beta phase this month (october 2016) and is estimated to be available for purchase the first week of november 2016.

The price is set to $129 with discounts for teams of 4 developers or more.

HexLicense for Firemonkey is shipping

three-rad-logosWe are happy to inform you that HexLicense for Embarcadero Firemonkey is finally out of beta and will ship to registered customers tomorrow (13.10.2016).

HexLicense has been tested on all major platforms:

  • Microsoft Windows 32 and 64 bit
  • Apple OS X 64 bit
  • Google Android
  • Apple iOS

You can read more about HexLicense on the product page: