4th Dimension Learning Basics

Key Takeaways

• The original “4th Dimension Learning Basics” page was a curated link list — its real value was pointing newcomers to the handful of resources that mattered: the ACI US site, the 4D-NUG mailing list, tech notes, and the Partner Program.
• 4D’s core concepts (structure vs. data, tables/fields/relations, forms, methods, value lists) have stayed remarkably stable across versions, so learning material from the v6.x era still teaches transferable ideas.
• The single biggest accelerator for a beginner is a community: mailing lists, user groups, and forums answer the “why won’t this work” questions that documentation alone cannot.
• Professional development in 4D is a viable income path, and the vendor’s partner/developer programs historically provided priority support, example databases, and beta access.
• Many of the original URLs are dead or redirected; the durable strategy is to learn the categories of resources (official docs, community, sample code, tools) rather than memorize specific links.

---

Why This Page Existed — and Why It Still Matters

The original page you’re reading is a snapshot of a specific moment in 4D history: the late 1990s, when ACI US (the North American distributor of 4D, later renamed 4D Inc.) maintained the primary web presence for the product at aicus.com. The page was essentially a resource directory — a list of URLs a developer should bookmark before starting serious work with 4th Dimension.

That framing is worth preserving, because it reflects a truth that hasn’t changed: learning 4D is as much about knowing where to look as it is about memorizing syntax. The platform has always had a relatively small, tight-knit community compared to, say, the Microsoft Access or FileMaker worlds, and that community — mailing lists, user groups, vendor tech notes — has historically been the fastest route from “stuck” to “shipping.”

So rather than discard the original list, this expanded version keeps every resource it named and adds the context, judgment, and modern equivalents a developer actually needs.

The Core 4D Concepts You’re Really Learning

Before chasing links, it helps to understand what 4D is, because the terminology shapes every resource you’ll read.

4D is a relational database management system with an integrated development environment. Its defining characteristic — and the reason it appeals to “citizen developers” and small-team IT builders — is that it bundles together several things that are usually separate products:

• A database engine (the 4D Server / 4D application) that stores and serves data.
• A structure editor for defining tables, fields, and relations.
• A form editor for building the user interface, including list forms and detail forms.
• A programming language (originally called 4D, now often referred to as 4D Langage / ORDA in modern versions) with a large library of built-in commands.
• A runtime that can be deployed as a compiled, standalone application.

The mental model to internalize early is the split between the structure (the schema — tables, fields, relations, and the methods attached to them) and the data file (the actual records). In classic 4D, these were separate files, and a common beginner mistake was to move or copy one without the other. Understanding this split explains a whole class of “my database won’t open” problems.

Two more concepts recur constantly in the original resource list:

• Methods — blocks of code attached to objects, forms, tables, or the database itself. The database method, in particular, runs at startup and is where you initialize globals and set up the environment.
• Value lists — reusable lists of choices bound to fields or variables, which is how 4D builds dropdowns and pop-up menus without hand-coding each one.

If you understand structure vs. data, methods, and value lists, you can read almost any 4D tutorial — old or new — and follow it.

Navigating the Original Resource List

The original page’s links fall into recognizable categories. Here’s how to think about each, including what has aged and what hasn’t.

Official vendor resources

The page pointed to ACI US at aicus.com for downloads, support, tech notes, and the Partner Program. ACI US was the company that distributed 4D in North America; the product itself originated with ACI (Analyses Conseils Informatique) in France, and the modern vendor is 4D SAS, whose site is 4d.com. The aicus.com domain and its deep links (downloads, support articles, FTP) are largely historical now — treat them as an archive rather than a live destination.

What survives conceptually is the structure of vendor support:

• Tech notes — short, targeted documents explaining a specific behavior or workaround. These were gold in the pre-Stack-Overflow era.
• Example databases — downloadable sample structures you could open, inspect, and cannibalize. This is still one of the best ways to learn 4D idioms.
• Downloads / updates — point releases that fixed specific bugs.

The 4D-NUG mailing list

The 4D-NUG (4D North User Group) mailing list was, for many developers, the single most valuable resource on the page. Mailing lists were the social media of their day: you’d post a question and get answers from experienced developers, often within hours. The page also pointed to a searchable archive (hosted at pdm-inc.com / “monkeywerks”).

The lesson here is durable: a searchable archive of past questions is worth more than the live list, because most of your questions have already been asked. Modern equivalents are the official 4D forums and community sites, plus general developer Q&A sites. When you hit a wall, search the archive first.

Third-party articles and tools

• Steve Hussey’s “Upgrading From FileMaker Pro to 4D” — a migration guide. Migration guides are disproportionately useful because they’re written for people who already know a database and need the differences explained, not the basics. If you’re coming from FileMaker, Access, or another low-code tool, seek out this genre.
• 4D Assimilator — a tool that let 4D clone any ODBC source, import table structures, and then import the data. This is an early example of the ODBC (Open Database Connectivity) interoperability that 4D has long supported. If you need to pull data from another system, understanding ODBC — and later, native connectors and SQL — is essential.
• 4D MetaBASE — a downloadable example application (the page noted it was roughly a 5 MB download, large for its era). Example applications like this are effectively living documentation.

