It looks like he started in June 2010. Worth a read, in my opinion.

One of the fun things to do with 4D is to take it apart. Long-time Mac users know how to edit an application’s resources, and sometimes you can find rather interesting artifacts in that way.

As it happens, in 4D 2003 and earlier, resource PICT ID=9000 was a picture of a dog. It is used for a QuickTime preview or something. This made me ask myself the question, “Whose dog is it, anyway?” I remember asking Someone French this question at a 4D Summit long ago, and I was interested to learn that it is (supposedly) François Marchal’s dog. It was nice to know that it was actually someone’s dog, and not just a dog from a clip art collection. I’ve always wondered about the dog’s name. Is it Buddy? Is it Rex? Anyway, the picture is a nice little Easter Egg in 4D and it made me happy to know a little bit of the story behind it. One day I decided to check 4D 2004 to see if François Marchal’s dog was still there. It wasn’t! PICT ID=9000 was no longer a picture of a dog, but instead a picture of two horses. Alors! What has happened here? Où est le chien? I miss him already! I hope he is doing OK.

So now the question is “Whose horses are they, anyway?”

I originally posted this message in 2007, in an earlier incarnation of this weblog. François Marchal was kind enough to answer in a comment:

2007-10-11 14:57:31

My Golden Retriever Ness is now an old dog, but still alive and happy. Let me introduce the horses. The grey arabian mare is my beloved horse Hassira. The black one is a “Cheval de Mérens”, he is my wife’s horse. He is now 20 years old and still in pretty good shape and ready for a ride. Those pictures are not specially an easter egg, but are used as a preview in the Quicktime dialog, to show picture transformation when using various components.

- François Marchal

If you develop in 4D on Windows, or even if you only test in 4D on Windows, eventually you’ll need to know which TCP/IP ports are open and which application opened them. Windows has a handy built-in Command-Line Interface program called netstat that does this nicely.

The problem with netstat is that doesn’t update by itself. You have to run it each time you are curious about open ports. This lack of convenience led me to search for an alternative. I was happy to discover CurrPorts. It displays the same information, but updates itself every few seconds and visually marks the changes to make them easier to see.

Here’s a comparison:

netstat works like this in the Command Prompt window:

C:\>netstat -a -n

Active Connections

  Proto  Local Address          Foreign Address        State
  TCP    0.0.0.0:25             0.0.0.0:0              LISTENING
  TCP    0.0.0.0:80             0.0.0.0:0              LISTENING
  TCP    0.0.0.0:135            0.0.0.0:0              LISTENING
  TCP    0.0.0.0:443            0.0.0.0:0              LISTENING
  TCP    0.0.0.0:445            0.0.0.0:0              LISTENING
  TCP    0.0.0.0:1026           0.0.0.0:0              LISTENING
  TCP    0.0.0.0:6646           0.0.0.0:0              LISTENING
  TCP    127.0.0.1:1031         0.0.0.0:0              LISTENING
  TCP    127.0.0.1:1056         127.0.0.1:1057         ESTABLISHED
  TCP    127.0.0.1:1057         127.0.0.1:1056         ESTABLISHED
  TCP    127.0.0.1:1059         127.0.0.1:1060         ESTABLISHED
  TCP    127.0.0.1:1060         127.0.0.1:1059         ESTABLISHED
  TCP    127.0.0.1:5152         0.0.0.0:0              LISTENING
  TCP    127.0.0.1:5152         127.0.0.1:1058         CLOSE_WAIT
  TCP    127.0.0.1:5354         0.0.0.0:0              LISTENING
  TCP    127.0.0.1:27015        0.0.0.0:0              LISTENING
  TCP    192.168.64.132:139     0.0.0.0:0              LISTENING
  UDP    0.0.0.0:445            *:*
  UDP    0.0.0.0:500            *:*
  UDP    0.0.0.0:1025           *:*
  UDP    0.0.0.0:3456           *:*
  UDP    0.0.0.0:4500           *:*
  UDP    127.0.0.1:123          *:*
  UDP    127.0.0.1:1044         *:*
  UDP    127.0.0.1:1900         *:*
  UDP    192.168.64.132:123     *:*
  UDP    192.168.64.132:137     *:*
  UDP    192.168.64.132:138     *:*
  UDP    192.168.64.132:1900    *:*
  UDP    192.168.64.132:5353    *:*
  UDP    192.168.64.132:6646    *:*

