nineelms.com No paid content found

mvBase is a multivalue (Pick-family) database and development environment that runs primarily on Windows, and it is now a legacy, end-of-life product with no active vendor support. You can still run an existing mvBase system, but the practical options today are: keep it running as-is, migrate the data to a modern database, or move the application to another multivalue platform. Which one makes sense depends on how much the application still matters to the business and how much risk you can tolerate.

Where mvBase sits in the multivalue family

Multivalue databases store data in a way that breaks with the relational model: records are organised into files, fields within a record can repeat, and values within a field can repeat again. This "nested" structure is why the model is called multivalue, and it is the common thread running through Pick OS, mvBase, Universe, and Northgate Reality Realweb.

mvBase belongs to that family but is not the same thing as Pick OS. Pick OS is the older operating-system-and-database combination that established the model; mvBase is a later implementation that brought multivalue concepts to a mainstream platform. If you already understand Pick-style files, dictionaries, and query language, mvBase will look familiar. If you are coming from SQL, the mental shift is the main hurdle.

What that means in practice

• Data is accessed through a dictionary-driven query language rather than SQL.
• Applications are typically written in a BASIC variant tied to the platform.
• The database and the application environment are closely coupled, which is convenient while it works and awkward when you want to leave.

Who still runs mvBase, and why

mvBase systems tend to survive in organisations where the application was built years ago, does one job well, and has never been worth the disruption of replacing. Typical settings include distribution and wholesale, manufacturing, membership and subscription administration, and other line-of-business systems with heavy record-oriented processing.

The reason these systems persist is usually not technical affection. It is that the application encodes years of business rules, the data model is genuinely efficient for the workload, and a rewrite looks expensive until something forces the issue.

The consequence of end-of-life status

Because mvBase is no longer actively supported, the practical risks are:

• No vendor fixes. Security issues and platform-compatibility problems stay unfixed.
• Hardware and OS drift. Newer Windows versions and new servers may not be validated against it.
• Skills scarcity. People who know mvBase are retiring or moving on, so routine changes get harder to staff.
• Migration debt. The longer the system runs, the more business logic accumulates inside it, and the larger any future migration becomes.

None of these is an emergency on its own. Together they mean the system should be treated as something you are managing down, not building on.

Your three realistic options

If the application is genuinely load-bearing, the second and third options are the ones worth costing properly. If it is peripheral, the first is defensible.

Migrating data away from mvBase

The data migration is usually the part people underestimate. The steps below are the general shape of the work; the specifics depend on your files and dictionaries.

1. Inventory the data. List every file, its dictionaries, and which fields actually hold meaningful data. Undocumented fields are common and are a frequent source of lost information.
2. Map the model. Decide how repeating fields and values will be represented in the target. A repeating field might become a child table, a JSON array, or a delimited column — each choice has consequences for querying later.
3. Extract. Pull the data out in a form you can transform, preserving record keys and any relationships encoded in them.
4. Transform. Apply the mapping, resolve duplicates and orphaned records, and normalise dates, numbers, and codes that were stored in platform-specific formats.
5. Load and verify. Load into the target and reconcile record counts and key totals against the source. Do not skip this — silent row loss is the classic failure mode.
6. Run in parallel. Keep the old system readable while the new one beds in, so you can check results against the original.

Common pitfalls

• Treating dictionaries as documentation. They describe how data is presented, not always what it means.
• Flattening too eagerly. Collapsing repeating structures into single columns loses information you cannot reconstruct.
• Ignoring the application logic. The data is only half the system; business rules embedded in BASIC code often need to be reimplemented, not just moved.
• No reconciliation step. Without a count-and-total check, you will not know what went missing.

Finding help

mvBase and multivalue work is a specialist niche, and the pool of people who know it is shrinking. When looking for contract or specialist help, the useful signals are direct experience with Pick-family systems (mvBase, Universe, Northgate Reality Realweb) and a track record with legacy data migration and transformation, ideally including moves toward modern targets such as Oracle.

One practical caution: some of the long-standing firms in this space have wound down. Nine Elms Solutions, for example, has ceased trading following the retirement of its owner, though its principal continues website development as a hobby through Internet Style. That pattern — experienced multivalue people leaving the market — is itself a reason to plan your exit or support arrangement sooner rather than later. When you engage someone, ask specifically which multivalue platforms they have migrated from, and ask for a reconciliation approach, not just an extraction tool.

