How to figure out what someone means, according to science

The science behind the words

Understanding the relationship between words and emotion has been part of a major undertaking for me and my colleagues Loran Nordgren at Northwestern University’s Kellogg School of Management and Matthew Rocklage at the University of Massachusetts. Together, we’ve been trying to understand whether people’s words can provide insight into the strength of their emotional reaction to a person or product.

4. Yandex Images

Yandex Images is the app to use for people looking to find an unknown person’s name and details with just a picture.

It’s clear that the developers did their jobs well here. As one of the most superior reverse search tools globally, Yandex Images makes image searching immensely flawless.

At some point, it even looks like you don’t have to do anything at all. Like you, just sit there, and the app imagines what you were thinking and delivers the images.

Like really, it’s so easy to handle.

You just need to drag and drop an image or paste its URL in the search box and voila. Yandex Images takes it from there. Hit the search button, and you will find a list of all the similar images to the one you just searched for.

It only gets better from there. Yandex Images has also added a feature that allows users to search for images in different resolutions. Images can now come in small, medium, and large sizes in your search results.

So, here’s a completely easy to use reverse image search engine that you can use without signing up. Did I mention that it’s also totally free but still manages to deliver flawless results?

Frankie’s Take:

I do love Yandex. Consider using the Yandex Browser with the app to get a complete immersion of its experience. You will come back to thank me later.


4. Avoid Saying the Name for as Long as Possible

If you’ve met and spoken with this person several times already and you’re still not sure, you probably don’t want to embarrass yourself by getting it wrong.

I come across this issue a lot. I’m so focused on the conversation—especially when I’m nervous in interviews—that I’m never focused enough to take in the pronunciation. If you’re one-on-one with the person, it’s pretty easy (and more natural) not to address the person by his or her name.

Just make sure the next time he or she says it, you actually listen.

