
Is this my interface or yours? (2016) - stared
https://medium.com/@jsaito/is-this-my-interface-or-yours-b09a7a795256
======
DavidWoof
This is basically one individual's musing on the topic of naming things in a
UI. I don't know the author at all, so he might have tons of insight or he
might just be making stuff up, I have no idea.

But at this point in time, why aren't we reading about studies rather than an
individual's musings? I'd much rather read that x% of individuals didn't
immediately make the connection between "my computer" and their workstation in
testing at MS.

One reason Code Complete has always been my favorite programming book is that
he backed up his suggestions with real numbers from serious studies. I'd love
to see similar types of writings in the design field.

~~~
chickenfries
So, this type of research exists, it's just not written about in Medium posts
like this :P

But I agree, I much prefer writing based on research rather than some
designer's reckons that aren't clearly labeled as reckons.

~~~
jacobolus
This is a kind of confusing use of the word “reckon”, which is typically a
verb and means to calculate or come to a conclusion after making a
calculation. (Etymology is from the word in old germanic languages for
“count”.)

You’re using it as a noun to mean something more like “guess” or “personal
opinion”. I guess stemming from informal uses like “I reckon I could ...”
(used without any calculation in sight, often with an exaggerated or bragging
rest of the sentence).

~~~
chickenfries
Yes, that's exactly what I meant, thanks for clarifying. I'm not sure where I
picked up using reckon as a noun, I think it might have been from an
Australian. In my mind, a reckon is a quick opinion given without much rigor
behind it, coming from "the gut" or experience.

~~~
lgas
I reckon most people could tell what you meant from context.

~~~
jacobolus
That’s fair enough, and I’m not trying to attack chickenfries, but I would
still like to push back against this usage. There are already dozens of good
words and phrases for this concept. Adopting a verb with nearly the opposite
meaning and using it as a noun is a weird choice even if it’s nominally
comprehensible in context.

~~~
chickenfries
Hm, I'm not going to stop using it because I like the way it sounds.

However, I do like it when people make comments like your original comment on
HN, because now someone who comes across my comment and doesn't understand it
will learn something by reading your comment.

------
tscherno
In German windows versions "My Computer" was translated with "Arbeitsplatz"
which means place of work

~~~
yorwba
As opposed to "Desktop" which was left untranslated. Ubuntu translates it as
"Schreibtisch", which my mother found pretty confusing, maybe because she
doesn't speak English.

~~~
denisw
Ubuntu has probably emulated macOS here, which translates the Desktop as
"Schreibtisch" as well.

------
stared
Another thread in this "cognitive UX / extended phenotype" topic:

* [https://ux.stackexchange.com/questions/4348/your-vs-my-in-us...](https://ux.stackexchange.com/questions/4348/your-vs-my-in-user-interfaces)

------
fenwick67
I think it's amusing that it's no longer "My Computer" and now it's just "This
Computer". The computer is no longer mine I guess, which aligns with
Microsoft's push for subscription models.

------
gpvos
Makes me think of the classic "Take me, I'm yours" text that reportedly was
used as the login text on terminals at Stanford:
[http://www.oocities.org/hsingmin/humor/takemeimyours.htm](http://www.oocities.org/hsingmin/humor/takemeimyours.htm)
.

------
ejdyksen
Windows 10 now uses the first person plural ("we") to talk to users, which I
always thought was an interesting choice. Things like:

    
    
      We're setting things up for you
      We can't sign into your account
    

Etc...

~~~
fencepost
This might be out of date, but I think the installer still uses "I" \- "I'm
happy to see you" and such.

If you imagine it in a creepy voice it completely changes the tone of an
install.

Edit: thanks autocorrect

~~~
kaybe
It comes across creepy to me and people around me all by itself. Maybe we
played to much Portal.

------
huhtenberg
With all the shenanigans Microsoft is trying to pull with Windows 10 they
obviously couldn't keep calling it "My Computer", because that's be... well...
a blatant lie.

~~~
doodpants
I never liked the "My" moniker, because I feel like the label is speaking to
me from the computer's or the vendor's point of view, rather than my own. So
for me, it would feel even _more_ appropriate for Windows 10 to continue using
it, to remind users who _really_ controls their devices.

------
fizixer
Off-topic (or maybe not), the title reminds me of a coding API/interface
design issue I often encounter, and I'm never able to resolve without finding
whatever I end up with as ad hoc at best.

To give a contrived example (note: the example is about a pre-condition-like
check, but that's not always the "intermediate action").

Let's say I design a sort function. It takes a linear collection (like an
array or list) and returns the same (sorted). Let's say I need to carry out an
intermediate action (intermediate as in, between the calling code before
sorting and the sorting algorithms itself) that I need to check if the
collection is already sorted, and return the collection as it is without
invoking the sorting code.

The design issue I have is: should the check be inside the sort function or in
the calling block just before the sort call?

It might feel like the validation squarely belongs inside the sort function
but, besides this example being a bit contrived, there is a solid counter
argument to be made that 'the job of the sort function is to sort'. If I am a
sort function, I sort. You give me a collection, I return a sorted collection.
Don't encumber me with extra checks of validating if the collection is worth
sorting, or some other stuff.

This is a general problem not specific to coding. In an interface between a
manager or a team-lead and the engineer, there are often situations when the
engineer says "It's my job to do this, you give me the task in this, such-and-
such prepackaged, form and I will return you the results." Later, the lead
wants the engineer to improvise a bit and do this extra thing, an intermediate
action, before actually doing the task. This "intermediate action" fits
squarely in neither the lead's or the engineer's roles. Ignoring the tilted-
balance-of-power in which usually the engineer ends up doing what's slightly
vague, which I consider an ad-hoc solution, the engineer could just as well
say "Why don't you do it?".

I guess there's a 3rd possibility in which a 3rd party does it. So in the case
of sort, we have a pure-sort function, which is called by "an outer-sort"
function which has all the checks, and if they all pass, only then the pure-
sort is called. And that outer-sort is called in the calling code instead of
calling pure-sort directly.

Which one of these is the best? most optimal? correct? What should even be a
criteria for judging the implementation of such a scenario? I don't know.

edit: another example, you have an in-place sort impl. and a non-in-place sort
impl. In the calling code you wish to switch between the two making sure it's
always non-in-place. Should you wrap the in-place sort in a make-a-copy-
before-sorting wrapper? or should the in-place impl do it itself just before
returning? or should the calling code handle the two types of sort with some
if check?

