Embarcadero: Firemonkey OOP
Embarcadero: Firemonkey C++
Clarification about EurekaLog and latest Delphi versions... Delphi XE2 has introduced a new visual framework - FireMonkey, as well as support for more platforms, including Win64 and OSX. There are constant income of questions about EurekaLog's future and possible support for these new technlogies. So I've decided to publish general explanation for everyone. EurekaLog and FireMonkey The answer is simple - EurekaLog will... never support FireMonkey, because there is nothing to support! FireMonkey is visual framework. But EurekaLog just don't use any visual frameworks - it don't use VCL and it certainly don't need to use FireMonkey. EurekaLog uses API for all visual UI. That's why you already can use EurekaLog with both VCL and FireMonkey applications. Of course, if you want to create your own custom error dialogs for EurekaLog or something like that - fine, use API, VCL, FireMonkey or whatever technology else. There is no limitations. However, EurekaLog is not related to VCL or FireMonkey. It's just exception tracer. EurekaLog and Win64 Sorry, but EurekaLog 6 will never support Win64. It was written without considering other platforms in mind. However, there are good news: EurekaLog 7 will support Win64. Right now we're working on it, even though it dind't appear in any public releases. Support for Win64 is our current top priority! It's expected that Win64 support will be released (as beta) after we ship stable release of EurekaLog 7. You can help this to happen sooner by testing EurekaLog. Preleminary estimate is that Win64 support will be basic for first few releases and then we'll add advanced features (like disassembler view). Another good news is that we want to make migration process as painless as possible. Ideally you should be able to install EurekaLog 7, open your old project, recompile it - and it should work. EurekaLog and OSX The case with OSX support is very similar to Win64. EurekaLog 6 is out of question, but support for OSX is planned for EurekaLog 7. This is our second top-priority. We want to finish Win64 first and then start going for OSX. Currently, there was no work done for OSX, but all current work is done with future OSX target in mind. EurekaLog and... Lazarus/MSVS C++ Yes, there is slight possibility for appearing EurekaLog for other IDEs like Lazarus or Microsoft Visual Studio (C++). However, currently this is considered as low-priority in far-far away future. Note: this information is highly preliminary and is suject to change. Also, there is no estimates available.Read More
Op maandag 13 februari 2012 zal Bob Swart van 13:00 tot 17:00 een Delphi XE2 iOS Development seminar houden in 't Brandpunt in Helmond Brandevoort, zie http://event.bobswart.nl voor details.Read More
LiveBindings, which were introduced in Delphi XE2, provide developers with new options for associating objects. And they are only one of a wealth of new features introduced in this groundbreaking version of Delphi. They are also a source of some confusion. One of the problems is that most of the demonstrations of LiveBindings are simple, in part because LiveBindings are so new. Another way to put this is that it's hard to think differently about object binding when we are so familiar with Delphi's existing mechanisms. As a result, most examples that I've seen so far duplicate much of what we already achieve in Delphi.But this is bound to change. I believe that once we start to see creative applications of LiveBindings, we, the collective Delphi community, will begin to think about them differently. I hope to jump start this process by collecting examples of LiveBindings that represent the way that we'll be using them in the future, and I'll publish these here. Of course, I'll give credit if you contribute so that you can bask in the gratitude of your fellow Delphi developers.So, here is my question. Do you have examples of LiveBindings that go beyond the obvious? Alternatively, have you seen an example that breaks the mold? Is so, please share. And, in case you haven't given much thought to LiveBindings, here is a short introduction.LiveBindingsLiveBindings is a general term for Delphi's new object/property binding mechanism first introduced in RAD Studio XE2. It is the only binding mechanism available to the new FireMonkey cross-platform component library (FMX), and is also available for traditional visual component library (VCL) components.At its core, LiveBindings is a mechanism for creating associations between objects and expressions. Expressions are strings that are evaluated by Delphi's new expression engine, and in the case of LiveBindings, they define what effect the expression will have on an object.While expressions are strings, they are evaluated by the expression engine at runtime, which is quite a bit different than your Delphi code, which is compiled by Delphi's compiler at compile time. As a result, expressions are different from other string types you normally encounter in Delphi code. For one thing, expression strings can define literal values using either single quotes or double quotes. In addition, the expression engine recognizes special methods that have been registered with it through Delphi's Open Tools API (OTA), and can employ custom output converters to transform data from one type to another. Another concept critical to LiveBindings is scope. In LiveBindings terminology, scope defines what is visible to the expression engine. Most LiveBindings require a control component (the object to which the expression will be applied), and in most cases a source component as well. In the case of these LiveBindings components, the control and source components are both in scope, making their properties available to the expression engine. Similarly, those custom methods that have been registered with Delphi from a design time package are also in scope, making those methods callable from your expressions.It's worth noting that while LiveBindings use expressions, expressions can be used without LiveBindings. Specifically, you can create a scope programmatically, adding to it the objects and methods you want the expression engine to evaluate, and then ask the expression engine to perform the evaluation, returning a value based on the expression string. It's an important point, as far as the expression engine is concerned, but not something that you necessarily need to think about when you are using the LiveBindings components.Do We Need LiveBindings?I recently spoke about LiveBindings during the "24 Hours of Delphi" broadcast with David Intersimone. One of the listeners asked a question about LiveBindings that I hear pretty often, though he gave a somewhat new twist. "Why do we need LiveBindings?" he asked. "After all, it appears that LiveBindings is just another way of doing what we already do using event handlers. It kind of seems like fishing poles. In older days we had cane fishing poles, and they worked just fine. The new fiberglass and graphite rods are nice, but they don't really do more than the old rods."I like the analogy a lot, because it actually highlights why LiveBindings are a positive thing. Let's take the fishing pole example. A recent television show on The History Channel called "101 Gadgets that Have Changed the World," the publishers of the magazine Popular Mechanics list the top 101 devices that have had a dramatic impact on our daily lives. And, guess what, fiberglass fishing poles made the list (at 100), beating out duct tape and being edged out by the stapler.In any case, the point is that while cane poles and fiberglass fishing rods perform the same task, they work differently, and fiberglass rods are functionally better on every level.I think we are going to be saying the same thing about LiveBindings, once we get our heads around them. Yes, you can do many things with LiveBindings that can be achieved without them, but as we get more familiar with their capabilities, I believe we will discover a whole range of features that are enabled only through LiveBindings.So, let me hear from you. Post a link to your example, or an example that you find on the Web, as a comment to this posting.Read More
Bookstores are Cool
I love bookstores. A lot of people love bookstores. I love hanging around in a bookstore and seeing what is new, what is popular, and what is available. I love seeing the cool games and other non-book stuff they ha… … Read More
The first edition (almost 250 pages) of my Delphi XE2 DataSnap Development courseware manual has been released, and sent to all customers of my previous Delphi XE DataSnap Development courseware manual (which is now "frozen" at the 4th and final edition).Read More
My first iPhone app (the "Game of Memory" written with Delphi XE2 and FireMonkey) is now available in the AppStore (for free), see http://itunes.apple.com/us/app/game-of-memory/id489076335?ls=1&mt=8 It was quite a journey from "start" to actual AppStore deployment, but fortunately, I now know all the steps, so from now on it will hopefully be easier (although probably not faster).Read More
If you missed CodeRage 6, or you didn’t get to every session that you wanted to see (hear?), it is now all online. That link also points to the latest offers and ways to find out more about XE2. I love XE2, and think it’s the best Delphi ever. And I say that not even using the FireMonkey/cross-platform stuff – so it’s even better than I think. I was digging around in my boxes in the basement – we’ve moved a ton, and so I’ve got stuff scattered all over – and came across a CD labeled “Website”. I opened it up, and lo and behold, there was a copy of one of my very first web sites, built with NetObjects Fusion. It was fun to poke around and see some of my really old content. (As a point of reference, the homepage has “This site was last updated on Tuesday, December 18, 2001” at the bottom. Remember when we used to do that?) Actually, I think some of the stuff will end up on my current site. Not all the links work, but if you’ve been around a while, you might remember some of it. Most of it was hand-maintained, but you can see where I tried to integrate in some early Delphi-based CGI stuff. I actually still like the colors and the template. The Generics.Default.pas unit is an interesting one – you may never have cause to use it directly, but it contains a lot of interesting stuff in support of the classes in Generics.Collections.pas. It’s worth poking around in. I was doing just that, and came across some interesting code – a function called (and I quote) BobJenkinsHash. It is used rather extensively throughout the unit, and appears to be a general purpose hashing code. Who is Bob Jenkins, you may ask? Well, apparently he’s a guy that wrote a very powerful and useful hash function, and Embarcadero has utilized it as part of their generics library. And here’s the interesting part – they created it using a set of GOTO(!!) statements whose use , well -- I seriously can’t believe I’m actually saying this – actually kind of make sense. The C code depends on the “fall through” nature of C’s switch statement, and the GOTO calls actually mimic that rather nicely. I’m open to suggestions on how it might have been written better. (Again – I can’t believe I just said that, but there it is.) And to redeem myself, I’ll chastise the author for not defining his interfaces in their own unit. (Sorry, Barry – I had to do something to restore my street cred for actually liking the way the GOTO’s worked…..) Anyway, interesting little find in the bowels of the Delphi RTL. I’ve added a new category, Three Sentence Movie Reviews. I watch a lot of movies, and have all these aspirations of writing up movie reviews when I watch, but I never do because it takes too long. So I thought I’d simply limit myself to three sentences in reviewing the film, and that way I might actually get the review done. I might have to get a bit creative – sort of like keeping tweets to under 140 characters. Should be fun. If you read this blog via DelphiFeeds, you won’t see it as I’ll not be putting the Delphi category tag on them. Just another reason to subscribe to my real feed.Read More
Recently there have been several threads and discussions about separating GUI and business logic. Of course that is nothing new, the MVC or MVP patterns are widely known. There is just one problem especially with these two patterns: the dependency betw… … Read More
Wherein I discuss how to do things that you should be doing and how not to do things that you shouldn’t be doing….
Sometimes you tweet something and it makes sense to you, but then you realize that it also kind of begs for more discussion.
I thought that a little more explanation would be in order. Let’s say you have ten cool features on your “Things Customers are Screaming For” list. There are two basic approaches you can take to getting them done: You can do them in series or in parallel. If you do them in parallel, you’ll get them all done sooner, but you may not get them done as thoroughly. If you do them in series, it will take you longer to do them all, but you’ll likely get each one done more thoroughly.
However, doing them in series – that is, sequentially doing only the most important remaining item – has an added benefit: It can help you not do things that you shouldn’t do. You may have ten things on your “We need to get these done right away”, but as time passes, some of those things may prove to be not needed, overtaken by events, or just plain dumb ideas. Doing things in parallel may mean that you get everything done sooner, but it also means that you might do something that proves to be a waste of time later on.
For example, if you have a team of five folks, and you have five ideas that take six man months each, you might give each person one idea to work on, and then six months later, you have all five ideas done. Great! But uh oh! — as it turns out, over the course of those six months, things changed and events transpired in such a way that two of the ideas weren’t really good ideas after all, and at the end of the six months you regret ever starting on them. So in the end, you have three things done that needed doing, but have wasted your time on two ideas that you should have left undone. Furthermore, since you only had one person working on each idea, you may not get a fully fleshed out solution, but instead, one that may have missing features or is not complete in some way.
But consider what happens if you work on them in series: say that instead of starting in all at once on the entire list, you pick the single most important of the ideas on the list. You focus your whole team on doing that one idea. You will likely be able to get it done somewhat sooner, say in one or two months instead of the six months in our example. (Five team members working on a six man-month project will likely take a bit longer because of transaction costs.) In addition, you will get a “five-headed” solution instead of a “one-headed” one, and thus the solution would likely be more complete, fleshed out, and feature rich. In other words, you might very well end up doing one thing properly and thoroughly instead of doing five things not so completely.
The added benefit comes when, after doing the most important project, you realize that one of the ideas you had originally thought was awesome isn’t really that awesome, and that you can take it off the list and not waste time on it. You might add another item to the list, or another item that was on the list suddenly becomes vastly more important than it was at the start of the first project. Instead, you can repeat the process and start working on the next most important thing. You end up with a very nice implementation of each project you do undertake, and you don’t do the projects that shouldn’t be done.
In a rapidly changing technical environment, that which looks like a no brainer in January might be old news by July. Obviously you want to avoid working on that project. A practical example might be that you are a software tools vendor, and people are pressing you to do, say, a development tool for Windows Mobile 6. You could choose to add staff and get that request done sooner, or you could stay the course and do more important things, only to discover with massive relief that you didn’t do Windows Mobile 6 at all when Windows Mobile 6 becomes a legacy technology. (Sound familiar? )
Now, I’ll grant that if you follow this plan, you’ll end up with fewer features in the long run. But you’ll also end up with more complete features with less wasted effort. You won’t have spent time on things you ultimately should not have. It might take a little longer to get any particular feature to market, but in the above example, you’ll end up with three really solid features and no time spent working on things that you should not have worked on at all instead of five half-baked features, two of which were a waste of time.
Repeat this process enough, and it becomes much more likely that you will end up with a product that has the right – and fully rendered — feature set. In many ways, inefficiencies are the result of choosing to do the wrong thing. If you keep your choices finely grained – that is, always put your efforts only into the things that are obviously the very most important thing to do do right now – you will end up doing the right thing every time, even if there is slightly less of it.
It’s often been said that knowing what you should do is easy; it’s knowing what you shouldn’t do that’s hard. If you repeatedly focus on and complete the one single thing you absolutely should do and do it well, it will be more readily clear what those things are you should not do. So, I guess ultimately, you have to choose: More features done less thoroughly with time spent on things that turn out to be a waste, or fewer, more complete features with fewer projects that you shouldn’t have done.
The BE Delphi Developer Day last week (November 17th) in Edegem, Belgium was a big succes, and so was my session on Delphi XE2 DataSnap FireMonkey Clients for Windows and Mac OS X, for which you can now download the slides and source code.Read More
Yesterday, I've released the 4th and last edition of the 202-page Delphi XE DataSnap Development Essentials in PDF format from http://www.eBob42.com/courseware - see the Table of Contents for more details.Read More
The following is also documented in my upcoming Delphi XE2 DataSnap book, but I want to share it with all Delphi XE2 DataSnap users already: DataSnap relies on OpenSSL for the encryption of the keys in the RSA + PC1 filter combination; which requires some manual assembly for 64-bit applications.Read More
Thanks to everyone who attended this session at AnDevCon II in San Francisco and Dessert Code Camp in Phoenix. Here are the updated slides (a PDF) and code samples from this session. Please leave a comment if you have any questions and I’d be happy to?clarify?things, or point you in the right direction. You can also get the HTTP Telnet script I used in that session.Read More
A suggestion for self-curating the Delphi content on Google+! Why? Because although we all are lovable developers, we can only handle that many photos, reshares and caturday gifs!Using Google+ allows us to have a unified comment system, and a loosely coupled Delphi community where you can actually pick and chose among who you want to follow.Here is how:Step 1: Create your Google+ Delphi Page. With Google+ adding pages, we now can self-curate our content. This means that each of us can create our own Delphi page, which can be used to promote our blog posts, or our Delphi musings directly in the page stream. Note that we would need to refrain from posting caturday gifs, or reshares of the events of all world+dog on our Delphi page.Step 2: From your Delphi Page, Follow the Delphi User Group and/or Firemonkey User Group pages This will make your page visible to other Delphi users, assuming you also complete step 3.Step 3: Ensure that you show in public on your Delphi page profile that you follow the page(s) above. This because a Google+ page will NOT show you as a follower, unless you follow it in public. Step 4: Pick the pages and/or users you want to follow from the User Group pages. As people publicly add (i.e. follow with) their Delphi pages, the user groups will automatically grow the list of available pages and visible for all. Step 5: Enjoy a "spam free" Delphi circle!Step 6: Optionally, reshare your old personal Delphi posts on your Delphi page.The generic Delphi and Firemonkey user groups are just a start. Anybody can create their own topic-centric User Group page as well. If you want to help grow the Delphi community:Create your own Delphi page, and follow the User Groups!Read More
If you are a Delphi developer you likely already know that Embarcadero recently released this year’s Delphi update called Delphi XE2. Delphi XE2 comes with support for 64-bit systems and with multi-platform capabilities. We just released an updated version of our logging tool SmartInspect that supports Delphi XE2 for Windows and Windows 64-bit systems. Please note that we don’t currently have plans to support SmartInspect for Delphi for Mac OS X and other cross platform targets. As the SmartInspect logging library for Delphi makes heavy use of the Windows APIs for performance reasons, we first want to wait on how popular the Delphi cross platform capabilities will become. If Delphi for Mac OS X becomes more popular we will certainly consider supporting this environment as well. If you are a registered customer you can download the new version from our customer portal. You can also download the updated trial version to try SmartInspect for free. Just let us know in case you have any questions or feedback about the new version.Read More