Archive
Delphi Developer Competition
The Delphi Developer group on Facebook has been around for a few years, and in that time we have held two very interesting demo competitions. The last competition we held was for Smart Pascal (Smart Mobile Studio) only, but we are extending it to include the dialects supported by our group; meaning Delphi, Smart Pascal, Freepascal and Remobjects Oxygene!
Embarcadero shipped over some extra goodies for us, so the competition this year is indeed a magical one. The top 3 contestants all get the official Embarcadero T-Shirt. We also throw in 10 Sencha ball-pens for each of the top 3 contestants; this is in addition to the actual prizes listed below (!)
The #1 winner not only get the 100€ FPGA devkit (see prizes below), he or she walks off with a high-quality, stainless steel Embarcadero branded coffee mug that holds half a litre of breakfast! (I seriously wanted to keep this for myself).
The prizes in all their glory!
Submission rules are:
- Source submission (GPL, LGPL) + binary
- No dependencies on commercial libraries or components
- Submissions must be available through GIT or BitBucket
- Submission must include everything it needs to be compiled
Submission categories are:
- Graphical demo (demo-scene style)
- Games and multimedia
- General purpose (utility programs)
Use the following Google form to register:
The purpose of the submissions is to show off both the language and your skills. Back in 2013 we got a ton of really cool demo-scene stuff, demonstrating timeless techniques; everything from bouncing meta-balls, gouraud shaded vectors, sinus scroll-texts and webgl landscape flight. We also had a fantastic fractal explorer program, bitmap rotozoom generator – and two great games! Which both made it onto AppStore and Google Play!
First prize
The winner walks off with some exciting stuff!
The first prize this year is something really, really special. The winner walks off with a spiffing Altera Cyclone IV FPGA starter board. This is a spectacular FPGA kit that allows you to upload a wide range of ready-to-rock FPGA core’s, as well as your own logic designs.
But to make it more accessible we added a retro daughter board, this gives you VGA, audio, keyboard, mouse, MicroSD, serial and two old school joystick ports. The daughterboard is needed if you plan on using some of the retro-cores out there. I personally love the Amiga core (shock, I know) but you can run anything from a humble Spectrum to Sega Megadrive, SNES, Atari ST/E, Neo-Geo and many others.
While the daughter-board makes this wonderful for retro-computing and gaming, fpga is first and foremost a tool for engineering. It ships with a USB-Blaster which allows you to connect it directly to your PC and it will be recognized as a device. FPGA modeling applications will pick this up and you can test out designs “live”, or just place a core on the SD-card and edit the boot config.
The kit sells for roughly 100€ with a case, but getting both the motherboard and the retro daughter-board is difficult. These things are sold separately, and the daughter board is produced in small numbers by dedicated hackers. So winning a kit that is pre-assembled, soldered and ready to go is quite a prize!
If you are even remotely interested in FPGA programming, this should give you goosebumps!
Second prize
The most powerful SBC I have ever used
The silver medal is the powerful Asus Tinkerboard, this is probably the most powerful SBC you can get below 100€. It delivers 10 times the firepower a Raspberry PI 3b can muster – and is superbly suited for Android development, Smart Mobile Studio kiosk systems and much, much more.
Of all the board I have tested and own this is the one with enough CPU grunt (even the mighty ODroid XU4 can’t touch this) to rival a low-end x86 laptop. You have to fork out for a SnapDragon IV to beat the Tinkerboard.
I have two of these around the house myself, one as a game console running Emulation Station (emulates PSX 1, 2 and 3 games), and another under my TV with Kodi and a 2 terabyte movie collection.
Third prize
Last but not least the bronze medal is a Raspberry PI 3b. The PI should be no stranger to programmers today, it more or less defines the IOT revolution and has, by far, the biggest collection of software available of all SBC (single board computers) available today.
The device that represents the IOT phenomenon
The PI is a wonderful starter board for Delphi developers who want to play with hardware under android. It’s also a fantastic board for Smart and FPC development.
I use a PI to test node.js services written in Smart Mobile Studio.
Dates
We start the clock on the 1st of october and submission must be delivered by the 31st. So you have a full month to code something cool!
Remember comments
While not always possible, try to write clean code. Part of the point here is to use these demos as an educational source.
We wont reject non-commented code, but please try to avoid 20k lines of spaghetti.
Hints and tips
Delphi has brilliant support for DirectX and OpenGL, so taking advantage of hardware acceleration should not be a problem. FMX is largely powered by the GPU and has 3d rendering and modeling as an integral feature – so Delphi developers have a slight advantage there.
Tilesets are graphics-blocks that can be used to create large game levels with a map-editor
If you want to use DIB’s under vanilla WinAPI there is always Graphics32, a wonderful and exceptionally detailed library for fast graphics.
Music: Most demo-scene code use mod music (actually today people play MP3’s as well), and there are good wrappers for player libraries like Bass. It’s always a nice touch to add a spot of music (and literally millions of free mod tracks freely available). So give your demo some flair by adding a kick-ass mod track, or impress us by writing a score yourself?
In the world of demo coding anything goes! Bring out that teenage spirit and go wild, create wonderful graphical effects, vector objects, scrolling texts, games or whatever tickles your fancy. If you need inspiration, check out the demo scene videos on YouTube (if that is what you would like to submit of course). A kick-ass database application, X server renderer, paint program or a compiler — it’s all good!
Make people go WOW that is cool!
Tile graphics: which is often used in games and demos, can be found almost anywhere. If you google “tileset” or “game tiles” you should get more than you need. Brilliant for parallax scrolling. Why not give Super Mario a run for its money? Show the next generation how to code a platform game! Check out the Tiled map-editor, this has a JSON export filter for you Smart Pascal coders.
Tiled is a powerful map editor. There is also mappy, which I believe have a Delphi player
OK guys, the game is a-foot! May the best coder win!
Smart Mobile Studio presentation in Oslo
Yesterday evening I traveled to Oslo and held a presentation on Smart Mobile Studio. The response was very positive and I hope that everyone who attended left with some new ideas regarding JavaScript, the direction the world of software is heading – and how Smart Mobile Studio can be of service to Delphi.
Smart Pascal is especially exciting in concert with Rad-Server, where it opens the doors to Node based, platform independent services and sub clustering. With relatively little effort Rad-Server can absorb the wealth that node has to offer through Smart – but on your terms, and under Delphi’s control. The best of both worlds.
You get the stability and structure that makes Delphi so productive, and then infuse that with the flamboyance, flair and async brilliance that JavaScript represents.
More important than technology is the community! It’s been a few years since I took part in the Oslo Delphi Club’s meetups, so it was great to chat with Halvard Vassbotten, Trond Grøntoft, Alf Christoffersen, Torgeir Amundsen and Robin Bakker face to face again. I also had the pleasure of meeting some new Delphi developers.
Presentation at ABG Sundal Collier’s offices in Oslo
Thankfully the number of attendees were a moderate 14, considering this was my first presentation ever. Last time I visited was when our late Paweł Głowacki presented FMX, and the turnout was in the ballpark of a hundred. So it was an easy-going, laid-back atmosphere throughout the evening.
Conflict of interest?
Some might wonder why a person working for Embarcadero will present Smart Mobile Studio, which some still regard as competition. Smart is not in competition with Delphi and never will be. It is written by Delphi developers for Delphi developers as a means to bridge two worlds. It’s a project of loyalty and passion. We continue because we love what it enables us to do.
The talks on Smart that I am holding now, including the november talk in London, were booked before I started at Embarcadero (so it’s not a case of me promoting Smart in leu of Embarcadero). I also made it perfectly clear when I accepted the job that my work on Smart will continue in my spare time. And Embarcadero is fine with that. So I am free to spend my after-work hours and weekend time as I see fit.
The Smart Desktop, codename Amibian.js, is a solid foundation for building large-scale web front-ends. Importing Sencha’s JS API’s can be done via our TypeScript wizard
So, after my presentation in London in november Smart Mobile Studio presentations (at least hosted by me) can only take place during weekends. Which is fair and the way it should be.
Recording the English version
Since the presentation last evening was in Norwegian, there was little point in recording it. Norway have a healthy share of Delphi developers, but a programming language available internationally must be presented in English.
A couple of months back, before I started working for Embarcadero I promised to do a video presentation that would be available on Delphi Developer and YouTube. I very much like to keep that promise. So I will re-do the presentation in English as soon as possible. I would have done it today after work, but buying tech from the US have changed quite dramatically in just a couple of years.
In short: I haven’t received the remaining equipment I ordered for professional video recording and audio podcasting (which is a part of my Patreon offering as well), as such there will be no live video-feed /slash/ webinar – and questions will be limited to either the comment-section on Delphi Developer; or perhaps more appropriate, the Smart Mobile Studio Forums.
I’m hoping to get the HD camera, mic-table-arm and various bits-and-bobs i ordered from the US sometime next week. I have no idea why FedEx have become so difficult lately, but the package is apparently at LaGuardia, and I have to send receipts that document that these items are paid for before they ship them abroad (so the package manifest listing me as the customer, my address, phone number and receipt from the seller is somehow not enough). This is a first for me.
Interestingly they also stopped a package from Embarcadero with giveaways for my upcoming Delphi presentation in Sweden – at which point I had to send them a copy of my work contract to prove that I indeed work for an American company.
But a promise is a promise, so come rain or shine it will be done. Worst case scenario we can put Samsung’s claims to the test and hook up a mic + photo lens and see if their commercials have any merit.
Linux: political correctness vs Gnu-Linux hacker spirit
Unless you have been living under a rock, the turmoil and crisis within the Linux community these past weeks cannot have escaped you. And while not directly connected to Delphi or the Delphi Developer group on Facebook, the effects of a potential collapse within the core Linux development team will absolutely affect how Delphi developers go about their business. In the worst possible scenario, should the core team and it’s immediate extended developers decide to walk away, their code walks with them. Rendering much of the work countless companies have invested in the platform unreliable at best – or in need of a rewrite at worst (there is a legal blind-spot in GPL revision 1 and 2, allowing developers to rescind their code).
Large parts of the kernel would have to be re-invented, a huge chunk of the sub-strata and bedrock that distributions like Ubuntu, Mint, Kali and others rests on – could risk being removed, or rescinded as the term may be, from the core repositories. And perhaps worst of all, the hundreds of patches and new features yet to be released might never see the light of day.
To underline just how dire the situation has been the past couple of weeks, Richard Stallman, Eric S. Raymond, Linus Torvalds and others are threatening, openly and legally, to pull all their code (September 20th, Linux Kernel Mailing List) if the bullying by a handful of activist groups doesn’t stop. Linus is still in limbo having accepted the code of conduct these activist demand implemented, but has yet to return to work.
Linus Torvalds is famous for many things, but his personality is not one of them
But the interesting part of the Linux debacle is not the if’s and but’s, but rather the methods used by these groups to get their way. How can you enforce a “code of conduct” using methods that themselves are in violation with that code of conduct? It really is a case of “do as I say, not as I do”; And it has escalated into a gutter fight masquerading as social warfare where slander, stigmata, false accusations and personal attacks of the worst possible type are the weapons. All of which is now having a real and tangible impact on business and technology.
Morally bankrupt actions is not activism
These activists, if they deserve that title, even went as far as deciding to dig into the sexual-life of one of the kernel developers. And when finding out that he was into BDSM (a form of sexual role-play), they publicly stigmatized the coder as a rape sympathizer (!). Not because it’s true, but because the verbal association alone makes it easier for bullies like Coraline to justify the social execution of a man in public.
What makes my jaw drop in all this, is the complete lack of compassion these so-called activists demonstrate. They seem blind to the price of such stigmata for the innocent; not to mention the insult to people who have suffered sexual abuse in their lives. For each false accusation of rape that is made, the difficulty for actual abuse victims to seek justice increases exponentially. It is a heartless, unforgivable act.
Personally, I can’t say I understand the many sexual preferences people have these days. I find myself googling what the different abbreviations mean. The movie 50 shades of gray revolved around this stuff. But one thing is clear: as long as there are consenting adults involved, it is none of our business. If there is evidence of a crime, then it should be brought before the courts. And no matter what we might feel about the subject at hand, it can never justify stigmatizing a person for the rest of his life. Not only is this a violation of the very code of conduct these groups wants implemented – it’s also illegal in most of the civilized world. And damn immoral and out-of-line if you ask me.
The goal cannot justify the means
The irony in all of this, is that the accusation came from Coraline herself. A transgender woman born in the wrong body; a furious feminist now busy fighting to put an end to bullying of transgender minorities in the workplace (which she claims is the reason she got fired from Github). Yet she has no problems being the worst kind of bully herself on a global scale. I question if Coraline is even morally fit to represent a code of conduct. I mean, to even use slander such as rape-sympathizer in context with getting a code of conduct implemented? Digging into someones personal life and then using their sexual preference as leverage? It is utterly outrageous!
It is unacceptable and has no place in civilized society. Nor does a code of conduct, beyond ordinary expectations of decency and tolerance, have any place in a rebel motivated R&D movement like Linux.
Linux is not Windows or OS X. It was born out of the free software movement back in the late 1960’s (Stallman with GNU) and the Scandinavian demo and hacker scene during the 80’s and 90’s (the Linux kernel that GNU rests on). This is hacker territory and what people might feel about this in 2018 it utterly irrelevant. These are people that start the day with 4Chan for pete sake! The primary motivation of Stallman and Linus is to undermine, destroy and bury Microsoft and Apple in particular. And they have made no secret of this agenda.
Expecting Linux or their makers to be politically correct is infantile and naive, because Linux is at its heart a rebellion, “a protest of technical excellence and access to technology undermining commercial tyranny and corporate slavery”. That is not my personal opinion, that is straight out of a Richard Stallman book Free as in Freedom; His papers reads more like a religious manifesto; a philosophical foundation for a technological utopia, seeded and influenced by the hippie spirit of the 1960s. Which is where Stallman’s heart comes from.
You cannot but admire Stallman for sticking to his principles for 50+ years. And thinking he is going to just roll over because activists in this particular decade has a beef with how hackers address each other or comment their code, well — I don’t think these activists understand the hacker community at all. If they did they would back off and stop poking dragons.
Linux vs the sensitivity movement?
Yesterday I posted a video article that explained some of this in simple, easy terms on Delphi Developer. I picked the video that summed up the absurdities involved (as outlined above) as quickly as possible, rather than some 80 minute talk on YouTube. We have a long tradition of posting interesting IT news, things that are indirectly connected with Delphi, C++ builder or programming in general. We also post articles that have no direct connection at all – except being headlines within the world of IT. This helps people stay aware of interesting developments, trends and potential investments.
The head of the “moral codex” doesn’t strike me as unbiased and without an axe to grind
As far as politics is concerned I have no interest what so ever. Nor would I post political material in the group because our focus is technology, Delphi, object pascal and software development in general. The exception being if there is a bill or law passed in the US or EU that affects how we build applications or handle data.
Well, this post was no different.
What was different was that some individuals are so acclimatized to political debate that they interpret everything as a political statement. So criticism of the methods used are made synonymous with criticism of a cause. This can happen to the best of us; human beings are passionate animals and I think we can all agree that politics has taken up an unusual amount of space lately. I can’t ever remember politics causing so much bitterness, divide and hate as it does today. Nor can I remember sound reason being pushed aside in favour of immediate emotional trends. And it really scares me.
Anyways, I wrote that “I stand by my god given rights to write obscene comments in my code“. Which is a reference to one of the topics Linus is being flamed for, namely his use of the F word in his own code. My argument is that, the kernel is ultimately Torvalds work, and it’s something he gives away for free. I dont have any need for obscenity in my code, but I sure as hell reserve the right to do so in my personal projects. How two external groups (in this case a very aggressive feminist group combined with LGBTQIA) should have any say in how Linus formats his code (or you for that matter) or the comments he writes – it makes no sense. It’s free, take it or leave it. And if you join a team and feel offended by how things are done, you either ignore it or leave.
It might not be appropriate of Linus to use obscenity in his comments, but do you really want people to tell you what you can or cannot write in your own code? Lord knows there are pascal units online that have language unfit for publishing, but nobody is forcing you to use them. I cant stand Java but I dont join their forums and sit there like a 12 year old bitching about how terrible Java is. It’s just infantile, absurd mentality.
So that is what my reference was to, and I took for granted that people would pick up on that since Linus is infamous for his spectacular rants in the kernel (and verbally in interviews). Some of his commits have more rants than code, which I find hilarious. There is a collection of them online and people read them for kicks because he is, for all means and purposes, the Gordon Ramsey of programming.
And I also made a reference to “tree hugging millennial moralists”. Not exactly hard-core statements in these trying times. We live in a decade where vegan customers are looking to sue restaurants for serving meat. Maybe I’m old-fashioned but for me, that is like something out of Monty Python or Mad Magazine. I respect vegans, but I will not be dictated by them.
I mean, the group people call millennials is after all recognized as a distinct generation due to a pattern of unreasonable demands on society (and in extreme cases, reality itself). In some parts of the world this is a real problem, because you have a whole generation that expects to bag upper-management salary on a paper route. When this is not met you face a tantrum and aggressiveness that should not exist beyond a certain age. Having a meltdown like a six-year-old when you are twenty-six is, well, not something I’m even remotely interested in dealing with.
And I speak from experience here, I had the misfortune of working with one extreme case for a couple of years. He had a meltdown roughly once a month and verbally abused everyone in the office. Including his boss. I still can’t believe he put up with it for so long, a lesser man would have physically educated him on the spot.
The sensitivity movement
But (and this is important) like always, a stereotype is never absolute. The majority within the millennial age group are nothing like these extreme cases. In fact we have two administrators in Delphi Developer that both fall under the millennial age group – yet they are the exact opposite of the stereotype. They are extremely hard-working, demonstrate good moral and good behavior, they give of themselves to the community and are people I am proud to call my friends.
The people I refer to as the sensitivity movement consists of men and women that hold, in my view, demands to life that are unreasonable. We live in times where for some reason, and don’t ask me why, minorities have gotten away with terrible things (slander, straw-men tactics, blame shifting, perversion of facts, verbal abuse, planting dangerous rumours and false accusation; things that can ruin a person for life) to impose their needs opposed to the greater good and majority. And no, this has nothing to do with politics, it has to do with expectation of normal decency and minding your own business. As a teenager I had my share of rebellion (some would say three shares), but I never blamed society; instead I wanted to understand why society was the way it is, which led me to studying history, comparative religion and philosophy.
The minorities of 2018 have no interest in understanding why, they mistake preference with offence, confuse kindness with weakness – and are painfully unable to discern knowledge from wisdom. The difference between fear and respect might be subtle, but on reflection a person should make important discoveries about their own nature. Yet this seem utterly lost on men and women in their 20s today.
And just to make things crystal clear: the minorities I am referring to here as the so-called sensitivity movement, are not the underprivileged or individuals suffering a disadvantage. The minorities are in fact highly privileged individuals – enjoying the very freedom of expression they so eagerly want taken away from people they don’t like. That is a very dangerous path.
Linux, the bedrock of the anti-establishment movement
The Linux community has a history of being difficult. Personally I find them both helpful and kind, but the core motivation behind Linux as a phenomenon cannot be swept under the carpet or ignored: these are rebels, rogues, people who refuse to bend the knee.
Linux itself is an act of defiance, and it exists due to two key individuals who both are extremely passionate by nature, namely Richard Stallman and Linus Torvalds.
Attacking these from all sides is shameful. I find no other words for it. Especially since its not a matter of principles or sound moral values, but rather a matter of pride and selfish ideals.
Name calling will not be tolerated
The reason I wrote this post was not to involve everyone in the dire situation of Linux, at least not to bring an external problem into our community and make it our problem. It was news that is of some importance.
I wrote this blogpost because a member somehow nicknamed me as “maga right-wing” something. And I’m not even sure how to respond to something like that.
First of all I have no clue what maga even is, I think it’s that cap slogan trump uses? Make america great again or something like that? Secondly, I live in Norway and know very little of the intricacies of domestic american politics. I have voted left for some 20 years, with exception of last norwegian election when I voted center. How my respect for Stallman and Linus, and how the hacker community operates (I grew up in the hacker community) – somehow connects me to some political agenda on another continent, is quite frankly beyond me.
But this is exactly the thing I wrote about above – the method being deployed by these groups. A person read something he or she doesn’t like, connects that to a pre-defined personality type, this is then supposed to justify wild accusations – and he or she then proceeded directly to treating someone accordingly. THAT behavior IS offensive to me, because there should be a dialog quite early in that chain of events. We have dialog to avoid causing harm – not as a means to cause further damage.
Is it the end of Linux as we know it?
No. Linus has been a loud mouth for ages, and he actually have people who purge his code of swear words (which is kinda funny) – but he has accepted the code of conduct and taken some time off.
The threat Stallman and the core team has made however is very real, meaning that the inner circle of Linux developers can flick the kill switch if they want to, but I think the negative press Coraline and those forcing their agenda onto the Linux foundation is getting, will make them regret it. And of course, articles like the New Yorker published didn’t help the situation.
Having said that, these developers are not normal people. Normal is a cut of average behavior. And neither Stallman, Linus of the hacker community fall under the term “normal” in the absolutesense of the word. Not a single individual that has done something of importance technologically fall under that group. Nor do they have any desire to be normal either, which is a death sentence in the hacker community. The lowest, most worthless status you can hold as a hacker, is normal.
These are people who build operating systems for fun. They are passion driven, artistic and highly emotional. And as such they could, should more gutter tricks be deployed, decide to burn the house down before they hand it over.
So it’s an interesting case well worth keeping an eye on. Preferably one that doesn’t add or subtract from what is there.
Help&Doc, documentation made easy
I have been flamed so much lately for not writing proper docs for Smart Mobile Studio, that I figured it was time to get this under wraps. Now in my defence I’m not the only one on the Smart Pascal team, sure I have the most noise, but Smart is definitely not a solo operation.
So the irony of getting flamed for lack of docs, having perpetually lobbied for docs at every meeting since 2014; well that my friend is mother nature at her finest. If you stick your neck out, she will make it her personal mission to mess you up.
So off I went in search of a good documentation system ..
The mission
My dilemma is simple: I need to find a tool that makes writing documentation simple. It has to be reliable, deal with cross chapter links, handle segments of code without ruining the formatting of the entire page – and printing must be rock solid.
Writing documentation in Open Office feels very much like this
If you are pondering why I even mention printing in this digital age, it’s because I prefer physical media. Writing a solid book, be it a mix between technical reference and user’s guide, can’t compare to a blog post. You need to let the material breathe for a couple of days between sessions to spot mistakes. I usually print things out, let it rest, then go over it with an old fashion marker.
Besides, my previous documentation suite couldn’t do PDF printing. I’m sure it could, just not around me. Whenever I picked Microsoft PDF printer as the output, it promptly committed suicide. Not even an exception, nothing, just “poff” and it terminated. The first time this happened I lost half a days work. The third time I uninstalled it, never to look back.
Another thing I would like to see, is that the program deals with graphics more efficiently than Google Docs, and at the very least more intuitively than Open Office (Oo in short). Now before you argue with me over Oo, let me just say that I’m all for Open-Office, it has a lot of great features. But in their heroic pursuit of cloning Microsoft to death, they also cloned possibly the worst layout mechanisms ever invented; namely the layout engine of Microsoft Word 2001.
Let’s just say that scaling and perspective is not the best in Open Office. Like Microsoft Word back in the day, it faithfully favours page-breaks over perspective based scaling. It will even flip the orientation if you don’t explicitly tell it not to.
Help & Doc
As far as I know, there are only two documentation suite’s on the market related with Delphi and coding. At least when it comes to producing technical manuals, help files and being written in Delphi.
First you have the older and perhaps more established Help & Manual. This is followed by the younger but equally capable Help & Doc. I ended up with the latter.
Help & Doc’s main window, clean and pleasing to the eye
Both suite’s have more in common than similar names (which is really confusing), they offer pretty much the exact same functionality. Except Help & Doc is considerably cheaper and have a couple features that developers favour. At least I do, and I imagine the needs of other developers will be similar.
Being older, Help & Manual have worked up more infrastructure , something which can be helpful in larger organizations. But their content-management strategy is (at least to me) something of a paradox. You need more than .NET documentation and shared editing to justify the higher price -and having to install a CMS to enjoy shared editing? It might make sense if you are a publisher, ghostwriter or if you have a large department with 5+ people doing nothing but documentation; but competing against Google Documents in 2018? Sorry, I don’t see that going anywhere.
For me, Help & Doc makes more sense because it remains true to its basic role: to help you create documentation for your products. And it does that very, very well.
Help & Doc has a built-in server for testing web documentation with minimum of fuzz
I also like that Help & Doc are crystal clear about their origins. Help & Manual have anonymized their marketing to tap into .Net and Java; they are not alone, quite a few companies try to hide the fact that their flagship product is written in object pascal. So you get a very different vibe from these two websites and their products.
The basics
Much like the competition, Help & Doc offers a complete WYSIWYG text editor with support for computed fields. So you can insert fields that hold variable data, like time, date (and various pieces of a full datetime), project title, author name [and so on]. I hope to see script support at some point here, so that a script could provide data during PDF/Web generation.
The editor is responsive and well written, supports tables, margins and formatting like you expect from a modern editor. Not really sure how much I need to write about a text editor, most Delphi and C++ developers have high standards and I suspect they have used RichView, which is a well-known, high quality component.
One thing I found very pleasing is that fonts are not hidden away but easily accessible; various text styles hold a prominent place under the Write tab on top of the window. This is very helpful because you don’t have to apply a style to see how it will look, you can get an idea directly from the preview.
Very nice, clear and one click away
Being able to insert conditional sections is something I found very easy. It’s no doubt part of other offerings too, but I have never really bothered to involve myself. But with so many potential targets, mobile phones, iPads, desktops, Kindle – suddenly this kind of functionality becomes a thing.
Adding conditional sections is easy
For example if you have documentation for a component, one that targets both Delphi, .NET and COM (yes people still use COM believe it or not) you don’t need 3 different copies of the same documentation – with only small variations between them. Using the conditional operations you can isolate the differences.
With Apple OSX, iOS and Android added to the compiler target (for Delphi), the need to separate Apple only instructions on how to use a library [for example], and then only include that for the Apple output is real. Windows and Linux can have their own, unique sections — and you don’t need to maintain 3 nearly similar documentation projects.
When you combine that with script support, Help & Doc is flexing some powerful muscles. I’m very much impressed and don’t regret getting this over the more expensive Help and Manual. Perhaps it would be different if I was writing casual books for a publisher, or if I made .NET components (oh the humanity!) and desperately needed to please Visual Studio. But for a hard-core Delphi and object pascal developer, Help & Doc has everything I need – and then some!
Wait, what? Script support?
Scripting docs
One of the really cool things about Help & Doc is that it supports pascal scripting. You can do some pretty amazing things with a script, and being able to iterate through the documentation in classical parent / child relationships is very helpful.
The central role of Object Pascal is not exactly hidden in Help & Doc
If you are wondering why a script engine would even be remotely interesting for an author, consider the following: you maintain 10-12 large documentation projects, and at each revision there will be plenty of small and large changes. Things like class-names getting a new name. If you have mentioned a class 300 times in each manual, changing a single name is going to be time-consuming.
This is where scripting is really cool because you can write code that literates through the documentation, chapter by chapter, section by section, paragraph by paragraph – and automatically replace all of them in a second.
Metablaster was a desktop search engine I made in 1999. I used scripts to target each search engine
I haven’t spent a huge amount of time with the scripting API Help & Doc offers yet (more busy writing), but I imagine that a plugin framework is a natural step in its evolution. I made a desktop search engine once, back between 1999 and 2005 (just after the bronze age) where we bolted Pascal Script into the system, then implemented each search engine parser as a script. This was very flexible and we could adapt to changes faster than our competitors.
While I can only speculate and hope the makers of Help & Doc reads this, creating an API that gives you a fair subset of Delphi (streams, files, string parsing et-al) that is accessible from scripts, and then defining classes for import scripts, export scripts, document processing scripts; that way developers can write their own import code to support a custom format (medical documentation springs to mind as an example). Likewise developers could write export code.
This is a part of the software I will explore more in the weeks to come!
Verdict – is it worth it?
As of writing you get Help & Doc professional at 249 €, and you can pick up the standard edition for 99€. Not exactly an earth shattering price for the mountain of work involved in creating such an elaborate system. If you factor in how much time it saves you: yes, why on earth would you even think twice!
Using Help & Doc is very easy, here we are creating a new doc with a few chapters
I have yet to find a function that their competition offers that would change my mind. As a developer who is part of a small team, or even as a solo developer – documentation has to be there. I can list 10.000 reasons why Smart never got the documentation it deserves, but at least now I can scratch one of them off my list. Writing 500 A4 pages in markdown would have me throwing myself into the fjords at -35 degrees celsius.
And being the rogue that I am, should I find intolerable bugs you will be sure to hear about them — but I have nothing to complain about here.
Its one of the most pleasant pieces of software I have used in a long time.
Human beings and licenses
Before I end this article, I also want to mention that Help & Doc has a licensing system that surprised me. If you buy 2 licenses for example, you get to link that with a computer. So you have very good control over your ownership. Should you run out of licenses, well then you either have to relocate an existing license or get a new one. You are not locked out and they don’t frag you with compliance threats.
Doesn’t get much easier than this
I use VMWare a lot and sometimes forget that I’m running a clone on top of a clone, and believe me I have gotten some impressive emails in the past. I think the worst was Xamarin Mono which actually deactivated my entire environment until I called them and explained I was doing live debugging between two VMWare instances.
So very cool to see that you can re-allocate an existing license to whatever device you want without problems.
To sum up: worth every penny!
HexLicense, Patreon and all that
Apparently using modern service like Patreon to maintain components has become a point of annoyance and confusion. I realize that I formulated the initial HexLicense post somewhat vague and confusing, in retrospect I will admit that and also take critique for not spending a little more time on preparations.
Having said that, I also corrected the mistake quickly and clarified the situation. I feel some of the comments have been excessively critical for something that, ultimately, is a service to the community. But I’ll roll with the punches and let’s just put this issue to bed.
From the top please
I have several products and frameworks that naturally takes time to maintain and evolve. And having to maintain websites, pay for tax and invoicing services, pay for hosting (and so on), well it consumes a lot of hours. Hours that I can no longer afford to spend (my work at Embarcadero must come first, I have a family to support). So Patreon is a great way to optimize a very busy schedule.
Today developers solve a lot of the business strain by using Patreon. They make their products open source, but give those that support and help fund the development special perks, such as early access, special builds and a more direct line of control over where the different projects and sub-projects are heading.
The public repository that everyone has access to is maintained by pushing the code on interval, meaning that the public “free stuff” (LGPL v3 license) will be some months behind the early-access that patrons enjoy. This is common and the same approach both large and small teams go about things in 2018. Quite radical compared to what we “old-timers” are used to, but that’s how things work now. I just go with flow and try to do the most amount of good on the journey.
Benefits of Patreon
The benefits are many, but first and foremost it has to do with time. Developer don’t have to maintain 3-4 websites, pay for invoicing services on said products, pay hosting fees and rent support forums — instead focus is on getting things done. So instead of an hour here and there, you can (based on the level of support) allocate X hours within a week or weekend that are continuous.
Patreon solves two things: time and cost
Everyone wins. Those that support and help fund the projects enjoy early access and special builds. The community at large wins because the public repository is likewise maintained, albeit somewhat behind the cutting edge code patrons enjoy. And the developers wins because he or she doesn’t have to run around like a mad chicken maintaining X number of websites -wasting more time doing maintenance than building cool new features.
And above all, pricing goes down. By spreading the cost over a larger base of interest, people get access to code that used to cost $200 for $35. The more people that helps out, the more the cost can be reduced per tier.
To make it crystal clear what the status of my frameworks and component packages are, here is a carbon copy from HexLicense.com
For immediate release
Effective immediately HexLicense is open-source, released under the GNU Lesser General Public License v3. You can read the details of that license by clicking here.
Patreon model
In order to consolidate the various projects I maintain, I have established a Patreon account. This means that people can help fund further development on HexLicense, LDEF, Amibian and various Delphi libraries as a whole. This greatly simplifies things for everyone.
I will be able to allocate time based on a broader picture, I also don’t need to pay for invoicing services, web hosting and more. This allows me to continue to evolve the components and code, but without so many separate product identities to maintain.
Patreon supporters will receive updates before anyone else and have direct access to the latest code at all times. The public bitbucket repository will be updated on interval, but will by consequence be behind the Patreon updates.
Further security
One of the core goals on Patreon is the evolution of a bytecode compiler. This should be of special interest to HexLicense users. Being able to compile modules that hackers will be unable to debug gives you a huge advantage. The engine is designed so that the instruction-set can be randomized for a particular build. Making it unique for your application.
The LDEF assembler prototype running under Smart Mobile Studio
Well, I want to thank everyone involved. It has been a great journey to produce so many components, libraries and solutions over the years – but now it’s time for me to cut down on the number of projects and focus on core technology.
HexLicense with the update license files will be uploaded to BitBucket shortly.
Sincerly
Jon Lennart Aasenden
Building a Delphi Database engine, part three
If you missed the initial two episodes in this tutorial, click here for the first article and here for the second. Even if you feel databases is something you master I urge you to read the articles from scratch, because the database theory we explore here is not the high-level concepts we learnt at school. Having said that it’s not too complex and with a bit of exploring you should find it easy to follow.
Update your git fork
In the previous episode you were asked to fork the project code from bitbucket. As we progress I will continue to add units and refactor code, so if you forked the code last time, you should fetch the latest revision before you continue.
Since GIT is incremental and awesome you can just revert to previous commits for the examples as we move along. I will mark each commit so you can see what is what and easily jump between examples.
Quick recap from our previous episode
Our last episode ended with a fidelity test on the storage medium. We implemented a class that would operate on blocks (or parts) of a defined size, rather than single bytes like a TStream does. The idea being that the class can create, read and write the blocks that contains the data; also known as a database pagesize.
I also introduced the notion of buffer classes, which are similar to Delphi streams. The buffer classes are actually Delphi implementations of the buffers found in node.js, which adds two very important benefits: the ability to inject and remove data from any point. So if you want to inject 1 gigabyte into the middle of a file, that can be done in a single call. If you want to remove 1 gigabyte from somewhere in the file, that is likewise reduced to a single call.
Buffers are designed to give you easier access to the data inside the buffer, while streams are great for normal programming tasks, buffers are much faster and ad-hoc, and thus better suited for database work.
From blocks to sequences
In this article’s code the focus is on sequences and putting together the essentials for our database class. Which means the ability to store sequences and being able to recover them (record persistency).
A sequence is, like I explained in our previous episode, file-parts that are linked together through offsets.
Whenever you want to store data that exceeds the page-size defined for a database, the only solution is to divide that data into parts and then spread the data over many blocks. We daisy-chain them together by setting the block number for the next block in the sequence in each of the parts (a block or part is ultimately just a record we write to the file), terminated by the value -1 ($FFFFFFFF as an unsigned longword). So the last block in the chain has the “next” field set to -1, which tells the system that there is no more data to fetch for the sequence.
If you are unsure about what I mean, please read up on sequences in the previous two articles.
Sequence persistency
What we are doing in this episode is to merge all the things we have talked about so far into a single class. The bit buffer is done, the block-file class is done, and now we need to make sure we can read and write full sequences.
This brings us to the problem of scaling. An empty database will not have any free blocks. So a part of the sequence reading and writing mechanism is the ability to expand the file on demand.
We also need to have some support functionality for mapping a sequence, otherwise we would have to store an awful lot of information for each record. We only really need to know the first block number in a sequence (because that will have a reference to any subsequent blocks used by a sequence). With mapping I mean a function that can investigate a sequence and return an array of block numbers, so that we know where each part of the sequence has ended up.
This might not be immediately useful, but when we reach the point of compacting a database, it becomes vital that we can quickly map what blocks a sequence occupy – and then organize them in a linear fashion so that the data can be read faster, and we can release excess empty space.
Changes to the header and part records
Suddenly our metadata needs have grown considerably. We need to store the bit-buffer that holds the map of the whole database (all the blocks are either used [1] or available [0]). We need to store a list of longwords that represents the records in a database. Please note that on this level, the database doesn’t care what record belongs to what table. And last but not least we need a file-header and block record that can keep track of the initial values.
Let’s have a look at the records first:
// Custom data structures
TDbVersion = packed record
bvMajor: byte;
bvMinor: byte;
bvRevision: word;
end;
TDbLibFileHeader = packed record
dhSignature: longword;
dhVersion: TDbVersion;
dhName: shortstring;
dhMetadata: longword;
dhRecList: longword;
dhBitBuffer: longword;
class function Create: TDbLibFileHeader; static;
end;
TDbPartData = packed record
ddSignature: longword;
ddRoot: longword;
ddPrevious: longword;
ddNext: longword;
ddBytes: integer;
ddData: packed array [0 .. CNT_DATABASEFILE_PAGESIZE - 1] of byte;
class function Create: TDbPartData; static;
end;
Notice that the part-data (block) has fields to keep track of the root (the first part in the sequence), the previous part in the sequence amd the next part in the sequence. This gives us a lot of freedom when we want to do some tooling for the engine later.
If you look at the file-header this has also been expanded. It has a field to hold the first part in the meta-data sequence, the record list (the total list of sequences stored in the file) and the bit buffer.
Metadata
There are quite a few classes we need to introduce, so let’s start at the top, namely the meta-data classes. In our case the metadata is (first and foremost):
- Tables
- Fields
- Database name
The reason I have isolated each of these as classes, is to make it easier to expand the system later. So let’s have a look at the classes:
IExtendedPersistence = interface
['{282CC310-CD3B-47BF-8EB0-017C1EDF0BFC}']
procedure ObjectFrom(const Reader: TDbLibReader);
procedure ObjectFromStream(const Stream: TStream; const Disposable: boolean);
procedure ObjectFromData(const Data: TDbLibBuffer; const Disposable: boolean);
procedure ObjectFromFile(const Filename: string);
procedure ObjectTo(const Writer: TDbLibWriter);
function ObjectToStream: TStream; overload;
procedure ObjectToStream(const Stream: TStream); overload;
function ObjectToData: TDbLibBuffer; overload;
procedure ObjectToData(const Data: TDbLibBuffer); overload;
procedure ObjectToFile(const Filename: string);
end;
IDbLibFields = interface
['{0D6A9FE2-24D2-42AE-A343-E65F18409FA2}']
function IndexOf(FieldName: string): integer;
function ObjectOf(FieldName: string): TDbLibRecordField;
function Add(const FieldName: string; const FieldClass: TDbLibRecordFieldClass): TDbLibRecordField;
function Addinteger(const FieldName: string): TDbLibFieldInteger;
function AddStr(const FieldName: string): TDbLibFieldString;
function Addbyte(const FieldName: string): TDbLibFieldbyte;
function AddBool(const FieldName: string): TDbLibFieldboolean;
function AddCurrency(const FieldName: string): TDbLibFieldCurrency;
function AddData(const FieldName: string): TDbLibFieldData;
function AddDateTime(const FieldName: string): TDbLibFieldDateTime;
function AddDouble(const FieldName: string): TDbLibFieldDouble;
function AddGUID(const FieldName: string): TDbLibFieldGUID;
function AddInt64(const FieldName: string): TDbLibFieldInt64;
function AddLong(const FieldName: string): TDbLibFieldLong;
end;
TDbLibPersistent = class(TDbLibObject, IExtendedPersistence)
private
FObjId: Longword;
FUpdCount: integer;
strict protected
// Implements:: IExtendedPersistence
procedure ObjectTo(const Writer: TDbLibWriter);
procedure ObjectFrom(const Reader: TDbLibReader);
procedure ObjectFromStream(const Stream: TStream; const Disposable: boolean);
function ObjectToStream: TStream; overload;
procedure ObjectToStream(const Stream: TStream); overload;
procedure ObjectFromData(const Binary: TDbLibBuffer; const Disposable: boolean);
function ObjectToData: TDbLibBuffer; overload;
procedure ObjectToData(const Binary: TDbLibBuffer); overload;
procedure ObjectFromFile(const Filename: string);
procedure ObjectToFile(const Filename: string);
protected
procedure BeforeUpdate; virtual;
procedure AfterUpdate; virtual;
strict protected
// Persistency Read/Write methods
procedure BeforeReadObject; virtual;
procedure AfterReadObject; virtual;
procedure BeforeWriteObject; virtual;
procedure AfterWriteObject; virtual;
procedure WriteObject(const Writer: TDbLibWriter); virtual;
procedure ReadObject(const Reader: TDbLibReader); virtual;
strict protected
// Standard persistence
function ObjectHasData: boolean; virtual;
procedure ReadObjBin(Stream: TStream); virtual;
procedure WriteObjBin(Stream: TStream); virtual;
procedure DefineProperties(Filer: TFiler); override;
public
property UpdateCount: integer read FUpdCount;
procedure Assign(Source: TPersistent); override;
function ObjectIdentifier: longword;
function BeginUpdate: boolean;
procedure EndUpdate;
class function classIdentifier: longword;
constructor Create; override;
end;
[ComponentPlatformsAttribute(CNT_ALL_PLATFORMS)]
TDbLibRecordField = class(TDbLibBufferMemory)
private
FName: string;
FNameHash: Int64;
FOnRead: TNotifyEvent;
FOnWrite: TNotifyEvent;
FOnRelease: TNotifyEvent;
procedure SetRecordName(NewName: string);
protected
function GetDisplayName: string; virtual;
procedure BeforeReadObject; override;
procedure ReadObject(Reader:TReader); override;
procedure WriteObject(Writer:TWriter); override;
procedure DoReleaseData; override;
protected
procedure SignalWrite;
procedure SignalRead;
procedure SignalRelease;
public
function AsString: string; virtual;abstract;
property DisplayName: string read GetDisplayName;
property FieldSignature:Int64 read FNameHash;
published
property OnValueRead: TNotifyEvent read FOnRead write FOnRead;
property OnValueWrite: TNotifyEvent read FOnWrite write FOnWrite;
property OnValueRelease: TNotifyEvent read FOnRelease write FOnRelease;
property FieldName: string read FName write SetRecordName;
end;
TDbLibFieldboolean = class(TDbLibRecordField)
private
function GetValue: boolean;
procedure SetValue(const NewValue: boolean);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value: boolean read GetValue write SetValue;
end;
TDbLibFieldbyte = class(TDbLibRecordField)
private
function GetValue:byte;
procedure SetValue(const NewValue:byte);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:byte read GetValue write SetValue;
end;
TDbLibFieldCurrency = class(TDbLibRecordField)
private
function GetValue:Currency;
procedure SetValue(const NewValue:Currency);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:Currency read GetValue write SetValue;
end;
TDbLibFieldData = class(TDbLibRecordField)
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
end;
TDbLibFieldDateTime = class(TDbLibRecordField)
private
function GetValue:TDateTime;
procedure SetValue(const NewValue:TDateTime);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:TDateTime read GetValue write SetValue;
end;
TDbLibFieldDouble = class(TDbLibRecordField)
private
function GetValue:Double;
procedure SetValue(const NewValue:Double);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:Double read GetValue write SetValue;
end;
TDbLibFieldGUID = class(TDbLibRecordField)
private
function GetValue:TGUID;
procedure SetValue(const NewValue:TGUID);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:TGUID read GetValue write SetValue;
end;
TDbLibFieldInteger = class(TDbLibRecordField)
private
function GetValue: integer;
procedure SetValue(const NewValue:integer);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:integer read GetValue write SetValue;
end;
TDbLibFieldInt64 = class(TDbLibRecordField)
private
function GetValue:Int64;
procedure SetValue(const NewValue:Int64);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value:Int64 read GetValue write SetValue;
end;
TDbLibFieldString = class(TDbLibRecordField)
private
FLength: integer;
FExplicit: boolean;
function GetValue: string;
procedure SetValue(NewValue: string);
procedure SetFieldLength(Value:integer);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
constructor Create(AOwner: TComponent); override;
published
property Value: string read GetValue write SetValue;
property Length: integer read FLength write SetFieldLength;
property Explicit: boolean read FExplicit write FExplicit;
end;
TDbLibFieldLong = class(TDbLibRecordField)
private
function GetValue:Longword;
procedure SetValue(const NewValue:Longword);
protected
function GetDisplayName: string; override;
public
function AsString: string; override;
published
property Value: Longword read GetValue write SetValue;
end;
TDbLibCustomRecord = class(TComponent, IDbLibFields, IStreamPersist)
strict private
FObjects: TObjectList;
strict protected
function GetItem(const Index:integer): TDbLibRecordField;
procedure SetItem(const Index: integer; const Value: TDbLibRecordField);
function GetField(const FieldName: string): TDbLibRecordField;
procedure SetField(const FieldName: string; const Value: TDbLibRecordField);
function GetCount: integer;
property Fields[const FieldName: string]: TDbLibRecordField read GetField write SetField;
property Items[const Index: integer]: TDbLibRecordField read GetItem write SetItem;
property Count: integer read GetCount;
public
function Add(const FieldName: string; const Fieldclass: TDbLibRecordFieldclass): TDbLibRecordField;
function Addinteger(const FieldName: string): TDbLibFieldInteger;
function AddStr(const FieldName: string): TDbLibFieldString;
function Addbyte(const FieldName: string): TDbLibFieldbyte;
function AddBool(const FieldName: string): TDbLibFieldboolean;
function AddCurrency(const FieldName: string): TDbLibFieldCurrency;
function AddData(const FieldName: string): TDbLibFieldData;
function AddDateTime(const FieldName: string): TDbLibFieldDateTime;
function AddDouble(const FieldName: string): TDbLibFieldDouble;
function AddGUID(const FieldName: string): TDbLibFieldGUID;
function AddInt64(const FieldName: string): TDbLibFieldInt64;
function AddLong(const FieldName: string): TDbLibFieldLong;
procedure WriteInt(const FieldName: string;const Value: integer);
procedure WriteStr(const FieldName: string;const Value: string);
procedure Writebyte(const FieldName: string;const Value: byte);
procedure WriteBool(const FieldName: string;const Value: boolean);
procedure WriteCurrency(const FieldName: string;const Value: currency);
procedure WriteData(const FieldName: string;const Value: TStream);
procedure WriteDateTime(const FieldName: string;const Value: TDateTime);
procedure WriteDouble(const FieldName: string;const Value: double);
procedure WriteGUID(const FieldName: string;const Value: TGUID);
procedure WriteInt64(const FieldName: string; const Value: int64);
procedure WriteLong(const FieldName: string; const Value: longword);
procedure Clear; virtual;
procedure Assign(source: TPersistent); override;
function ToStream: TStream; virtual;
function ToBuffer: TDbLibBuffer; virtual;
procedure FromStream(const Stream: TStream; const Disposable: boolean = true);
// Implements:: IStreamPersist
procedure LoadFromStream(Stream: TStream); virtual;
procedure SaveToStream(Stream: TStream); virtual;
function IndexOf(FieldName: string): integer;
function ObjectOf(FieldName: string): TDbLibRecordField;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
[ComponentPlatformsAttribute(CNT_ALL_PLATFORMS)]
TDbLibRecord = class(TDbLibCustomRecord)
public
property Fields;
property Items;
property Count;
end;
TDbLibTable = class(TDbLibPersistent)
strict private
FName: string;
FParent: TDbLibMetaData;
FPrototype: TDbLibRecord;
FFieldDefs: IDbLibFields;
strict protected
procedure BeforeReadObject; override;
procedure WriteObject(const Writer: TDbLibWriter); override;
procedure ReadObject(const Reader: TDbLibReader); override;
public
constructor Create(const MetaData: TDbLibMetaData); reintroduce; virtual;
destructor Destroy; override;
published
property Parent: TDbLibMetaData read FParent;
property FieldDefs: IDbLibFields read FFieldDefs;
property TableName: string read FName write FName;
end;
TDbLibMetaData = class(TDbLibPersistent, IDbLibTables)
strict private
[Weak]
FParent: TDbLibDatabase;
FDbName: string;
FTables: TObjectList;
function GetTable(index: integer): TDbLibTable;
function GetTableCount: integer;
function AddTable(TableName: string): TDbLibTable;
strict
protected
procedure SetDatabaseName(NewName: string);
procedure BeforeReadObject; override;
procedure WriteObject(const Writer: TDbLibWriter); override;
procedure ReadObject(const Reader: TDbLibReader); override;
public
property Database: TDbLibDatabase read FParent;
property DatabaseName: string read FDbName write SetDatabaseName;
property Tables[index: integer]: TDbLibTable read GetTable; default;
property TableCount: integer read GetTableCount;
function GetTableByName(TableName: string; var Table: TDbLibTable): boolean;
constructor Create(const Database: TDbLibDatabase) ; reintroduce; virtual;
destructor Destroy; override;
end;
Some might not like that I made some alterations to the standard Delphi persistency system. But if you look closely at the class TDbLibPersistent you will see that it makes it easier to handle hosted data. You have methods like BeforeRead() and BeforeWrite() that makes house-keeping a lot easier.
With the metadata out of the way, lets have a peek at the actual database class. Or should I say, the sequence persistency layer, because at the moment it has the capacity to save sequences, remember them when you re-open the file, keep track of the database name and defined tables – but we have not yet turned the metadata into physical data.
TDbLibRecordList = class(TDbLibPersistent)
strict private
FDbRecList: TList;
function GetCount: integer; inline;
function GetItem(const index: integer): longword; inline;
procedure SetItem(const index: integer; const Value: longword); inline;
strict protected
procedure BeforeReadObject; override;
procedure WriteObject(const Writer: TDbLibWriter); override;
procedure ReadObject(const Reader: TDbLibReader); override;
public
property RecordList: TList read FDbRecList;
property Items[const index: integer]: longword read GetItem write SetItem; default;
property Count: integer read GetCount;
constructor Create; override;
destructor Destroy; override;
end;
TDbLibDatabase = class(TComponent)
strict private
FHeader: TDbLibFileHeader;
FBitbuffer: TDBLibBitBuffer;
FDbFile: TDbLibBuffer;
FDbFileAccess: TDbLibPartAccess;
FDbRecList: TDbLibRecordList;
FMetaData: TDbLibMetaData;
FTableAccess: IDbLibTables;
FActive: boolean;
FFilename: string;
FAccessMode: TDbLibAccessMode;
function GetActive: boolean;
procedure SetActive(const NewActive: boolean);
function GetFileName: string;
procedure SetFileName(NewFileName: string);
function GetAccessMode: TDbLibAccessMode;
procedure SetAccessMode(const NewMode: TDbLibAccessMode);
function GetDbName: string;
procedure SetDbName(NewDbName: string);
strict protected
procedure ResetHeader;
procedure ReadHeader;
procedure WriteHeader;
public
property MetaData: TDbLibMetaData read FMetaData;
property Tables: IDbLibTables read FTableAccess;
procedure Open;
procedure Close;
procedure GrowBy(Parts: longword);
procedure ShrinkBy(Parts: longword);
function GetRecordCount: integer; inline;
function GetRecordSequence(const RecNo: integer): TDbLibSequence; inline;
function GetSequenceBits(NumberOfBits: longword; var Bits: TDbLibSequence): boolean;
procedure WriteSequence(const Sequence: TDbLibSequence; const Data: TStream); inline;
function WriteDataAsSequence(const Data: TStream; var Sequence: TDbLibSequence): boolean;
procedure MapSequence(StartPageIndex: longword; var Sequence: TDbLibSequence); overload; inline;
function MapSequence(const StartPageIndex: longword): TDbLibSequence; overload; inline;
function ReadDataFromSequence(SeqStart: longword): TStream; inline;
procedure BeforeDestruction; override;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
public
property Active: boolean read GetActive write SetActive;
property DatabaseName: string read GetDbName write SetDbName;
property Filename: string read GetFileName write SetFileName;
property AccessMode: TDbLibAccessMode read GetAccessMode write SetAccessMode;
end;
Our previous fidelity test was somewhat meager. This time we give the system a bit more to work with. So our initialization code now looks more akin to proper database work:
var
LTable: TDbLibTable;
begin
memoOut.Lines.Clear();
memoOut.Lines.BeginUpdate();
screen.Cursor := crHourGlass;
try
try
FDatabase.Filename := 'c:\temp\mydb.db'; //'::memory::';
FDatabase.AccessMode := TDbLibAccessMode.amCreate;
FDatabase.DatabaseName := 'temp';
LTable := FDatabase.Tables.AddTable('main');
LTable.FieldDefs.Addinteger('id');
LTable.FieldDefs.AddStr('name');
LTable.FieldDefs.Add('data', TDbLibFieldData);
FDatabase.Open();
finally
if FDatabase.Active then
FDatabase.Close();
end;
finally
memoOut.lines.EndUpdate();
screen.Cursor := crDefault;
end;
Fork the code luke
The latest code has been uploaded to the BitBucket repository (same as last), so simply update the fork you did earlier. Make sure you set plenty of breakpoints and also download a hex-editor and examine the resulting databasefile.
Alright! I think that is enough for the third episode. In our next episode we have more than enough to explain and explore, but now the fundamental parts are in place!
Until next time!
Jon L. Aasenden 
You must be logged in to post a comment.