C:\>

Addresses (0.0.0.0 means listening as a server), ports, and the state of the TCP/IP connection are indicated clearly. However, if you want to see them again, you have to run netstat again — and you’re responsible for noticing what changed since the last time you ran it. Useful to a point, but tedious in practice.

CurrPorts opens its own window, and presents all the same information available in netstat — but in a beautiful, compact, self-updating display. And, to add some extra-nice value, it can log its output in several different formats for later debugging.

CurrPorts is much nicer than netstat as a visual tool!

CurrPorts is the work of Nir Sofer, an old school hacker who very generously publishes several excellent utilities for free under his company name NirSoft. Judging from his blog he’s a helpful, intelligent fellow. Thank you, Nir, for publishing CurrPorts!

If you develop in 4D, eventually you’ll have to work with TCP/IP. And, even if you’re a fanatical Mac user, you’ll have to test on Windows. CurrPorts makes that a more pleasant experience. I use and recommend it!

In July 1994 I flew down from Anchorage to attend the annual 4D DEVCON 1994 at the Fairmont Hotel in San Jose. It was the first I’d ever attended in person. I was awe-struck by Silicon Valley and star-struck by all the 4D Luminaries and Personalities. For me, it might as well have been another world.

I took 48 pages of hand-written notes over the course of the event. They are a little time capsule of what was and wasn’t important at the time. They make for an interesting artifact.

4D DEVCON 1994 Notes

That year the big news was 4D Universal, which was to place 4D squarely in the technology mainstream on Mac OS, Windows, and UNIX. ACI’s write-once, run anywhere platform pre-dated Sun’s Java by 18 months (though what we saw was definitely a demonstration and not a shipping product). It was very impressive to see three monitors, three keyboards, and three projectors on stage. Laurènt started 4D Server on UNIX running on a SUN Sparc 5 and issued queries from both Mac OS and Windows. That was trippy stuff in pre-web 1994!

One highlight for me was the Advanced Class from Jean-Pierre Ribreau, the famous JPR. In class we learned all sorts of internals about 4D, intricacies of Externals, and how to improve performance. You can see in the notes that my American ears didn’t hear his name correctly, and I likened him to Jacques Cousteau. I hope he’ll forgive me.

They keynote was full of people I knew only by name: MDD, Mark Vernon, and Laurent Ribardière. I wrote “nil” as my notes for MDD; I hope she will overlook that! Mark Vernon presented sales statistics: 12,000 servers and 50,000 users. In addition to his 4D Universal demonstration, Laurent showed performance statistics for 4D on PowerPC hardware, which was relatively new at the time.

4D Chart and 4D Compiler 2.2 were the new add-on products that year. 4D Compiler was US $1000, a price that made my head spin, but I bought it anyway. It was pure guilt: I had cracked the compiler’s copy-protection a year before and had been using it daily so I came clean with my licensed copy.

At the vendor area I bought Walt Nelson’s 4D for Fun and Profit and had him sign it. I also bought Garri Ogata’s 4D Command Reference Cards. I saw many other interesting third-party products and enjoyed them all.

The best part of the conference for me was the lobby of the Fairmont. It was the unofficial place to be. Well-known developers held court, and not-so-well-known developers like me hung on their every word. I met in person those I had known only on the CompuServe Forum. It was a very wonderful experience.

In the early 1990s Natural Intelligence was one of the premiere 4th Dimension development consultancies. Founded in Cambridge, Massachusetts by Joshua Wachs and staffed by luminaries including Hillel Cooperman and Aparajita Fishman, NI produced the most advanced and well-known 4D tools of the time: Easy4D, QuickCode Pro, and ObjectTools.