Details Examples

  1. Meaning should be understood from the same line. Switching of contexts takes time and distracts from thinking on a topic. Do not expect jumping of eye back and forth as a standard way to understand your code. Do not expect that the correct meaning can only be understood from the definition, people will unlikely to go to the definition and will work with their guess instead. 

  2. If meaning cannot be understood from the same line – make it explicitly visible. Place a comment to describe what is happening and why, and provide a reference for further reading if needed. 

  3. Do not use one-two-letter-per-word abbreviations, even if this is very local. Eventually it may become bigger and, even if not, such code is not easy to understand from this line only, you need to get back to definitions of these variables and spend extra time to understand what is going on correctly. Abbreviations which are agreed convention is an exception, but these should be rare. 

    Bad: wcf.add(cr);   

  4. Prefer English over formal (but keep it formally correct). Name things so they can be read naturally in English. Avoid compound noun form if it can be misleading. 

    Badbool selection_all() const; Good: bool all_selected() const 

    Bad:  file_unable_to_parse, Good: unable_to_parse_file, 

    Bad:  DesignTypeNeedToOpen(); GoodTypeOfDesignToOpen(); 

    BadSetAbstractGeometryStatus(); // What is abstract geometry status? Status of abstract geometry? abstract status of geometry? something else? Just by reading the name you cannot understand what it really is and is made for. In most cases it means that the name is wrong. 

  5. Narrow scope of usage and visibility.  Create variables as close to their usage as possible. This improves readability and decrease coupling of code. This helps with having simpler names, as narrow context of usage requires less specifics to distinguish entities from each other. This will also tell a reader that there is no need to check if this variable is used anywhere else. Use code blocks and namespaces for that. 

    Violating this rule harms code understanding and harms design, since others may use variables in an unintended way, creating more coupling between modules than needed. 

  6. Do not create synonyms, use one term for everything related to what is meant by this term. You need to name one entity the same way everywhere. This way people will faster understand code and will be more careful when noting differences in names – they will expect the meaning is also different.  

    Bad:  char console[] = "STD_OUT"; Good: char std_out_name[] = "STD_OUT"; 

    BadQLineEdit* rundir_editor_ = nullptr;
    QPushButton* select_dir_ = nullptr; // is dir different from rundir?
     GoodQLineEdit* rundir_editor_ = nullptr; 
    QPushButton* select_rundir_ = nullptr;

    Badreturn RecentMenuItemTextAndTooltip(mru_text, menu_item_tooltip); // all names refer to one entity using different wording 

  7. Do not use shortenings of words as a main method. It leads to overly relaxed attitude to naming and indulges to the reluctance to find simpler and shorter terms. It also adds cognitive complexity, because it leads to non-intuitive shortenings.

  8. Remove unnecessary prefixes and postfixes.  

    Bad:  bool is_visual_mode() const { return visual_mode_; } Badbool get_visual_mode() const { return visual_mode_; } Good: bool visual_mode() const { return visual_mode_; } 

  9. Object should be named per its purpose and data, not per its type. 

    Bad: Coloring coloring_;  Good: Coloring custom_colors_; 

  10. Use inline comment to identify meaning of arguments passed by value, so the line can be understood without checking the function definition. 

    Goodtraits.set_color(color, true /*custom*/); 

  11. If a function does some things, it should be named with a verb. 

    Bad:  void JobsQueueUpdate(); Good: void UpdateJobsQueue(); 

  12. If a function is a simple getter of a parameter or a property, it should be a noun or an adjective. To preserve that in some conventions simple getters can be named using the same style as variables, e.g. in snake_case(). 

    Bad: string GetName() constGood: sting name() const

  13. Function name should not contain argument type in general, because each function call will already mention its argument. 

    Bad: bool ValidateRectangle(const Rectangle&) const; Good: bool Validate(const Rectangle&); 

  14. Function name should not mislead about what it does.  

    Badbool FilesAreAvailable(files) { // may set expectation that all files will be checked 
      for file in files: 
        if reader.open_existing(file): 
          return true;  // but it only checks if at least one file is available
      return false; 

  15. Name function by its resulting effect, not by one of possible applications  

    Bad:  void RunVisualDebugger(char* argv[], int* exit_status) { 
      forksys(argv, exit_status); 
     Goodvoid Fork(char* argv[], int* exit_status) { 
      forksys(argv, exit_status); 

  16. Avoid putting implementation in name 

    Bad:  void CallLsfork(char* argv[], int* exit_status) { 
      lsforksys(argv, exit_status); //can change in future 
     Goodvoid Fork(char* argv[], int* exit_status) { 
      lsforksys(argv, exit_status); 

  17. Predicates should be named such that they will be interpreted as predicates: having true/false possible states, not multiple states, are not confused with an instance of a class. 

    Badfailed_state = True # name assumes multiple failed values; also, is this about politics and sociology? Good: failed = True # `if failed:` is perfectly readable 

    Bad<instance>.worker_ = True # member ‘worker_’ can be read as instance of Worker class, not as predicate in other contexts Good<instance>.is_worker_ = True # no misinterpretation is possible 

    Badis_active_user = True # if this is not a property, but boolean local data holder Badactive_user = True # like a variable with User instance Gooduser_is_active = True 

    Badat_least_one_running_instance = True Goodat_least_one_instance_is_running = True 

  18. Do not sacrifice meaning over beauty. 

    Bad// note that all names are rather small 
    class Status(Enum): 
    SENT = 0 
      ACCEPTED = 1 
      REFUSED = 2 
      STARTED = 3  
      COMPLETED = 4 // successfully? 
      FAILED = 5 
      IN_PROGRESS = 6 
      ALIVE = 7

    Betterclass Status(Enum): 
      SENT = 0 
      ACCEPTED = 1 
      REFUSED = 2 
      STARTED = 3 
      SUCCESSFULLY_COMPLETED = 4 // long, but clear 
      FAILED = 5 
      IN_PROGRESS = 6 
      ALIVE = 7

  19. Meaning should be understood without knowing of rest associated namesClassification should be nonoverlapping. This is because such names will be broadly used in contexts alone, which will mislead readers about their meaning. 

    Bad:  FINISHED = 5 // successfully? prematurely? FAILED = 6 // only this line helps to understand previous line meaning, and we are still not sure if something which is FINISHED can also be FAILED GoodSUCCEEDED = 5 FAILED = 6 

  20. Singularity and inconsistency in décor and formatting attract attention and slows down reading. Rules of formatting are created also for faster reading. If you don’t have any special reason, do not break the formatting rules. 

    Bad: //break a rule of one blank line between function bodies (if it is set) if the functions are similar 

    Bad: void StartUp(); 
    void PROCESS_DATA(); // why capitals?

  21. Avoid misleading terms. 

    Bad:  QCheckBox* check_geometry_; // using “check” to show that it is a checkbox can mislead a reader that this means “test geometry for errors”, hower it just enables showing of it 

  22. Do not mix more and less general terms as synonyms. 

    BadDesignLoadStatus error; // status can be either error or success or something else, in practice error variable may hold status of success

  23. Name associative containers such that one can understand their two-fold nature.  In some conventions you may use “to” for that: key_to_value 

  24. Compound nouns are good if they are not ambiguous. 

    Good?: id_of_task_of_parent_stage Good: parent_stage_task_id

5. Start with a keyword focus

There is a long-standing debate about whether or n

There is a long-standing debate about whether or not keywords in a domain name will help your blog with SEO.

According to Google’s John Mueller, there’s not a significant increase in visibility (if any) with keyword domain names.

What is a keyword domain (blog name)?

A keyword domain is when you choose a blog name that incorporates a main keyword you plan on blogging about directly into your blog’s URL. For example, if you wanted to start a blog about traveling the world, a keyword domain could be something like or where you’ve got either the exact word “travel” or a closely-related term included directly in your domain name.

Pre-2011, a keyword in your domain did tend to increase your SEO rankings.

Since then, Google has consistently changed its algorithm to devalue keyword blog names—so that they don’t automatically rank higher.

Fast Method

Fast method is for usage while writing a draft or a small part in an already established code. 

  1. Describe an entity “using your words” What is your intention? How would you use it?  

  2. Use terms from the context/existing vocabulary to compile a derivative name Do not create synonyms and do not use different wording for the same thing. 

  3. Check if the entity can be properly understood from the same line it will be used inDo not imply that the reader has go to the definition/somewhere else to understand it correctly. Switching between contexts is for finding details, not for finding the idea. Switching to another context make you lose the original one. 

  4. Ask yourself: can others misinterpret the name?Even if the misinterpretation will happen in 5% of cases it may lead to hours of debugging and worsen maintainability. 

  5. Check readability, prefer English over formal. A text that can be easily read is easier to understand. 

How to figure out someone’s Instagram password effortlessly by CocoSpy

One more tracking software worth mentioning in this guide is CocoSpy. This is another effective tool if you need to find out someone’s Instagram password. It provides keylogging features and monitors calls, messages, real-time location, and social media browsing. 

So, let’s see simple steps to figure out someone’s Instagram password via CocoSpy

As always, to get started, you need to get an account on CocoSpy website. Go to the main page and click Sign up now. You will need to register as a new user of the platform. Once done, CocoSpy will guide you on how to set up the software on the target device. Make sure you can get the target device in your hand for a few minutes. This is an essential step to have tracking software installed. 

Step 1. Register with CocoSpy 

The key step to get started is to create your account. You need to use an email and a secure password. Then you have a chance to select a target’s phone model and configure your new account settings. CocoSpy app supports both platforms – Android and IOS devices. So in case you have a phone you want to spy on – CocoSpy is a perfect choice since it doesn’t require jailbreaking the target phone.

Step 2. Next step – install Cocospy app

Step 2. Next step – install Cocospy app

The next essential step is to install the CocoSpy app on the device, you want to hack. As already mentioned, you need to take your partner’s or child’s phone in your hands and install the app on the target device. CocoSpy will provide you with a step-by-step guide on how to install their app. You will need to follow a dedicated link and download the application on the android device. After it takes only a few minutes before you can start monitoring your target phone.

Step 3. Track someone’s Instagram though the control panel on Cocopy 

Finally, once all of the steps are completed, you can visit your CocoSpy dashboard and see everything that is going on in your spouse’s or kid’s device. Out of all the features available on your dashboard, go to the keylogging section. This is the place where you can find out someone’s Instagram password. Apart from that, you can always view all the ongoing activities on Instagram or other social media by going to social apps tag. Make sure for the first use, your target device needs to have internet connection, and the software will need a few minutes to download all the data to your dashboard. 

Feature Posts

iCareFone Review and Its Best Alternative

Spyzie Review – Everything to Know About Spyzie

mSpy Reviews and Top Alternatives in 2022

Cocospy Review – Everything to Know About Cocospy

Spyic Review | Spyic Pros and Cons & Its Best Alternative