• Embarcadero Software, the company behind the Delphi RAD Studio multiplatform development system, published their 2015 Roadmap for RAD Studio.

    RAD Studio is a complete development environment for building cross-platform apps where you can use the same source code base to build native executables for Windows, OS X, iOS, and Android. It supports two languages, ObjectPascal and C++(11).

    Here are a few highlights of things to come this year:

    • new 64-bit compilation for iOS, now required by Apple in addition to 32-bit executables (as “universal” binaries)
    • new 32-bit C++ (11) compiler for Windows.
    • Enhanced, more stable IDE with support for a large memory model
    • Major enhancements to FireUI multi-device designer, including multiple device previews
    • Full support for Windows 10, both VCL and FMX
    • Support for 4K monitors
    • Native HTTP(S) client libraries on all platforms (no longer dependent on Indy!)
    • Enhancements to VCL and FMX/FireMonkey
    • Enhancements to Enterprise Mobility Solution (EMS) including Push Notifications and additional extensions
    • Support for the latest additions to Android and iOS releases
    • 64-bit toolchain for OS X

    For more details, click here to visit their announcement page.

  • I was talking to a software consultant earlier this evening and he said he advises his clients to approach a mobile first development strategy for software these days. I asked him to elaborate on this a bit.

    He basically said that for years, people who wanted to create custom software apps for their business would build desktop apps. Lately, as mobile devices and smart phones have been taking over the world, these apps are extended into the mobile realm.

    But now the focus of this advice has shifted: if you’re developing a custom piece of software for your business, people “in the know” are now recommending that the apps target mobile platforms first. Then as needed, a desktop version can be created later.

    If you’re using Delphi XE7 or later, this whole conversation is irrelevant. Here’s why.

    Read more…

    Tags: , , , ,

  • In the previous post, we examined four traditional ways of initializing objects such as forms in Delphi. There are two more approaches we’ll examine that aren’t used as much but result in much less coupling than the others: initialization methods, and call-backs. In this installment we’ll look at the former, and in the next we’ll look at the latter.

    Remember that we’re discussing how to initialize objects here, including forms. It’s not always the case that you have data available in an easily accessible database table, so we’re doing this manually, which is not all that uncommon. In fact, I maintained a rather large application a while back that used a NOSQL database where we had to do the data queries outside the forms and pump all of the data into and out of the forms exactly like this, which is where I got the inspiration for this series of articles. In that code, I found virtually all of these approaches used to interact with their forms; there was not a lot of consistency throughout the project. (Actually, this is all leading somewhere inasmuch as I hope to present a simplified way of interacting with forms that can reduce the amount of “plumbing” code required to get data in and out of them.)

    Read more…

    Tags: ,

  • In the last post we started discussing selection forms and I stopped at the point where we were encountered a dilemma: the form is constructed with the form.Create() method but there’s data that’s not loaded into it yet. So how do you get the data into the form?

    I’d like to take a slight detour for a minute and discuss something called dependency injection.  Wikipedia defines dependency injection thusly:

    Dependency injection is a software design pattern in which one or more dependencies (or services) are injected, or passed by reference, into a dependent object (or client) and are made part of the client’s state.

    Any time you need to pass data into an object, it represents this design pattern. Some folks might quibble about whether the dependencies can only be “services”, or whether they need to be “passed by reference”. For this discussion, it doesn’t really matter — the point is, you have some data (fields, objects, or services) that needs to be injected into the object (a TForm in this case) and it affects the state of that object. When a form opens and you want the user to be looking at a bunch of fields already populated with data to select from, that is the initial state of the form.

    So the question is, what’s the proper way of interacting with the form so it is initialized properly when the user sees it? Let’s look at our options within the context of the dependency injection pattern. Read more…

    Tags: , ,

  • This is the second part of a series I’m doing on the topic of interacting with forms in Delphi. This time we’re going to focus on a particular kind of form that I’ll call the “Selection Form”.


    There are tons of simple selection forms that we encounter on most programs today: font selectors, brush selectors, date selectors, directory and file selectors, etc. The most common ones have standardized representations that become familiar to us fairly quickly, either because they’re a standard part of the operating system, or because the app developer came up with his/her own versions. These aren’t the kinds of selection forms we’re interested in.

    The selection forms I’m talking about are used by an application when the programmer needs to find some kind of reference key for locating data for the user, often through a database lookup operation. Databases normally use integers as keys, called “IDs”, and their exact values are irrelevant. All you know is that any given ID lets you find one specific record.

    So as a programmer, when you’re presented with a situation where you need to find a database record by ID and you don’t know what it is, you … ask the user. This is typically done with a selection form. They’re also called “lookup forms”. They’re usually displayed as pop-up forms displayed modally, which means they hold the focus until you close them.

    Read more…

    Tags: ,

  • This is the first of several articles I expect to write on the topic of (programmatically) interacting with forms in Delphi. This is a look “under the hood” at some stuff that a lot of Delphi Developers take for granted. I’ll survey a variety of approaches I’ve seen in working with forms, some recommendations I’ve got, and hopefully lay the groundwork for a new way to approach dealing with forms. Along the way, we’ll also take a look at how LiveBindings can play a role in this effort as well.

    For those who don’t know, Delphi is a programming environment released in 1995 (Valentine’s Day, if I recall correctly).  I’ve been using it ever since. It supports a language called Object Pascal, and it grew out of a very popular compiler called TurboPascal, the product that launched a company known as Borland, Inc., way back in the early days of home computers (back when they still ran MS-DOS).

    (You can learn more about Delphi from the Embarcadero website.)

    In the last article I posted, I made an effort to describe what the future of programming might be like if we’re to have any kind of quantum leap in the productivity of programmers. The software industry has revolutionized virtually every other field except our own. Today we employ the same edit/compile/debug form of iterative programming that has been used for over 50 years. That has got to change. We need something that’s more designed around dropping little logic blocks on a form and connecting them with lines that represent data flows. And it must be done in a way that allows the resulting diagrams to be executable.

    Read more…

    Tags: , , , , ,

  • General 10.03.2015 No Comments

    I haven’t updated this blog in ages. But after consulting with some folks, it was decided that I should spend more time curating articles here that are more technical in nature, and use my other blog, SchwartzThink, for other stuff.

    So I’ll be moving (copying) some articles from the other blog here, then adding more here, primarily as they apply to Delphi and programming.

  • Books, Reviews 14.03.2011 No Comments

    The Millionaire Messenger by Brandon BurchardI recently got a copy of a new book by Brendon Burchard entitled, The Millionaire Messenger: Make a Difference and a Fortune Sharing Your Advice. It was published officially on March 7th, 2011, and it shot straight to the top of the Amazon and B&N sales charts (maybe others).

    I met Brendon at a conference a couple of years ago and got a copy of his book, Life’s Golden Ticket: An Inspirational Novel.  It’s a great read.  Knowing a little about Brendon’s background, I decided to jump at an offer he put out recently to pre-order a copy of his newest book at a great discount.

    Read more…

  • Most people these days use a link cloaker or redirect script or service of some kind. I use several self-hosted redirect scripts, as well as some commonly-used hosted services. Someone asked me why recently, and I thought it would be a useful topic to share with you. It’s a topic that isn’t well understood and is largely under-appreciated.


    In my mind, all of these scripts and services do the SAME THING: they let you set up one URL to REDIRECT people to another. I call them ALL “redirects”. Most offer different features and benefits, so I use several. Read more…

  • Whether you’ve heard of the Product Launch Formula or not, it’s definitely something to take a look at.

    Jeff Walker is releasing the third iteration of his Product Launch Formula shortly, and he’s in the pre-launch phase.


    The amazing thing that most people don’t realize about Jeff’s Product Launch Formula is that it’s kind of like basic math — the same principles apply regardless of what market niche you’re going after. Read more…