At DEVCON 1994, my first, I met Josh. NI was growing, and he was actively recruiting. I took him up on an offer of an interview, and as a prerequisite I received the famous Natural Intelligence 4th Dimension Proficiency Test.

True to the pre-Internet technology of the day, I received the test by Fax. It is now old and yellowed, but still legible after 16 years. It contains details reflective of NI: beautiful typography, careful layout, formal but respectful language, and technical excellence.

Natural Intelligence Fax

I was enamored of NI, and wanted that interview. I carefully built my response in kind with what I knew then as beautiful typography, a careful layout, formal but respectful language, and the best 4D code I knew how to write. It’s interesting how much things have changed and how much they haven’t.

Natural Intelligence 4D Proficiency Test

Based on my response, I did get an interview with NI. It was a long flight from Anchorage to Boston followed by an exciting and exhausting all-day interview with more people than I could count. An offer followed the next week, which I fitfully considered and eventually turned down in favor of another from Apple. I recall finally connecting with Josh by telephone at his booth on the floor of MacWorld Boston to tell him my decision. It was a tough choice.

In the later 1990s NI applied their amazing talents to the up-and-coming Java platform. They produced the first Mac-based Java IDE, which they called Roaster. It included a Java JVM they had written, even more insanely difficult to do then than today. It reflected their technical greatness. They also produced a news website, Intelligence.com.

In 1999 NI was sold to Circle.com and evaporated into the Internet Bubble of the early 2000s. Hillel Cooperman moved on to achieve further greatness at Microsoft’s Macintosh Business Unit and lately with Jackson Fish Market. Aparajita Fishman remains a highly-regarded 4D Developer and publisher of Active4D. Joshua Wachs is changing the world of online activism at Echo Ditto.

Life might have turned out very differently for me had I accepted Josh’s offer; the Natural Intelligence 4D Proficiency Test remains an interesting memento of that decision.

For better or worse, the 4D iNUG Tech Mailing List — the NUG — is the main conversation for 4D Development. It’s where we all talk to each other, all the time.

There are a few places where the NUG’s messages are posted in web page form. GMane is my favorite. It includes a graph of Messages per day since it started tracking the NUG back in 2005.

Lately I noticed a trend. An uptick. We’re talking more.

Where the messages per day had been on a long slow decline since 2005, in late 2008 there was an inflection point. The number of messages per day increased. It’s a subtle but significant turnaround! That trend appears to continue.

I attribute the uptick to improved developer confidence. In late 2008 4D Server v11 was shown publicly at the 4D Summit. Since then, 4D v11 has improved in stability and reliability from version 11.3 through version 11.6. As well, significant vendor projects have appeared or improved: Wakanda, 4D for Flex, 4D Pop, 4D SVG, and the 4D Knowledgebase. The third party market reflects this same trend; significant products have also appeared since then.

Lest I appear too much a shill, I will recognize that there have been some negative events in the platform, mostly minor (but still aggravating). But, nothing speaks like numbers: look at that graph and decide for yourself. Like a stock price that anticipates the confidence of the market, our GMane graph shows it: 4D is on an uptick!

One of my favorite bits of 4D Memorabilia is my Signed 4D v3 Key Disk.

Key… disk? What is this, you might ask? Children, gather ’round and learn of the great mystery of a key disk and of the night when mine was signed by its author in the exotic surroundings of an Egyptian temple.

In the mists of the time before the Internet, before all computer activity could be registered and monitored online, there was a problem: how do you keep people from accidentally using too many copies of non-open-source software?

Computers of that epoch had an interesting and primitive portable storage medium called the floppy disk. These were much like a USB flash drive but with much, much smaller capacity — on the order of 0.001 gigabytes per device.

