"Over the months after our first meeting, I had all sorts of interactions with Steve about Mathematica. Actually, it wasn’t yet called Mathematica then … For a while he wouldn’t suggest anything. But then one day he said to me: 'You should call it Mathematica.' … he told me his theory for a name was to start from the generic term for something, then romanticize it." (Wolfram, Idea Makers)

https://en.wikipedia.org/wiki/Philosophi%C3%A6_Naturalis_Pri...

(Though in this case the intended meaning is probably a little closer to "build mystique surrounding.")

I agree with your point about naming a product to cover the whole field. It does seem off-putting--although I think examples of it are pretty rare. (In fact, I can't think of any off hand...) In this case, "Mathematica" is far enough from anyone's ordinary English usage that it doesn't fall into that category for me. I don't believe I've ever heard anyone say the word "Mathematica" to refer to anything other than the product. It would be a different story, of course, if it were just called "Math."

Ok, I see. But it is not true for a large(not english speeking) part of the world. It is like calling your "pineapple" software Ananas[1], you just romanticize it in a small region while interfere with traditional word usage in the other part. [1] https://www.reddit.com/r/MapPorn/comments/2pp0s6/pineapple_p...

IIRC Microsoft did this (Word, Windows) with hope that the press would feel the need to use “Microsoft” to disambiguate, improving brand recognition.

[1]: http://www.joelonsoftware.com/items/2005/10/17.html

    def a(b):
        m = 0
        return b(m)

    def a(b):
        m = b(1)
        return m+7

    compose : (a -> b) -> (b -> c) -> (a -> c)
    a `compose` b = \x -> b(a(x))

    partial3 : (Integer -> Integer -> Integer) -> (Integer -> Integer)
    partial3 f = f 3
    map : [a] -> (a -> b) -> [b]
    map [] f = []
    map (x:xs) f = (f x):(map xs f)

  compose :: (b -> c) -> (a -> b) -> a -> c
  compose f g x = f (g x)

Also check out the journal Formalized Mathematics [2]. The idea is that every major new theorem in a paper has a machine verified proof attached.

[1] http://mizar.uwb.edu.pl

[2] http://mizar.uwb.edu.pl/fm/

[1]: http://mattneary.com/Quizzical/

As a simple example:

1. Create customer

2. Add tokenized card to customer

3. Charge the card

Step 2 requires the HREF/ID of the customer. Step 3 requires the HREF/ID of the card.

The scenario: https://github.com/balanced/balanced-api/blob/master/feature...:

  Scenario: Push money to an existing debit card
    Given I have sufficient funds in my marketplace
    And I have a tokenized debit card
    When I POST to /cards/:debit_card_id/credits with the JSON API body:
      """
      {
        "credits": [{
          "amount": 1234
        }]
      }
      """
    Then I should get a 201 Created status code
    And the response is valid according to the "credits" schema
    And the fields on this credit match:
      """
      {
        "status": "succeeded"
      }
      """
    And the credit was successfully created

For some reason, though, I feel like the natural language would actually intimidate me. Where are ideas like "sufficient funds" defined?

  Given(/^I have sufficient funds in my marketplace$/) do
    step 'I have tokenized a card'
    @client.post("/cards/#{@card_id}/debits", {
                   amount: 500000
                 })
  end

  Given(/^I have a tokenized debit card$/) do
    @client.post('/cards',
      {
        name: "Johannes Bach",
        number: "4342561111111118",
        expiration_month: "05",
        expiration_year: "2015"
      }
    )
    @debit_card_id = @client['cards']['id']
    @client.add_hydrate(:debit_card_id, @debit_card_id)
  end

  All
    a = b
    Any
      All
        c = d
        d = f
      c = e

  a = b
    c = d
      d = f
    c = e