6.1Case studies
The essentials in 30 seconds
- Assemble: analyse the data → design the windows → code in WLangage → generate the reports → deploy — that chain is what makes an application reliable.
- Prove it: an application exists when the data stays consistent (transactions, integrity), when it runs at the customer's site and when it updates without losing a single line.
- Decide: Classic or Client/Server, single-workstation or multi-workstation, executable or automatic update: the usage context decides, not fashion.
Yacine's thread — three situations, one method
Yacine is a WinDev developer at an electrical equipment trading SME in Oran. He maintains and evolves the in-house application that manages customers, products, orders, invoices and stock. He reviews three notable situations from the quarter — building the application from A to Z, moving from a Classic database to multi-workstation Client/Server, and deploying to travelling sales reps. The cases below follow his chain from levels 0 to 5: analyse, design, code, query, harden, deploy.
Each case follows Context → Steps → Result: replay it on your own applications.
Why case studies
Previous levels laid the bricks (analysis, windows, WLangage, HFSQL, queries, reports, procedures, security, deployment); here we assemble them end to end. It is the chain of good reflexes — a clean analysis, linked controls, bounded queries, transactions and a test run on a clean machine — that separates a reliable management application from a demo that only works on the developer's workstation.
Replaying end to end
A case is not copied: it is replayed. You follow the order of the approach, adapt it to the context (number of workstations, data volume, store constraints) and keep the same demand for proof at every step.
From screen to field
The real test of an application is not “it opens on my machine”, but “it holds over time”: data stays consistent, permissions are respected, backups exist and an update does not break what already works.
Case 1 — Building the trading management application from A to Z
Context: Yacine must deliver to his SME an application that manages customers, products, orders, invoices and stock, with simple tracking for the boss and fast input at the counter.
Déroulé :
- Design the analysis: files, items, relationships and keys, thinking about integrity and future changes (N0.4, N1.1).
- Design the windows and controls, taking care of ergonomics and naming (N1.2).
- Code the processes in WLangage: variables, conditions, loops, events (N1.3, N2.5).
- Link the controls to the data and master records (HAjoute, HModifie, HEnDehors) (N1.4).
- Generate a first version with the RAD, then produce the useful reports (invoice, stock) (N1.5, N2.3).
- Write the queries and choose the right traversal modes and file table modes (N2.2, N2.4).
Result: A coherent application: solid analysis, linked controls, clean record handling and generated reports — a healthy base for future changes.
Case 2 — Moving the database from Classic to Client/Server
Context: The application first runs in HFSQL Classic on one workstation. With several users at the counter and in the warehouse, slowdowns and the risk of conflicts become visible.
Déroulé :
- Choose the right mode and prepare the move to HFSQL Client/Server (N2.1, N4.1).
- Review the queries: database-side filters, indexed items, bounded queries (N2.2).
- Define permissions and user groups according to real roles (N4.2).
- Wrap writes in transactions and handle locks in multi-user mode (N4.1).
- Test load and consistency with several simultaneous workstations (N4.5).
- Set up backups and restore before the switchover (N4.1).
Result: A reliable shared database: centralised data, fast responses, respected permissions and consistent writes — multi-workstation becomes an asset, not a risk.
Case 3 — Deploying and maintaining on travelling sales reps' machines
Context: Sales reps work on the road and must receive new versions without an IT person on site, without losing their data or blocking their round.
Déroulé :
- Prepare the executable and its dependencies, with a complete installer (N4.4).
- Set up installation and automatic updates (N4.4).
- Decide what stays local and what comes from the server, and manage synchronisation (N4.1).
- Secure access and customers' personal data (N4.2).
- Test-run each version on a clean machine before release (N4.5).
- Track versions and code with the source control manager (N5.4).
Result: A cleanly deployed fleet: controlled versions, updates with no data loss and autonomous sales reps — maintenance becomes predictable.
Ready-to-say script — framing an application (30 s)
“The application: [trading management / Client/Server migration / deployment]. My approach: check the analysis, design the windows, link the controls, code the processes, generate the reports, then test-run and deploy.”
Keep this to frame a project with your management or a customer.
Ready-to-say script — explaining your method (30 s)
“I always start from the analysis, I link the controls rather than tinkering in the screen, I bound my queries and I test on a clean machine before delivering — that's what avoids nasty surprises.”
Useful for explaining your approach without unnecessary jargon.
Copy-paste template — construction approach
1. Analyse: files + items + relationships + keys
2. Design: windows + controls + ergonomics
3. Code: WLangage (events, procedures)
4. Link: controls <-> items, HAjoute/HModifie/HEnDehors
5. Report: bounded queries + reports
6. Harden: errors + permissions + tests
7. Deploy: executable + update + clean-machine test runCopy-paste template — pre-delivery test sheet
Version: [x.y] Date: [..]
Analysis changed: yes/no (migration tested on a copy)
Data: backup done? yes/no
Paths tested: login, input, modification, deletion
Permissions checked: profile [counter / warehouse / boss]
Printing: invoice + stock report OK
Installation tested on a clean machine: yes/no
Rollback planned: yes/noVery small business / small budget
Stay in HFSQL Classic on one or two workstations, focus on the analysis and the useful reports, and only add complexity if the need is real.
SME in Oran
Adapt to local realities: power cuts, heterogeneous workstations, French content and labels, quick training for users at the counter.
Remote / multi-site
Centralise data in Client/Server, double the traceability and plan a clear remote update procedure.
Cross-cultural
Make labels explicit before transposing: an item name or label that is obvious to one person must speak to any newcomer.
48h challenge — apply it tomorrow
Take a real application and replay the chain: checked analysis, linked controls, 1 coded process, 1 generated report and 1 test on a clean machine.
- I can chain analysis, windows, code, queries, reports, hardening and deployment on a real application.
- I have a replayable approach (analysis first, linked controls, bounded queries, clean-machine test run).
- I have done the 48h challenge or scheduled its date.
Yacine delivers the trading application. Which chain follows the guide?