Typically, a software application would be distributed on a collection of these floppy disks. If the application was small, it might fit on one floppy disk which the user would use directly when they wanted to run that application. If the application was large, the user would install on their internal hard disk by starting a program on the first floppy disk, and then insert the rest in the series as prompted. This would place the entire application and its supporting files on the internal hard disk. For example, the Microsoft Office of that time was distributed on a collection of over 40 individual floppy disks — even 4th Dimension had 4 or more floppy disks. This is a strange concept today, but it certainly made sense at the time and worked rather well — unless one of the floppy disks had a corruption problem, which made installation a challenge.

When a software vendor of that time wanted to copy-protect their application, they had only the floppy disk drive as their means of deployment. Strange as it may seem, computers were only very rarely connected to the Internet. So, the vendor would distribute a specially-formatted floppy disk — usually with purposefully-introduced corruption in known locations on the disk medium that only the application knew how to decode properly. Because these floppy disks were corrupted in a controlled way they were not easily reproduced by end-users, and thus the special floppy disk became a key for the application. (Of course, very clever users could duplicate the key disks with concerted effort and especially clever users could reverse-engineer the application and circumvent — or “crack” — the copy-protection, but that discussion is best left for another time.)

Thus, for the first three major US versions of 4th Dimension, from about 1987 until 1996, the Key Disk was a carefully-guarded possession of any 4D Developer. The copy-protection scheme employed by ACIUS involved a random check: approximately every third time the Developer launched 4D, it requested the Key Disk.

In July 1994 I brought my Key Disk to the annual 4D DEVCON, my first. My hope was to have Laurent Ribardière sign it, which he did during a memorable moment at the DEVCON Party. I thought it was very cool to have the author sign his work!

The main event of the 4D DEVCONs of those days was the DEVCON Party, which was lavish and always memorable. In 1994, the DEVCON Party was held at the Rosicrucian Museum in the Alhambra District of San Jose, California. The Museum is themed after the Temple of Amon at Karnak, and is utterly surreal.

On that night, I stood on the porch of the museum waiting to get Laurent’s attention. He was there chatting with the other members of the French contingent, who were smoking cigarettes outside as they must do in the United States. At the right moment I introduced myself to Laurent, shook his hand, and asked him to sign. He was quite amused to do so, but was very gracious and honored my request. The brightly-lit surroundings, the smoke from the strong French cigarettes, and the very warm and bright night all added to the surreality of the moment for me.

And so, my signed 4D v3 Key Disk remains one of my most treasured pieces of 4D Memorabilia. I keep it on my desk to remind me of the time when the Internet was not known, and of that rather surreal night when I asked Laurent to autograph my key disk.

There is an Easter Egg that has been hidden in 4th Dimension for many years, since 4D 6.0 and probably before.Here’s how to make it appear:

1. Single-click somewhere in the application. (I use an unused part of the menu bar for this.)

2. Carefully type "somiO", with a Shift-O for the last character.

3. Continue to hold down the Shift key.

You will see a small window open in the center of the screen. It contains a picture of 4D SAS’s Chief Visionary Officer and EVP of Engineering Asmae Benkirane, who must be a very special person to have her picture embedded inside 4D!

Be careful not to hold down the shift key for too long — all, and we mean ALL, event processing stops during this time. As soon as you release the Shift key, the window disappears and processing returns to normal.

Perhaps a future version will have an updated picture of Asmae! In any case, her picture is a lovely hidden feature and a wonderful Easter Egg.

Developer 1: Hey, wouldn’t it be great if 4D could (insert interesting thing here)?

Developer 2: Why would you want to do that?

Both Developers: Pause, look at each other, then laugh hysterically.

I’ll save the full explanation for another article, but if you answer “Why would you want to do that?” you show that you’re a bit out of touch with your constituency. It’s something of a self-fulfilling prophecy — if you don’t already understand why you would want to do that, you’ll probably never be convinced of its importance, and will never do it.

For me, a member of the 4D Development Community (to varying degrees) for 20-plus years, the punch line to the joke describes why I am now writing about the Community in a blog format: almost nobody does it. There are deeper reasons, but for today I’ll leave it that FLUSH BUFFERS is my response to “Why would you want to do that?”