Ask LLOG: "Developer requests to assume role"?

« previous post | next post »

Reader MP writes:

A question came up at work about the syntax of something that struck some of us as odd.

The context is fairly technical – it’s one of a series of captions for a diagram. The full set of captions is (approximately) this:

1. System admin creates role
2. System admin sets role permissions
3. Developer requests to assume role
4. [ProductX] returns role session credentials
5. Developer updates folder using role credentials

In this context, role, permissions, credentials, and even assume all have precise technical meanings. The oddity is in the syntax of “requests to assume.”

I’ve run it by editors (a lot of them), and although many people agree that that it sounds odd, no one has been able to pin down exactly why. In fact, a couple of people have come up with examples that would seem to support the pattern of request + infinitive:

AHD5 apparently has an example “… requested to see the evidence firsthand”
MW unabridged has an example “… requests to be excused from the ungrateful task”

Any thoughts or insights?

My suggestion: It's a matter of probability.

The wordform requests occurs 6,798 times in the COCA corpus. In a random sample of 100 that I checked, 94% were nouns. With an infinitival complement, the proportion of nominal uses is apparently even higher. There are 653 instances of the sequence requests to, and in a random sample of 100, 100 of the requests were nouns rather than verbs. A quick scan over all 653 turned up only two verbal uses:

Ironically, in assuming the disadvantaged position of a woman, the narrator astutely requests to be read as a cultural authority.
Supervisor Tom Ammiano requests to be listed as a co-sponsor, and says, "[…]"

In these two cases, the interpretation of requests as a noun is impossible or at least strongly disfavored, e.g. by the preceding adverb in "astutely requests".

It's common to modify the noun requests in this construction with another noun denoting the requester, as in these examples from COCA:

Nonsmoker requests to smokers to refrain from smoking are often stressful, […]
March refused police requests to interview him or his children.
It would also make junk e-mailers comply with all consumer requests to be removed from their lists.
He said it has also refused agency requests to separate operations at Natanz, […]

So perhaps the pattern Developer requests to […] primes readers strongly to expect that requests will be a plural noun, while the rest of the context requires them to interpret it as a 3rd-person singular present verb form.