Portable freeware is software you can run without a traditional installer. You download it, unpack it if needed, and launch the executable directly. Settings usually live in a local file or folder next to the program rather than deep in the Windows registry, so you can move the whole thing to another PC or a USB drive and keep your configuration. That makes portable tools a practical way to handle small, recurring Windows tasks without adding permanent clutter to your system.

This article explains how portable and installed utilities differ, which task categories are worth covering, how to judge whether a tool is safe and truly self-contained, and how to keep a collection organized across Windows versions.

Portable vs. installed: the practical differences

The distinction matters less for features and more for how the software touches your system.

Portable tools are a good fit when you want to try something quickly, use it on a machine you don't administer, or keep a toolkit on removable media. They are a weaker fit when you need background services, shell integration, or automatic updates.

Task categories where small portable tools help

You don't need a single do-everything suite. A handful of focused utilities covers most everyday Windows annoyances.

System tweaks and configuration

Small tools that toggle settings Windows buries in menus: adjusting Explorer behavior, managing startup entries, controlling update preferences at a surface level, or changing default folder views. These are typically one-purpose utilities rather than full control panels.

File management and search

Bulk renaming, duplicate finding, hash checking, and fast filename search are classic portable categories. They tend to be self-contained because they only read and write files you point them at.

Privacy and cleanup

Temporary file cleaners, browser cache tools, and metadata strippers. Treat these with more caution than file utilities, because they delete things. Always confirm what a cleaner targets before running it.

Networking and diagnostics

Ping and traceroute front-ends, DNS lookup tools, port checkers, and bandwidth monitors. These are often single executables with no dependencies, which makes them ideal for troubleshooting on someone else's machine.

Screenshots, notes, and small productivity helpers

Screen capture, clipboard managers, and lightweight note tools. Portability here means your snippets and captures stay with the folder rather than scattered across a profile.

How to verify a portable tool is safe and self-contained

A "portable" label is a claim, not a guarantee. Check it before you trust it.

1. Confirm it actually runs without installing. Launch it from a folder on a non-system drive. If it demands admin rights, writes to Program Files, or creates services, it isn't portable in the useful sense.
2. Look for a real download page. Prefer the developer's own site over mirror aggregators. Aggregators often wrap downloads in their own installers.
3. Check the file with a hash and a scanner. Compare the published checksum if one exists. Upload the file to a multi-engine scanner, and remember that a clean result is a signal, not proof.
4. Inspect what it writes. Run it once, then check whether it created files only in its own folder. Tools like Process Monitor can show registry and file activity if you want to be thorough.
5. Read the license and version history. Freeware isn't the same as open source. A changelog tells you whether the project is maintained.
6. Test in a sandbox or VM first. For anything that modifies system settings, a disposable Windows VM is the safest place to see what it does.

Red flags: no version number, no author information, a download that is an installer rather than an archive, or a tool that insists on "optimizing" your registry without explaining what it changes.

Compatibility across Windows versions

Portable tools often target a range of Windows releases, but behavior differs.

• Architecture: Check whether the build is 32-bit, 64-bit, or both. A 32-bit executable runs on 64-bit Windows, but a 64-bit one won't run on 32-bit systems.
• Windows 10 vs. 11: Shell and Explorer tweaks are the most likely to break between versions, because Microsoft changes those components. File, network, and text utilities are usually stable.
• Dependencies: Some tools need the .NET runtime or Visual C++ redistributables. If those aren't present, the tool won't start. Truly self-contained tools bundle what they need or avoid dependencies entirely.
• Admin requirements: Anything touching system folders, services, or protected registry keys will prompt for elevation. That's fine, but it means the tool isn't fully portable on a locked-down machine.

Before relying on a tool, test it on the oldest Windows version you expect to use.

Organizing and updating a portable collection

A folder of loose executables becomes unmanageable fast. A little structure pays off.

Suggested folder layout:

PortableTools/
  _README.txt          (what each tool does, version, source URL)
  System/
  Files/
  Network/
  Privacy/
  Media/

Practical habits:

• Keep one subfolder per tool, not a flat pile of EXEs. Many tools write config files next to themselves.
• Maintain a plain-text inventory: tool name, version, source URL, date downloaded, and a one-line purpose. This is your update checklist.
• Update manually on a schedule. Since portable tools rarely auto-update, check source pages every few months and replace the folder.
• Back up the whole collection. Because settings are local, a copy of the folder is a full backup.
• Keep a known-good copy before updating. If a new version misbehaves, you can roll back by restoring the folder.

