The question is a bit contradictory as it seems to ask for multiple, possibly mixed-up, items:
- Use of physical cards
- Use of card originated conventions
- Use of the word card as professional term
In addition it carries the issue of
- Individual timing
as each and every user and use case will not only have dropped them at a different time(*1), but also as a gradual process.
In general, use of physical cards started to vanish as early as the mid-1960s when hard disks became a thing with most installations. From then on, punch cards' use in data centers declines - it was simply more convenient to start a job from disk. Despite that, their use as prime media for data entry continued. By 1970 local data-entry systems like Cogar 4 or Datapoint 2200 started to replace key punches and cards. IBM introduction of the 3740 data entry system, in 1973, handed the biggest punch to card processing. (Mass) data entry moved from keypunch to 3740 and similar systems, taking away the need to create and carry wagonloads of cards from data-entry buildings to the computer room.
From there on, physical cards were no longer a main stable in mainframe systems. I know several large-scale computing centers (i.e. such with multiple machines) which by 1978 had removed all their readers (in the old times multiple readers per machine) except for one single card reader kept operational for the occasional task of reading in some old stack.
My last (kinda) professional use was typing a series of cards at a customer site (*2) for our football (*3) bet list to be immediately printed out in 1979. Not because there weren't terminals, but because the lonely 029 keypunch was readily available and printing them out could be done with a console command not needing any account (*4) :))
Physical cards left mainstream service around 1976 to 1979.
A reminder about how gradual the change was/is, can be found in this report about a 1948 electro-mechanical(!) IBM 402 accounting machine still operating for production in 2010 in Texas, USA ... of course using newly-punched 80 column cards for data :)
Card Inspired Conventions
Since the card was the first and all around (*5) data storage, everything was based on those (usually *6) 80 columns. All software was, and often still is, based around buffers of 80 (or 84) bytes to read the next (partial) record.
Introduction of modern data-entry systems (such as the 3740 and later) only straightened and sped up the entry process, not the internal workings - which is exactly what made it such a seamless and successful step ahead.
Fixed-length records are even now the mainstay of data handling on mainframes (*7).
This of course included the command line as well (*8). With increased terminal availability, OSes started to acquire front-end abilities to handle lines longer than 80 chars. Sometimes this was done by turning long lines into series of 80 byte records :)
Such software is still to be found today. After all, why change a running input system if no command, configuration or input data will exceed 80 chars anyway? Likewise command line, compiler, most tools, etc. are still able to read an input line as a series of 'cards' concatenated by a continuation mark.
Not to mention that basic manuals for mainframe OSes still start with an introduction to command structure differing very little to back then.
Facit: Conventional use never stopped.
Card as Professional Term
And then there are people talking about their job. A line was a card and a card was a line. This was deeply ingrained with everyone working in (mainframe) IT. And we all know how hard it is to get rid of terms that have been used for a long time.
Within that setting, calling something a card is in addition a clear hint that it's not about some line but a command or parameter or a stack thereof. Which is another of those remainers: Stack as in Stack of Cards (*9). Mainframe people may still distinguish a stack for commands/parameters from a file which holds data. It's simply part of a domain specific language :)
It does fade more and more with each retiring oldtimer and their successors no longer directly operating the system.
Conclusion: Card as professional term is still known but fading fast.
*1 - Interestingly, smaller customers usually transitioned notably later. I remember one example running a single low end /370 (in real mode) still using tape based procedures in 1980 and complaining that even the real mode OS now needs a disk to fully function. He claimed it was made on purpose to make him buy new hardware, hardware he and most (his words) others would never ever need.
*2 - The Bavarian tax office in Munich, the customer mentioned, might make a perfect example for the situation 1979. At the time they were running six /370 mainframes, 14 printers, a huge disk farm and close to 1000 terminals. Exactly two keypunches were surviving in a corner along with a single card reader. Only a few years before they had several halls filed with a hundred or more key punches and staff operating them in shifts.
*3 - The real stuff, played using only feet (and brains).
*4 - Which also meant that the job was not recorded in any way in the accounting system :))
*5 - As in used foreverything, input, output, intermediate, short term and long term storage
*6 - YMMV depending on manufacturer. 80 is standard for IBM and most IBM-compatible systems
*7 - Along with block-orientated instructions, not needing to iterate along variable-length fields and records is a major reason why mainframes are as fast as they are.
*8 - After all, the command line is nothing other than the terminal collecting characters until they are sent as a record which the host can handle exactly as if a card was read - standardization of interface formats at the very base.
*9 - In some way as well forthedata structure, isn't it?