I went to the 4D Summit in Atlanta, Georgia this year. I know that many developers were unable to attend this year and would like to hear more about what we learned this year. I did not take extensive notes this year, but I did jot down some key points on my iPhone throughout the summit. I'm sure 4D, Inc. will be posting more information about v12 and the 4D Summit on their website very soon. But in the mean time, I'll get the discussion started now with these comments.

Synchronization and Replication

In v12 the database engine will provide support for syncing and replication. This feature is still under development so details about implementation are not finalized. Basically you will have two new SQL commands called REPLICATE and SYNCRONIZE that you can use inside the Begin/End SQL commands. You log into a remote database and then use these commands to pull data from a remote database and put it into the local database tables, or into arrays. The 4D database engine handles all the housekeeping for you. All that is needed is to specify a primary key for a table and turn on the replication property for the table. They are trying to create a system that can easily be implemented to do auto replication, yet also provide a way to allow developers to have some fine grained control. Looks good so far -- but the devil is in the details. We'll stay tuned for more info.

Hierarchical Listbox

Combine a Listbox with a Hierarchical List and you get a Hiearchical Listbox. It's a new way of configuring a listbox so that it contains those little triangles (or boxes with a plus inside for Windows) so you can collapse or expand rows in the list box. It's hard to describe, but when you see it you say -- oh yeah, that would be useful in some situations.

Dynamic Variables

This is a big one and effects several areas. It's a feature that 4D has had and used internally for some time, and now it is being exposed to 4D developers. We all know that to compile a database, you need to declare all variables. If you need to show some info on a form, you need to use a process or inter-process variable on a form. So you need to declare that variable in the compiler definition method. So consider this. Now you create a new variable object on a form. Set the object name to "TheObject", set the object type to "Alpha", and set the object variable name to "". Yes, set the variable name to nothing. Not "tempString_t", but blank.

4D v12 will have commands that will allow you to set the value of an object by its object name. You do not need a variable name. 4D v12 will dynamically create a variable at runtime with the correct type. You can get and set the value of that variable by just using the object name. Humm... this would be very useful.

And how about throw in a command to duplicate an object on a form at runtime and set the new object's name and other properties. So you can create one text variable on a form and at runtime, and duplicate that object many times and move it around on the form as you desire. Even works with static text objects. Say goodbye to the days of creating a form with 300 objects all moved off to the side, and you have to move all the objects around and hide the ones you don't need in the "On Load" form event. Now you just duplicate the object you need, change their object names, and assign them values -- all with just the object name. No variable names required. Yes, the wheels are turning in my mind to about how I can use this feature.

Also related to this feature is listboxes that are created with a SQL SELECT statement INTO a listbox. In v11 the columns or arrays that are automatically created are not "real" arrays that developers can access. They are in fact dynamic array variables. Now you can access these listbox arrays and manipulate them.

External Database Files

It is now possible with the language to create a new .4DD and .4DB file and access it while maintaining access to the default data file. I'll describe it with an example. You create a menu item in your database called "Archive Data..." It display a dialog box to allow the user to specify what tables they want to archive records from. They click OK and in your code you do the following:

• Query the database and get a selection of records you want to export and delete from the data file.
• Create a new .4DD data file to put these records into
• Add the exported records to the new .4DD data file
• Delete the records from the current data file
• Close the new .4DD data file

Now the records have a new home in the new .4DD data file. You can open that data file at any time and access it just like any other data file with full read/write access using SQL statements. It is now possible to create a 4D application that segregates it's data into multiple .4DD data files. Now you can put that monster 48 million record table of data that never changes into it's own .4DD data file and "protect it" form the main database. Think about it.

Wakanda

I don't even want to get started with this. It is new. It is powerful. It is the future of 4D, it is hard to describe in 5 sentences. Go to http://www.wakandasoftware.com and read about it. The key thing is javascript and the automatic creation of database objects based on the defined relational database structure. You could also say web applications that utilize javascript from end to end -- on the web browser client side to the 4D server side back end. See... it's hard to describe so go read about it. s.u.

Enhanced Method Editor

It looks the same, but under the hood it's all new. The method editor can now pretty format more than just the current 4D language. In v12 it also deal with SQL. So the code inside the Begin/End SQL is now displayed with colors for table names, column names, keywords etc. And it also supports type ahead of SQL that is very intelligent. So using the tab key is now very useful inside Begin/End SQL commands.