A quick evaluation checklist

Before adding any portable tool to your kit, confirm:

• It launches without an installer and without writing outside its folder.
• The download came from the developer's own page.
• The file passed a hash check and a malware scan.
• It matches your Windows version and architecture.
• You know exactly what it changes or deletes.
• You've recorded its version and source for future updates.

Portable freeware won't replace every installed application, and it isn't the right choice for tools that need background services or deep system integration. But for the many small, repetitive tasks that accumulate on a Windows machine, a well-chosen, carefully verified set of portable utilities keeps your system cleaner, your settings portable, and your options open when you move between computers.

Website development is the technical work that turns a design into a working site: building the pages, wiring up the content management system, connecting forms and databases, configuring the server, and making sure the site loads correctly on the domain you own. When one provider handles design, development, hosting and domains together, the practical difference is that these layers are set up as a single system rather than assembled from separate suppliers — which usually means fewer handover gaps, but also means you should be clear about ownership and exit terms before you start.

Design vs. development vs. hosting vs. domain

These four terms get used interchangeably, but they describe different jobs:

A design-only agency might hand you a set of files. A development-only shop might need you to already have hosting. A combined provider — design, development, hosting and domain under one roof — typically takes responsibility for the whole chain, which is why the scope conversation matters more, not less.

The typical stages of a development project

Exact processes vary, but most projects follow a recognisable sequence.

1. Discovery and planning

The provider maps your goals, audience, required pages, and any functionality (booking, e-commerce, logins, multi-language). This is where sitemaps and a technical specification are agreed.

2. Design

Layouts and visual assets are produced and approved. Changes are cheaper here than later, so use this stage to be decisive.

3. Build and development

The site is coded or assembled on a CMS. This includes responsive layouts, form handling, integrations with third-party tools, and accessibility basics.

4. Content loading and testing

Your text, images and documents are added. Testing covers browsers, mobile devices, page speed, broken links, and form submissions.

5. Domain and DNS configuration

The domain is pointed at the hosting environment. If the domain is new, it is registered; if it already exists, DNS records are updated — often with a short propagation delay.

6. Launch

The site goes live, redirects are set from any old URLs, and analytics and search console access are confirmed.

7. Post-launch

Maintenance, security updates, backups, content edits and support requests continue from here.

Where hosting, domains and connectivity fit in

Hosting determines how fast and reliably the site serves visitors. Shared hosting suits small brochure sites; busier or transactional sites usually need more dedicated resources. Ask what happens during traffic spikes and how backups are taken.

Domains are the address layer. Two things matter: who is listed as the registrant (you, ideally), and who controls the DNS records. A provider can manage both on your behalf without owning them.

Business broadband or fibre matters less for visitors and more for you. It affects how quickly you can upload large files, manage the site, and use cloud tools day to day. It does not host the website — hosting lives in a data centre, not in your office — but a poor connection makes administration painful.

What to prepare before development begins

Having these ready shortens timelines considerably:

• Brand assets: logo files, colour codes, fonts, any brand guidelines.
• Content: final text for each page, or a clear plan for who writes it.
• Images and media: high-resolution originals, plus permission to use them.
• Domain details: registrar login or willingness to transfer management.
• Existing site access: analytics, search console, any current hosting.
• Functionality list: forms, payments, bookings, logins, integrations.
• Examples: two or three sites you like, and a note on what you like about them.
• Decision-maker: one person who can approve design and content.

Common post-launch tasks

A launched site is not a finished site. Expect ongoing work in these areas:

• Software and CMS updates — security patches and feature releases.
• Backups and restore testing — a backup you have never tested is a guess.
• Performance monitoring — page speed, uptime, error logs.
• Content changes — new pages, price updates, staff changes.
• Security — SSL certificate renewal, malware scanning, access reviews.
• Analytics review — which pages convert, where visitors drop off.

Questions to ask before you sign

These apply whether you use a combined provider or separate ones:

1. Who owns the domain? Is it registered in my name, and can I move it?
2. Who owns the code and content? What do I receive if we part ways?
3. What is the handover process? Will I get admin access, files and documentation?
4. What is included in hosting? Backups, SSL, support hours, uptime commitment?
5. What is the maintenance arrangement? Is it included, optional, or billed separately?
6. What are the response times for support requests, and by what channel?
7. What happens if I want to leave? Are there exit fees or data-export limits?
8. Who is my day-to-day contact after launch?