I don't have a lot of confidence that this explanation is correct, but it covers the ground.


  1. Faldone said,

    September 15, 2012 @ 6:16 pm

    What looks weird to me is "the ungrateful task".

    [(myl) That's the old-fashioned ungrateful meaning "Unpleasant, disagreeable, distasteful", as in Addison's couplet

    But stop, my Muse, th' ungrateful sound forbear,
    MARIA 's name still wounds each British Ear:

    This is of course the opposite of the sense of grateful glossed "Pleasing to the mind or the senses, agreeable, acceptable, welcome".]

  2. Ø said,

    September 15, 2012 @ 6:33 pm

    In the current sense grateful=thankful.

    In the old-fashioned sense ungrateful=thankless.

  3. Dick Margulis said,

    September 15, 2012 @ 6:39 pm

    When MP ran the question the other day by a lot of editors, he did not include the list context. On my querying him, he did allow it was for a technical document, and I suggested that in a technical context it looked fine. Now that I see the list context, I'm even more convinced that it's unremarkable. We have a fairly strong bias toward assuming that lists are constructed in parallel, if for no other reason than in edited text they typically are constructed in parallel by dint of editorial intervention. So, in the middle of the list as shown above, requests is pretty obviously a verb. I don't see a garden path problem here (even though your corpus analysis suggests that I might see such a problem if the sentence were isolated).

    So I think MP is seeing the shadow of a ghost of a problem that was never there (in this context).

  4. FM said,

    September 15, 2012 @ 6:51 pm

    I think the distinction is this. When you're requesting something, you're asking someone else to do something. So it's a priori a bit odd to request (of someone else) (for you) to do something. In the other examples given ("requested to see", "requests to be excused") these are actions which are, for lack of a better word, passive — they require agency on someone else's part. In fact, except for "requested to see" all the other examples are actually in the passive voice. "Assuming a role" is usually not such an action — it sounds like you would assume it on your own initiative. So this would seem on the surface to be semantically, not grammatically, weird.

  5. Alan Curry said,

    September 15, 2012 @ 6:57 pm

    The first thing I notice about the non-odd-sounding examples is that most of them are passive: to be excused, to be read, to be listed, to be removed. The implied actor behind those passives is the person receiving the request. "Requests to see" is bascially equivalent to "requests to be shown", so it fits the same pattern, specifying an action to be taken by the request receiver. I think "requests to assume" sounds odd because it's not obvious what the request receiver must *do* to satisfy the request. The closest we get to an answer is that in step 4 it returns something. "Assume" and "return" don't form an obvious request-reply pair.

    [(myl) But the same pragmatic puzzle exists in "Developer asks to assume role" — does it have the same problem?]

  6. John Roth said,

    September 15, 2012 @ 7:04 pm

    It looks weird to me too. "Developer requests role" works for me.

    My intuition is that "request" and "assume" have a semantic mismatch of some kind.

  7. J.W. Brewer said,

    September 15, 2012 @ 7:17 pm

    "requests to be VERBed" is not quite the same as "requests to VERB," which I get a very ESLish-at-best vibe from. Does anyone have another in-the-wild sample of the latter, which COCA apparently did not? I think part of the problem might be that "requests" as a verb will frequently (if not obligatorily?) take an NP object before the infinitive. So, e.g., some googling turned up a headline "$1 million requested to address crowding in Windham schools." If you were to recast that into the active voice and present tense, it would be "School board requests $1 million to address" etc. In the COCA examples above, recasting from "to be VERBED" to "to VERB" might also require the insertion of such an object, e.g. "Supervisor Tom Ammiano requests [whoever is in charge of such listing] to list him as a co-sponsor."

  8. Guy said,

    September 15, 2012 @ 7:20 pm

    Isn't 'request' just being substituted for 'ask'?

    The constructions that come most easily to me are request that + passive & ask + infintive.

    It requests that it be done but asks to do or asks to be done.

    Maybe the writer was thinking 'asks' but thought that wasn't technical/formal enough?

  9. L said,

    September 15, 2012 @ 7:40 pm

    "Request" is standard-issue technobabble, and it has a precise technical meaning. I'm a standard-issue technobabbler by profession. The meaning is pretty much the same as in general use, but it's the go-to technobabble word. Computers don't ask, they don't beg, they don't say please, they don't send in boxtops. They request, and sometimes the request is granted and sometimes the request is denied.

    A technobabble corpus would, I am certain, bear this out.

    There might be great interest in comparing a technobabble corpus to the general corpus, or to a TBC from some years ago. Then we'd see that this sentence is comfy-cozy in one and funny-lookin' in the other, but then the whole of geekspeak is comfy-cozy to geekspeakers and funny lookin' to muggles.

  10. Terrence Enger said,

    September 15, 2012 @ 7:42 pm

    It is my impression that the verb "ask" is rarely used in the context
    of interaction with a computer.

    Looking at RFCs 1001 through 1500,
    , I find
    311 lines matching '\bask((s)|(ing)|(ed))?' but 4398 matching
    '\bask((s)|(ing)|(ed))?\b'. To eliminate hits on "request" as a noun,
    I repeated the search for the words with endings -ed and -ing, getting
    counts of 273 and 3398 lines.

  11. L said,

    September 15, 2012 @ 7:43 pm

    PS Would you prefer "Developer submits role-assume request?" It avoids that user-friendly "to."

  12. Ralph Hickok said,

    September 15, 2012 @ 7:50 pm

    “… requests to be excused from the ungrateful task” also sounds very odd to my ear.

  13. Guy said,

    September 15, 2012 @ 8:14 pm

    Totally understand that computers don't ask (vague memories of learning about interrupt requests in CS1 a couple of decades ago) but wouldn't the developer in this situation be a person? Does that make any difference to the technobabble?

    Would 'developer submits request to assume role' be wrong in this situation?

  14. djw said,

    September 15, 2012 @ 8:57 pm

    It seemed completely natural to me, maybe because I started with an assumption that , as L says, "requests" would be the appropriate way to say "ask" in a technobabble (or formal/stuffy?) setting, and that "assuming a role" would be a requisite step before the developer actually assumes that role. (I've used shared files just enough to know that in some cases, once one person has the "role" of "author," nobody else can jump in and start sharing the file without some negotiation about who has that "role.")

    "Ask to [do something]" seems perfectly natural to me, so "requests to…" does, too. My kids asked to go outside, asked to watch tv, asked to stop for a drink; maybe it's just a central Texas thing?

  15. William Ockham said,

    September 15, 2012 @ 9:20 pm

    This seemed total normal to me because as some who has been both the sys admin and the developer in these scenarios, I have a very strong expectation to see these statements in the standard UML-style with an actor performing an action. "Developer" must be the actor and "requests" must be the action.

  16. Brian said,

    September 15, 2012 @ 9:41 pm

    I've read the original post and all the comments, and I still can't tell what it is that's supposed to "sound odd" about the text in question. I mean seriously, it sounds perfectly normal. (Or at least it does if you grant the absention of articles, given the context of diagram captions.) Maybe I've been a geek too long?

  17. Steve Kass said,

    September 15, 2012 @ 9:53 pm

    I think Alan is on the right track. One doesn't typically use the word request when the request is to do something actively oneself. One might request permission to do something oneself (She requested permission to address the audience.), or one might request to be the recipient of an action (She requested to be served.) And while one might request to see evidence, the seeing is not an active thing. One would be less likely to request to look at evidence. (One might request a look at evidence, or request permission to look at evidence.)

    [ok] He requested permission to take a seat.
    [no] She requested to take a seat.
    [ok] He requested to sit. (He wants to be seated, not to do the "sitting down" motion.)
    [ok] She requested to be seated. (Means something a bit different, though.)
    [no] He requested (from the captain) to seat the customers.
    [ok] She requested (from the captain) permission to seat the customers.

    [(myl) This seems convincing. The nominal uses of "request to" mostly involve a request on the part of X for Y to do something, e.g. (from the recent NYT) "The Times Denies State Department Request to Remove Photo From Web Site"; "E.P.A. Denies an Environmental Group’s Request to Ban a Widely Used Weed Killer"; "Google said it would not comply with a White House request to reconsider the anti-Islam video that has set off violent protests". But there are some exceptions, e.g. "He did, however, say that Kerala’s request to start a prestigious Indian Institute of Technology was “under serious consideration” by the central government."]

  18. The Ridger said,

    September 15, 2012 @ 10:23 pm

    One should bear in mind that although "request" and "ask" have the same *meaning* this does not by any means guarantee that they will share the same *syntax*. English is full of words that mean pretty much the same thing, but you can't just replace one with the other in a sentence. For instance, "he gave the library his books" is fine, but "he donated the library his books" is not; "he told me the truth" is fine, but "he said me the truth" is not. In fact,it can be worse: while "he stopped to smell the roses" is fine, and "he ceased to smell the roses" is fine, they have radically different meanings.

  19. HP said,

    September 15, 2012 @ 11:00 pm

    What we're seeing here is a standard process document, where "process" is a technical term derived from Information Mapping ™, and adopted by a number of both open-source and proprietary content-management standards. What we don't see are the procedures followed by the individual agents in the process, and the user interface of the database client in which these steps are performed.

    As a general rule, when I document software, I try to choose words that mirror the UI, even if they would be infelicitous in nontechnical writing. And database clients are notoriously infelicitous.

    So, I can imagine a procedure written for developers that says:

    1) Log in using the username and password provided.

    2) From the Request menu, choose Assume Role.

    If that were the case, then the phrasing in the process topic is not only correct, it's the best of all correct phrasings, unless you want to bog down your documents with endless glosses, which only serve to make the software appear more difficult to use than it actually is.

  20. Charles A said,

    September 15, 2012 @ 11:46 pm

    The caterer requests to serve dinner at eight.
    The captain requests to sail at dawn.

    I find these just a little off. Strangely, the oddness dissipates if "request" is replaced with either verbs whose meaning is less bossy (suggests, proposes) or more bossy (demands). "Requests" seems to occupy a specially odd place on the spectrum of insistence.

  21. Steve Kass said,

    September 15, 2012 @ 11:49 pm

    The nominal uses of "request to" mostly involve a request on the part of X for Y to do something, . . . [but] there are some exceptions, . . ."

    I may be moving further from the original question, but this nominal use of request seems interesting in its own right.

    Is it possible that "Y denies X('s) request to [verb]" is entirely neutral on whether the request is for X to [verb] or for Y to? The two possible scenarios are

    1. (actual headline similar to one of your examples):

    Google [Y] Denies White House [X] Request to Censor Anti-Muhammed Film

    X asks, "Hey Y, can we [verb]?", and Y says "No, you can't." The White House wants to censor the film themselves. Google said "No, you can't."

    2. (your example):

    The Times [Y] Denies State Department [X] Request to Remove Photo From Web Site

    X asks, "Hey Y, will you [verb]?", and Y says "No, we won't." The State Department asks the Times to remove the photo. The Times said "No, we won't."

    In these and your examples, only one of the actors has the authority to [verb]. I can imagine cases where the meaning is ambiguous, though: "Sweden denies Norway's request to send peacekeeping forces." On the other hand, some nouns in the same position as request can't go either way: "Sweden welcomes/denies/ignores/accepts Norway's desire/offer to send peacekeeping forces" can only refer to Norway's forces; but "Sweden rejects Norway's plea to send forces" is probably a statement about Swedish forces.

  22. G said,

    September 16, 2012 @ 3:39 am

    I think there's a clue in that if the sentence is cast in the past tense, "Developer requested to assume role," it reads as if someone else is requesting that the developer should assume the role (i.e. "Developer IS requested to assume role").

    This supports the idea that "requests" doesn't "like" to take as an object an infinitive that expresses an active action by the requester. This makes a certain amount of sense, because why would I ask someone else for ME to do something?

    If that's what we want to express, we ought to explain how this other party comes into it, why we need to request anything at all and not just do it, e.g. "Developer requests PERMISSION to assume role."

  23. GeorgeW said,

    September 16, 2012 @ 5:05 am

    I think my 'request' prefers either a NP or 'that' complement. Anything else seems a little weird.

    1. Developer requests a role
    2. Developer requests that he or she assume a role.

  24. Peter Erwin said,

    September 16, 2012 @ 5:06 am

    "requests to be VERBed" is not quite the same as "requests to VERB," which I get a very ESLish-at-best vibe from…. I think part of the problem might be that "requests" as a verb will frequently (if not obligatorily?) take an NP object before the infinitive.

    I got the same vibe. It specifically reminded me of constructions like "This allows to analyze the data" which are clearly missing an NP object before the infinitive (e.g., "us", "the instrument"); I see things like that (usually with "allow") moderately often in my work-related reading (the astrophysical literature), where the majority of the writers are not native English speakers.

  25. Mr Punch said,

    September 16, 2012 @ 5:43 am

    You can't argue with technobabble – it's actually supposed to sound non-standard. But … "request" as a verb, in ordinary usage, takes a noun – you request some thing, you don't request "for" or "to." That's "ask." The standard phrasing using "request" might be "requests assignment to the role."

  26. The Ridger said,

    September 16, 2012 @ 6:10 am

    As for the original question, I think if all the jargon – if "requests" means "from the Request menu, select" – were capitalized, the audience would have absolutely no problem with it.

  27. L said,

    September 16, 2012 @ 6:56 am

    @Guy – Yes, Developer is (approximately) a person; and no, it doesn't make a difference. He's performing a logical operation, and in an old fashioned flowchart it doesn't really matter if he's a box, a bumptangle, or a stick-figure.

    [Where "logical" means "precisely defined and constrained" – it might in fact make no sense whatever, and it doesn't necessarily involve booleans or bitmasks, although those are also "logical operations." Precisely defined can still be ambiguous, it is merely that the ambiguity is precisely defined and constrained. If nerds spoke properly they'd be a teeny-tiny bit harder to spot, but the difference would remain negligible overall.]

    > Would 'developer submits request to assume role' be wrong in this situation?

    That would be fine. What would be unnatural to the jargon, but helpful to the normal, sane, nose-out-of-the-keyboard type who actually has to use the goddamn thing might be "The developer submits a request to assume a desired role for assessment and decision."

    However since the relevant actor is identified as "developer" we are better off cutting to the chase, as eg in the original. All those extra words just waste his time and might introduce errors because he would then have to examine them for precisely defined meanings that could alter the sense of "Developer requests to assume role." This is why the jargon uses the briefest possible phrasing, even if clumsy. Adding in all those "extra" words only opens the door to unintended meanings; one can never be absolutely certain that the documentation is bug-free, but one can take steps to control for it.

    Cutting to the chase myself, the writer values precise jargon meaning over smooth presentation. Are you surprised? He's a weenie, and proud of it!

  28. L said,

    September 16, 2012 @ 7:06 am

    @the Ridger

    Bear in mind that the "audience" is himself a "developer."

    If a football coach tells his team, "23 left red red over" that's one thing. If he adds in all the little words that would make that sentence parse properly and sound natural in ordinary spoken English… nevermind, probably can't be done; "red red over" is plainly a noun phrase serving an adjectival function modifying the noun phrase "23 left" which, although identifying a tabbed section of the playbook, is here actually employed as a command verb with a plural object.

  29. Michael said,

    September 16, 2012 @ 7:15 am

    I agree with Alan and Steve that "request" usually takes a passive or a noun as a complement. All of their examples sound like normal English. But there is a third possibility that may have been overlooked: "that + subjunctive."

    In the original context, "Developer requests to assume role," sounds weird. Possible edits are:

    (Passive) Developer requests to be granted role.
    (Noun) Developer requests role [from ProductX].
    (Noun) ?Developer requests assumption of role.
    (Subunctive) Developer requests that he assume role. (Substitute "he or she", "s/he", or "(s)he" to taste.

    Practically, my best advice would be to write, "Developer asks for role." But if, for technical reasons, "requests" must be used, "Developer requests role," seems best.

  30. Michael said,

    September 16, 2012 @ 7:18 am

    I meant to write, "Developer asks to assume role."

  31. leoboiko said,

    September 16, 2012 @ 7:35 am

    Just agreeing with other people that, after a decade reading technical documentation, “[subject] requests to [verb noun]” sounds unremarkable. Some examples found in my system docs:

    > The Client requests to mount /tftpboot/ […]

    > The system entry for site drop would now give serial1 as port name, but request to use it at 9600bps only.

    > A client may request to mount a directory from a remote host on a local directory just the same way it can mount a physical device.

    > This requests to the kernel (decompressor and early kernel) to not write early messages that require accessing the display hardware directly.

    > Request to do a scan. If returning zero, the scan request is given the driver […]

    > If the site requests to be forwarded all news you receive yourself, […]

    (To be fair, “issue a request”, “send a request” and the like do seem more common. I guess it’s an easy step to verb “build and send a request” as “to request”.)

  32. jonathan said,

    September 16, 2012 @ 11:57 am

    I think Steve Kass' explanation rings true, and might re-write it as

    Developer requests to be granted role.

    The passive fits his explanation, and, additionally, 'granting a role' is better technobabble than 'assuming a role', as 'grant' is an actual database management command.

  33. Coby Lubliner said,

    September 16, 2012 @ 12:11 pm

    It seems to me that "request" follows different rules as a noun and as a verb. Since "ask" has no verbal noun of its own, "request" has taken on that role, so we have (N) "request for" (e.g. "request for proposal") as the nominalization of (V) "ask for", since one does not, in normal English, (V) "request for" something. In fact (V) "request" and "ask" are not interchangeable; when "request" takes a direct object, it's the thing one wants, but with "ask" this requires "for", while the direct object of "ask" is the person(s) to whom the request is made (unless the reference is to a question, not a request), though it may be preceded by "of" (I ask you = I ask of you). All in all the syntax, semantics and pragmatics are murky territory, the kind nitpickers has best stay away from.

  34. Mike E. said,

    September 16, 2012 @ 12:27 pm

    To me, this concise technical language sounds normal in the context.
    of computerized systems.
    I would suggest that
    "Developer requests to assume role."
    is analagous to
    "X applies to join club."

    In a system where the assumption of a role requires authorization, assuming a role requires action by both parties, like joining a club, so the rules might be slightly different from those applying to other verbs.

    Also, in this sort of context, I think you may get slightly unusual language because of the need for the same word to be used consistently by people and computer systems . The word "request" is being used as a word in the English language but also, to some extent, as a word in a semi-artificial language (even though "request . . ." may be seected from a menu rather than written out, as in a traditional programming language)

  35. L said,

    September 16, 2012 @ 12:30 pm


    > To be fair, “issue a request”, “send a request” and the like do
    > seem more common.

    Ah, but here is exactly where adding words misleads the technobabble reader!

    To a software wonk, "send a request" is a distinct subpart of "request." It is the part analogous to mailing the letter containing your request, and it is a process unto itself worthy of discussion.

    If the original writer meant to communicate that sending it was sufficient, he would have said so; and by so doing, he would have assured Developer that this is all that matters. Developer no longer cares whether the request is received; you have precisely and unambiguously instructed him to send it, and that sending alone is all that matters.

    It sounds like I'm slitting my own throat with Occam's razor, and so I might well be doing. Nevertheless, if done correctly, a technobabbler includes a word it's because that word is needed, and if he omits a word it's because the omission is needed.

  36. L said,

    September 16, 2012 @ 12:37 pm

    > All in all the syntax, semantics and pragmatics are murky territory,
    > the kind nitpickers has best stay away from.

    Unless presented in Backus-Naur Form.

    Computers are the nitpickiest nitpickers that ever picked a nit, and those who tend and feed them and grease-monkey around underneath them had best develop the habit.

  37. Steve Kass said,

    September 16, 2012 @ 2:25 pm

    Coby Lubliner writes

    Since "ask" has no verbal noun of its own

    Actually… (His remarks are nevertheless valid.)

  38. Chris said,

    September 16, 2012 @ 8:33 pm

    It sounds like a description of the unix program "sudo" where you can do an action as if you were another (presumably with more rights) user. But you don't "request" you just do it. I suppose there's a request aspect as it could be turned down and it isn't immediately obvious what you can and can't do.
    To me this sounds like it was written for a flowchart so that there can be a "granted" and "denied" path.

  39. bob edgar said,

    September 17, 2012 @ 4:19 am

    I believe the developer submits a request (to or via the ProdutctX software agent) to assume the role (to acquire sufficient rights to perform the task).

    As mentioned up thread, this is similar to sudo but more fine grained.
    Thus "developer submits request to assume role" would be my choice.

  40. L said,

    September 17, 2012 @ 9:08 am


    > To me this sounds like it was written for a flowchart so that
    > there can be a "granted" and "denied" path.

    You're right on the trail here; if it's a request, that means it might be granted or denied. If it were a non-deniable "request" the verb would be, depending on context, "commands" or "asserts" or "performs" or something that implies no assessment, merely obedience.

    Of course it's always possible that "commands" will fail, but that's the difference between "wasn't permitted" and "didn't work." (Things do fail in computers, now and again, or so I've heard tell.)

  41. Dave K said,

    September 17, 2012 @ 10:43 am

    Getting back to Steve Kass's comment on the 15th, further support for his idea may be that the form is very common in the passive:
    "I was requested to leave the premises."
    "The police were requested to look at the evidence."
    where a passive recipient of the request is asked to perform an action.

  42. Barbara Partee said,

    September 17, 2012 @ 11:40 am

    Ray Jackendoff had the earliest published discussion and analysis of this kind of behavior with 'ask' and 'request' in his 1972 book Semantic Interpretation in Generative Grammar. He was discussing which NP in the main clause "controls" the infinitive verb in the lower clause, when there is one, in a wide range of sentences, starting from the well-known contrast between "subject control" in
    (i) John promised Mary to come home on Tuesday
    and "object control" in
    (ii) John asked Mary to come home on Tuesday.

    And he noted exceptions to object control with 'ask' in some of the kinds of examples discussed above, e.g.
    (iii) The student asked the teacher to be allowed to leave the room.
    He noted that in those cases there was a strong effect of the semantic role of the subject of the infinitive — "X to be allowed to leave the room" — X is syntactic subject, but semantically X is not an agent, but rather a 'recipient' of permission.

    He found cute interactions in examples with nouns like permission:

    John gave permission (to Mary) to leave
    John received permission (from Mary) to leave
    — in the first one John is not the leaver but the 'authority-figure', in the second John is the leaver.

    In the example that started this post, we have the verb 'request', which doesn't take a direct object as easily as 'ask' does, but is otherwise pretty similar. And what we see is that in addition to the possible omission of mention of who was asked to X or who was requested to X, the example seems to have something like an implicit "be permitted to". That seems reasonable enough if the context makes it clear that the request is a request to be permitted to do something, and in this technobabble context that may very easily go without saying.

    I think Alan was indeed on the right track and Steve Kass basically nailed it; just wanted to note that Jackendoff discovered it (as far as I know) and also nailed it, 40 years ago. I've been retelling his story from memory (it was memorable!) and may have some details wrong. What made it so memorable was the interplay of syntax and semantics (and pragmatics and real-worlds knowledge) in determining how we interpret the unexpressed subjects of embedded infinitives. Cool stuff.

  43. L said,

    September 17, 2012 @ 12:24 pm

    @Barbara Partee

    > in this technobabble context that may very easily go without saying.

    That's all I'm saying. How it functions elsewhere, is a topic I've intended to be silent about.

    Essentially in this jargon, a "request" can be refused for cause – if some condition is not met, it will not be granted. A "command" conversely is a demand that must be met if possible.

    "Developer" in the original is a technobabbler (as any good developer ought to be) and can be expected to appreciate this. He makes the request, and then either some automated process, or some person, or some combination, will assess it and decide whether or not to grant it.

    Technobabblers also speak of "real time" as though the alternative is "unreal time" or "imaginary time" or even "virtual time." Shrug.

    We do it for the boo.

  44. mike said,

    September 18, 2012 @ 8:23 am

    For all those in the "technobabbler" thread here, the context here is web services, in which all interactions occur via request/response cycles. The use of "assume" and "role" is strongly suggested by the underlying API, which includes an AssumeRole call (the request), which as someone was musing, results in either an Allow or Deny response. Steps 3 and 4 of the sequence are not UI-based interactions, altho the other steps can be performed via a UI wrapper on the API.

  45. L said,

    September 18, 2012 @ 11:41 am

    @mike, nice catch!

  46. Jens Fiederer said,

    September 23, 2012 @ 6:27 pm

    Speaking as a developer, "developer requests to assume role" sounds completely unremarkable to me. Jargon isn't expected to be meaningful to people outside the specialty.

RSS feed for comments on this post