The goal is to have the 4D method editor deal with all types of files that you use with 4D: 4D methods, XML, HTML, JSON, SQL, javascript, etc. The new method editor will pretty format all of them for you. But in v12, all you get is Begin/End SQL formatting. You'll have to wait for v13 to make use of the other formats.

PHP Support

We get a new command called "PHP Execute" that will execute a PHP function or script. The cool part is that it allows you to pass in parameters and get back parameters very easily. The PHP engine is imbedded inside 4D so it is always available -- nothing to download and install. And anybody can use it -- 4D Server, 4D Webserver, 4D Remote. So now you can go search the web for a php script that does something you need. Put a copy of that script text file into a folder near the 4D structure file and you are basically done. This does not open up some doors -- it blows the doors off the hinges and exposes a whole new world.

SQL Dump & SQL Execute Script

We get a new command that will create a SQL dump text file. I think this is a SQL standard for allowing you to create a specially formatted text file that contains data exported from a database. So now you can ask that IT manager "give me a SQL dump of all the tables in your database, I want to load that data into 4D." Does not matter if he is using MS SQL Server or MySQL. And the text files he give you, you can use to load a 4D database with just the "SQL Execute Script" command. And you can do the same for him and dump data out of 4D. I think there is more you can do with this new feature, I just don't know what that would be at the moment.

Dazu MySQL Dump

Rich Text Fields

Yes, we have waited decades -- 25 years -- for this feature. You can now specify a text field or a text variable as "rich text" and you can have bold, italic, different fonts, sizes, and colors in a text field. Think super-mini word processor capabilities. The cool thing is that all the formatting info is embedded into the text field by using html SPAN tags. Of course there is new commands and support in the language to manipulate the styled text. EVERYONE will use this new feature somewhere.

At the wrap-up session someone asked Laurent about have static rich text objects on forms. Currently v12 does not support static rich text objects, but Laurent said "it should not be too hard to do, and it is a good idea". So... maybe. :-)

Form Widgets

Think detail subforms. Now we can include a subform on a form, but the subform must be a multi-line "output" form. With v12 you can include a "detail" form on a form as a subform. Example: You create a nice little text field formatter bar with a popup for font, a popup for font size, a button or bold, italics, underline, etc. You use this to allow the user to format one of those new v12 rich text fields. Now you can include the formatter bar on other forms -- as a detail subform -- and use it to control a rich text field on the main form.

There is also support to allow you to access detail forms from a component and use them in the host database. This is what "form widgets" is all about. You can now "publish" forms from a component and use them on host database forms. YEAH!! Oh, and 4D will also provide 30-40 pre-made form widgets for us to use. This is getting closer to the object library that we have all been dreaming about.

Getters And Setters For All

You know how there is a command called BUTTON TEXT to set the text in a button, but there is no way to "get" the text of a button with the language. Well no more, now there is a "Get Button Text" command. 4D has committed to always provide a "getter" command for any "setter" command in the language. v12 will fill in the holes. Thank you, thank you, thank you 4D!!

That's the areas that got me excited about 4D v12. This is not all the new stuff coming -- just what caught my interest.

Tim

seine Ergänzungen

… I forgot to mention those 2 important changes. 4D v12 will be 64 bit for 4D Server Windows. No Mac support for 64 bit yet -- 4D is still a Carbon app on Mac OS X. They are in the process of moving to Cocoa and then Mac OS X users will have a 64 bit version -- expected with v13.

And they have overhauled the printing sub-system in 4D. Again, new under the hood but same 4D language API -- with a new addition. There is now a "Print Object" command. You specify the form and the name of the object on the form, and the position on the page to print that object. Very powerful and give developers a lot more control of building a printout.

Oh yes, you can now print listboxes on a form, and there are print variable frame type objects.

OMG how could I forget the new language, Jack. Yes, Javascript is in all our futures with 4D v13 and beyond. They did stress that 4D will support 2 languages: the "current" language and javascript. Both languages will be maintained and enhanced. The Javascript support will come from the Wakanda project and the "merging" with the 4D product line.

Julio Carneiro