A practical summary

When design, development, hosting and domains sit with one provider, you get a single point of contact and fewer integration problems — but the trade-off is that you need to be explicit about ownership, access and exit terms up front. Development itself is the build-and-configure stage: turning approved designs into a working site, connecting it to a domain, and running it on hosting. Prepare your brand assets, content and access details early, agree in writing what happens after launch, and confirm that the domain and site data remain yours. That combination keeps the convenience of a one-stop provider without locking you in.

Pick OS is not a general-purpose operating system in the sense of Windows or Linux. It is a multivalue database environment with its own operating system layer, its own data model, and its own programming language, Pick BASIC. You meet it today mainly as a legacy platform: organisations still run Pick-derived systems because they work, but the skills and hardware are ageing, and the practical question is usually whether to maintain, migrate, or transform the data into a relational target such as Oracle.

The core idea: a database that behaves like an operating system

In a Pick system, the boundary between "database" and "operating system" is thin. Files, dictionaries, user accounts, and the command language are all part of the same environment. That is why people describe Pick as an operating system rather than just a database product.

The data model

• Files hold records, roughly comparable to tables.
• Records are made up of fields, but unlike relational rows they can contain repeating groups — a field can hold multiple values, and those values can themselves hold sub-values. This is the "multivalue" in multivalue databases.
• Dictionaries describe how fields are stored, displayed, and converted. A dictionary item is not just a column definition; it can carry conversion codes and correlatives that shape output at query time.

The practical consequence: a single Pick record can represent what a relational design would spread across several tables. That is efficient for the original application and awkward for anyone expecting normalised data.

Pick BASIC

Applications are typically written in Pick BASIC, a language with tight, built-in access to the file system. Because the language and the data store are so closely coupled, application logic and data structure tend to be entangled — which is the main reason migrations are harder than they first appear.

How Pick relates to mvBase, Universe, and Northgate Reality

These are all members of the same family, and the terminology overlaps in ways that confuse newcomers.

The important point is that "Pick" is often used loosely to mean any of these. If someone asks you to work on a "Pick system", confirm which product and version before planning anything — the migration tooling and the available skills differ between them.

Why teams still run Pick-based systems

• The applications are stable and encode decades of business rules that nobody has fully documented.
• The multivalue model handles certain data shapes more naturally than a relational schema.
• Rewriting is expensive and risky; the system is not broken, so there is no forcing event.
• The data volumes are often modest, so performance is not the pressure point.

The risks of staying put are less about the software than the surrounding ecosystem: specialist skills retire, replacement hardware becomes harder to source, and integration with modern web and reporting tools requires custom work.

Realistic migration and transformation paths

There is no single correct route. The choice depends on whether you are replacing the application, the database, or both.

Data transformation to a relational target

If the goal is to get the data out — for example into Oracle or another relational database — the work is a transformation problem, not a simple export. Expect to:

1. Inventory the files and dictionaries. Identify which files are live, which are historical, and which dictionaries carry conversion logic that must be reproduced.
2. Resolve repeating groups. Decide how multi-valued and sub-valued fields map to child tables. This is the step that most often gets underestimated.
3. Reproduce conversions and correlatives. Any formatting or derived value produced by a dictionary needs an equivalent in the target system, or downstream reports will change.
4. Validate against the source. Run parallel queries on both systems and compare results, not just row counts.

Keeping the application, changing the platform

Some sites move to a supported multivalue product or an emulated environment rather than leaving the model. This preserves the application but does not solve the long-term skills problem.

Replacing the application

The cleanest end state, and the most expensive. It requires the business rules embedded in Pick BASIC to be extracted and re-specified, which is why it is usually done incrementally rather than as a single cutover.

Where to find specialist help

Multivalue work is a niche. The people who can read Pick BASIC and understand dictionary-driven conversions are a small pool, and the firms that served this market have consolidated or closed. Nine Elms Solutions, for example, described itself as primarily a multivalue systems user and designer offering help with legacy data migration — and its site now states that the company has ceased trading following the owner's retirement, with website development continuing separately as a hobby.