Community and professional programs

• User groups — local or regional gatherings. The page linked to a directory of them. Even in a remote-first world, a local group is valuable for hands-on help and job leads.
• The ACI US Partner Program — for developers doing 4D work professionally. The page listed concrete benefits: priority tech support on an 800 number, all tech notes and example databases “since the dawn of time,” discounts, and access to beta versions. That last item — beta access — is a genuine competitive advantage, because it lets you prepare clients for upcoming changes before they ship.

How to Decide Which Resources to Invest In

Not all resources deserve equal time. Use this rough priority order, which reflects how experienced 4D developers actually work:

Priority	Resource type	Why it matters	Time investment
1	Official documentation & tech notes	Authoritative; defines correct behavior	Ongoing reference
2	Community archive (mailing list / forum)	Answers real-world “why” questions	Search as needed
3	Example databases	Teach idioms and structure by example	Study a few deeply
4	Migration guides	Fastest path if you know another tool	Read once, thoroughly
5	Tools & utilities (ODBC, importers)	Extend reach to other systems	Learn when needed
6	User groups & partner programs	Support, networking, beta access	Situational

The principle: spend your first hours in the official docs and one good example database, then live in the community archive. Tools and programs come later, once you know what you’re building.

Practical First Steps for a New 4D Developer

Translating all of the above into an actual plan:

1. Install the current 4D version from the official vendor site and open a sample database. Don’t start from a blank structure — start from something that works.
2. Open the structure editor and identify the tables, fields, and relations. Then open a form and find the methods attached to its objects. This connects the schema to the UI.
3. Trace one value list from its definition to the field or variable it’s bound to. Value lists are a small feature that teaches a big idea: 4D separates data definition from presentation.
4. Write a trivial method — something that displays a message or loops through records — and run it. Getting the edit-run-observe loop working early removes the fear of the language.
5. Join a community and lurk before posting. Read the archive. You’ll absorb conventions and pitfalls faster than any tutorial delivers them.
6. If you intend to earn money, investigate the vendor’s current developer/partner program. The benefits have evolved, but the concept — priority support, sample code, early access — persists.

Caveats and Things the Original Page Couldn’t Say

A few honest notes that a resource list from 2000 couldn’t include:

• Links rot. Nearly every URL on the original page is now dead, redirected, or archived. Don’t be discouraged if a link fails — search for the title of the resource instead; community members often re-host old articles and example files.
• Version drift is real. 4D has evolved substantially — the introduction of ORDA (Object Relational Data Access) changed how many developers query and manipulate data, and the language has gained modern constructs. Concepts from v6.x still apply, but syntax and best practices have moved on. Always check which version a tutorial targets.
• “Low-code” doesn’t mean “no-code.” 4D lets you build a lot with forms and value lists, but serious applications require writing methods. Budget time to learn the language.
• The community is small — and that’s a double-edged sword. You’ll get personal help, but there are fewer Stack Overflow answers than for mainstream languages. The archive and official docs carry more weight here.

Frequently Asked Questions

Is 4D still actively developed and supported?

Yes. The product originated with ACI in France and is now developed by 4D SAS, which continues to release new versions, documentation, and developer programs. The historical ACI US distributor site referenced on this page is no longer the primary source — the official vendor site is. Concepts from older versions remain relevant, but you should always confirm which version a given tutorial or example targets.

What’s the difference between the 4D structure and the data file?

The structure is the schema — tables, fields, relations, forms, and methods — while the data file holds the actual records. In classic 4D these were separate files, which is why copying or moving one without the other causes databases to fail to open. Understanding this separation is fundamental and explains many beginner troubleshooting scenarios.

Do I need to know SQL or ODBC to use 4D?

No, but it helps. 4D has its own query and data-access language, and tools like the historical 4D Assimilator used ODBC to import structures and data from external sources. If you need to integrate with other systems, learning ODBC and 4D’s SQL support expands what you can build considerably.

How important is joining a community or user group?

Very important, especially because 4D’s community is smaller than those around mainstream languages. Mailing lists, forums, and their searchable archives answer the practical “why won’t this work” questions that documentation doesn’t cover. User groups and vendor partner programs add networking, priority support, and early access to new versions.

Can I make a living doing professional 4D development?

Yes — the original page explicitly framed professional 4D development as an income path and pointed to the vendor’s Partner Program for support, example databases, discounts, and beta access. The specific program terms have changed over time, but the model of a vendor-supported developer ecosystem persists. Check the current vendor site for today’s program details.

Where should a complete beginner start today?

Start with the official vendor documentation and a downloadable example database rather than a blank structure. Open the structure editor, trace a value list, and write one small method to get the edit-run-observe loop working. Then join a community and search its archive before posting. This sequence mirrors how the original resource list was meant to be used.

---

*Copyright