I expected the new language in V12, but that was promised on V13, coming by ways of the merge with Wakanda.
Let me add that I believe their strategy with Wakanda makes a lot of sense. Create a new product, with a new language and a new way of doing things. And do that with the aim of merging that new product with 4D down the pipe.
That will allow Wakanda to run its course without the constraints of backward compatibility, or the risk of breaking existing apps. 4D will be able to test and try a lot of new technologies in Wakanda and I do welcome that. As they indicated at the summit and on private conversations with 4D people, despite being a separate product, it leverages on their existing code base (form/method editors, DB engine, web server engine, etc...). And most important for us 4D'ers, (I repeat here), merging with 4D is in the product specs. Thus we may not directly benefit from it now, but will do down the road.
Wakanda's language is javascript both on the client and server side. There was even a hint that the new method editor (V12) would be capable of handling both languages, or that the method editor in Wakanda is the same as in v12.

Tim Nevels

Yes Julio, that is how I heard it too. Wakanda is a totally new project that can go in any direction 4D wants. But Laurent is in charge of Wakanda, and his intention is to merge work from Wakanda into 4D -- and vice versa.

I also heard that the method editor is all new under the hood. You see some small changes on the surface, but the big change is in the method editor "engine" and it's new language capabilities.

I wonder if there are other text editors out there that support pretty formatting of SQL code, and are tightly integrated to the data dictionary to allow type-ahead and auto-complete of SQL language objects. The new 4D v12 method editor can.

Walt Nelson

…
But I asked myself: "What is the most important single thing that I learned at the Summit - something that is not likely to change? What lasting impression can I take away from 4D Summit 2009?"

And for me, the lasting impression is 4D Inc's long-term strategic direction to:

Embrace and Incorporate Industry-Standard Languages Into 4D

In v11, 4D officially embraced the SQL standard as an alternate data-access language within 4D.

As I understood what they presented in the keynotes at Summit 2009, they intend to continue along this strategic track, and do the following in v12:
• Further enhance 4D's support of SQL keywords (e.g. Joins);
• Focus on compatibility with industry-standard SQL reporting tools such as Crystal Reports;
• Enhance the Method Editor to include type-ahead and syntax-checking for SQL keywords;
• Add the ability to execute PHP from within 4D.

(Note: I think it would be really cool if they named Version 12 "4D SQL Server v12". Someone in a keynote referred to 4D Server as "4D SQL Server" and I really, really, REALLY liked that name.)

-----------------------

In Version 13 (or whatever they end up calling it), they plan to:
• Add Javascript as an alternate development language within 4D;
• Officially designate Javascript as 4D's long-awaited OO (Object-Oriented) language.

What This Means to Us

This strategic direction by 4D Inc. has vast implications for us. Personally, I wholeheartedly endorse this long-term strategy of embracing industry standard languages, and overlaying those languages on top of the 4D language. Don't get me wrong; I LIKE the current 4D language. In many ways, I believe that 4D's data manipulation concepts are superior to SQL. However, there are several advantages to adding the industry-standard languages to 4D. For example:
• It makes 4D more acceptable in large IT shops
• It makes building large 4D development shops easier, because we will be able to, in greater numbers, recruit developers who know nothing about 4D, but are proficient in SQL, PHP, and Javascript.
• It answers a future objection that large organizations will have, when they start using 4D more extensively: "There are not enough 4D developers." The shortage of 4D developers is a limiting factor for 4D's growth. As we move forward, this shortage will become a real issue for large accounts - in fact, it already is an issue for some large 4D accounts and some large 4D vertical market shops.

(Note: at one of the keynotes, one of the speakers mentioned that one of the primary goals of Wakanda is to attract Javascript developers to 4D.)

Speaking of Wakanda, I STILL have trouble with that name. It might be a cute name, but it tells me nothing about what the product does. If their goal, as stated, is to attract Javascript developers, then I feel that they should name the product something that clearly indicates that it is a Javascript product. For example, "Wakanda JS" or even better, "4D Javascript". (IMHO, YMMV)

The name aside, I am glad that they finally settled on the official OO language for 4D.

But back to the main point: five years from now, the 4D world will be very different. Currently, PHP and Javascript developers are only called in for 4D Web projects. However, when we have SQL, PHP, and Javascript as a part of the 4D back-end language, industry-standard language developers will be permanently on staff in 4D development shops. Many of those developers may know little or nothing about the original 4D language, but they will be productive members of 4D development teams. This is a good thing; no, this is a VERY good thing, IMHO.

Walt Nelson - Guam