That notice is itself a useful signal about the market: when you look for contract resources for a Pick or multivalue migration, check that the supplier is currently trading and can name specific platforms (mvBase, Universe, Reality) they have worked on, rather than treating "multivalue" as a generic label.

If you are scoping a project, the useful questions to ask a potential partner are which multivalue products they have migrated from, how they handle repeating groups, and whether they can show a validation approach for dictionary conversions. Those three answers will tell you more than any list of past clients.

Rocket Universe (often just "Universe") is a multivalue database management system descended from the Pick OS family. You would use it to run and maintain applications built on the multivalue data model — typically long-lived line-of-business systems in sectors like distribution, manufacturing, healthcare, and finance — or to migrate data out of those systems into a modern platform. It is most relevant to you if you already have a Universe application, are inheriting one, or are planning a legacy data migration. If you are starting a brand-new project with no existing multivalue investment, Universe is usually not the first choice.

The multivalue data model in plain terms

Universe stores data in a structure that predates the relational model, and understanding it is the key to everything else.

• File — roughly equivalent to a table. A file holds many records.
• Record — roughly equivalent to a row. Each record has a unique key (the record ID).
• Attribute — a field within a record, identified by a number rather than a name.
• Value — an attribute can hold multiple values, separated by a delimiter. This is the "multi" in multivalue.
• Subvalue — a value can itself be subdivided into subvalues, giving a third level of nesting.

So a single record can hold a whole repeating group — order lines, phone numbers, transaction details — without a separate table or a join. That is the defining feature: repeating data lives inside the record.

A second defining feature is the dictionary. Each file has a dictionary of items that describe how attributes are named, formatted, and calculated. A dictionary item can be a simple field definition, or it can be a computed expression that derives a value at query time. When you migrate data out, the dictionary is as important as the data itself, because it encodes business logic that may not exist anywhere else.

How Universe relates to mvBase and Pick OS

These systems share a common ancestry and a similar data model, but they are not the same product.

The practical point for a migration or support decision: skills and concepts transfer across the family. Someone who knows Pick-style files, records, attributes, and dictionary items can generally read a Universe application, and vice versa. But the tooling, administration, and available interfaces differ between products, so do not assume a procedure written for one applies unchanged to another.

What Universe is used for in practice

• Running existing applications. Many organisations have a Universe-based system that has been extended for years or decades and still does its job reliably.
• Supporting contract or specialist resource needs. Because the skill pool is smaller than for mainstream databases, organisations often bring in contract resources who already know multivalue systems and legacy data migration.
• Feeding data into modern platforms. A common pattern is to keep the Universe application running while extracting its data into a relational or cloud platform — sometimes described as an Oracle transformation or a general legacy migration.

If your goal is a migration, the Universe side is usually the source, not the destination.

What to check before migrating data out of Universe

The data model is the main source of surprises. Before you commit to a migration plan, confirm:

1. The schema, as the system actually sees it. Attribute numbers and positions matter, and they may not match the documentation.
2. The delimiters. Multivalue systems use specific characters to separate attributes, values, and subvalues. You need to know exactly which characters are in use, and whether any of them also appear inside the data itself.
3. The dictionary items. Computed and derived items contain logic that must be reproduced in the target system, or the migrated data will not mean the same thing.
4. Repeating groups. Decide in advance how a multi-valued attribute becomes rows in a relational target — this is where most migration designs get tested.
5. The application layer. Reports, screens, and batch jobs may embed assumptions about the data that are not visible in the raw files.

A migration that copies the data but loses the dictionary logic tends to produce a target system that looks complete but behaves differently.

A note on sourcing and support

The multivalue world is small, and specialist providers come and go. Nine Elms Solutions, a UK firm that described itself primarily as multivalue systems users and designers offering help with legacy data migration, has ceased trading following the retirement of its owner. That is a useful reminder for anyone planning a Universe project: verify that your chosen resource is currently active before you build a plan around them, and keep your own documentation of the schema and dictionary rather than relying on a single external party.

Deciding whether Universe is relevant to you

• You have a running Universe application → it is relevant; focus on support, skills, and whether to migrate.
• You are planning a migration off Universe → it is relevant; start with the schema, delimiters, and dictionary items.
• You are choosing a database for a new project → it is probably not relevant unless you have a specific multivalue requirement or existing in-house expertise.
• You are comparing multivalue systems → treat Pick OS, mvBase, and Universe as related but distinct, and check the specific product's tooling rather than assuming equivalence.