mitt

For every $1 billion remitted, 117 Indians die in 6 Gulf nations

The embassies in Gulf countries have not been forthcoming in providing data under RTI on the number of deaths.




mitt

India to retain top position in remittances with $80 billion: World Bank

India is followed by China ($67 billion), Mexico and Philippines ($34 billion each), according to World Bank.




mitt

Remittances show poll bump, again

ET looked at data from 1990-91 to present, and the remittance-elections bump is evident.




mitt

India highest recipient of remittances at $79 bn in 2018: World Bank

India was followed by China (USD 67 billion), Mexico (USD 36 billion), the Philippines (USD 34 billion), and Egypt (USD 29 billion).




mitt

India was the top recipient of remittances worldwide in 2018

India was the top recipient of remittances worldwide in 2018, data from the World Bank shows. The remittances were boosted in part by migrants from Kerala sending.




mitt

With $78 billion, India still highest overseas remittance receiver

India continues remains the top recipient of remittances, with its diaspora sending back $78.6 bn in 2018.




mitt

'Nothing adverse' in overseas remittance data, says CBDT

“The Directorate of Intelligence & Criminal Investigation (I&CI) of the income tax department during August and September 2019 obtained LRS data from several banks in Mumbai and Delhi and verification of the top 100 cases was undertaken. However, nothing adverse was found,” said the report, which was submitted to SIT probing black money earlier this year.




mitt

Fino Payments Bank logs 80 per cent plunge in domestic remittances

The payments bank sees average monthly remittances of close to Rs 5,000 crore from daily wage earners working in various factories, construction sites, small businesses, plumbers, carpenters, cab drivers, among others.




mitt

Tata Motors gets nod from board constituted committee to raise Rs 1,000 crore via NCDs

These will be issued in three tranches of Rs 500 crore, Rs 300 crore and Rs 200 crores with redemptions due on September 30, 2022, November 28, 2022 and December 29, 2022 respectively, it added.




mitt

SEC Announces Investor Advisory Committee Meeting Focusing on COVID-19

The Securities and Exchange Commission's Investor Advisory Committee will hold a public meeting on May 4, 2020, by remote means.  The meeting will begin at 2 p.m. ET, is open to the public via live webcast, and will be archived…




mitt

Small Business Capital Formation Advisory Committee to Discuss the SEC’s Capital Formation Proposal on May 8

The Securities and Exchange Commission today released the agenda for the Friday, May 8 meeting of its Small Business Capital Formation Advisory Committee, which will be hosted via video conference. The Committee will discuss the Commission’s recent…




mitt

SEC Investor Advisory Committee to Meet Virtually on May 21

The Securities and Exchange Commission's Investor Advisory Committee will hold a public meeting on May 21, 2020 by remote means.  The meeting will begin at 10 a.m. ET, is open to the public via live webcast, and will be archived on…




mitt

Chinese National Pleads Guilty to Committing Theft of Trade Secrets

TULSA, Okla. – Hongjin Tan, a 35 year old Chinese national and U.S. legal permanent resident, pleaded guilty Tuesday in federal court to committing theft of trade secrets from his employer, a U.S. petroleum company.




mitt

Operational Changes to Backcountry Permitting Procedures Planned at Grand Canyon National Park

https://www.nps.gov/grca/learn/news/news_2009-11-20_procedure_change.htm




mitt

Vehicles over 20 feet in length will not be permitted on Cape Royal Road for the duration of construction.

Grand Canyon National Park has begun improvements to Cape Royal Road on the North Rim. Beginning September 3, 2013 Cape Royal Road from Roosevelt Point to Cape Royal Point, at approximately mile 11.5, will be closed for repaving. Vehicles over 20 feet in length will not be permitted on Cape Royal Road for the duration of construction. https://www.nps.gov/grca/learn/news/updated-road-improvements-to-temporarily-close-portion-of-cape-royal-road-on-the-north-rim-of-grand-canyon-national-park.htm




mitt

Sexually transmitted infections surveillance reports




mitt

New Intermittent Fasting Program Shown to Suppress Cancer and Metabolic Disease in Mice and Humans

This new research has outlined yet another benefit to intermittent fasting—that may arise from the time you eat, rather than what you eat.

The post New Intermittent Fasting Program Shown to Suppress Cancer and Metabolic Disease in Mice and Humans appeared first on Good News Network.




mitt

Canadian Olympic Committee

The Canadian Olympic Committee is the official site providing information about coaches and athletes with media and links, and is the private, non-profit organization representing Canadian athletes in the International Olympic Committee (IOC) and the Pan American Games.  




mitt

Committed to the wrong branch? -, @{upstream}, and @{-1} to the rescue

I get into this situation sometimes. Maybe you do too. I merge feature work into a branch used to collect features, and then continue development but on that branch instead of back on the feature branch

git checkout feature
# ... bunch of feature commits ...
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# deploy qa-environment to the QA remote environment
# ... more feature commits ...
# oh. I'm not committing in the feature branch like I should be

and have to move those commits to the feature branch they belong in and take them out of the throwaway accumulator branch

git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

Maybe you prefer

git branch -D qa-environment
git checkout qa-environment

over

git checkout qa-environment
git reset --hard origin/qa-environment

Either way, that works. But it'd be nicer if we didn't have to type or even remember the branches' names and the remote's name. They are what is keeping this from being a context-independent string of commands you run any time this mistake happens. That's what we're going to solve here.

Shorthands for longevity

I like to use all possible natively supported shorthands. There are two broad motivations for that.

  1. Fingers have a limited number of movements in them. Save as many as possible left late in life.
  2. Current research suggests that multitasking has detrimental effects on memory. Development tends to be very heavy on multitasking. Maybe relieving some of the pressure on quick-access short term memory (like knowing all relevant branch names) add up to leave a healthier memory down the line.

First up for our scenario: the - shorthand, which refers to the previously checked out branch. There are a few places we can't use it, but it helps a lot:

Bash
# USING -

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -        # ????
git push
# hack hack hack
# whoops
git checkout -        # now on feature ???? 
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout - # now on qa-environment ????
git reset --hard origin/qa-environment
git merge --no-ff --no-edit -        # ????
git checkout -                       # ????
# on feature and ready for more feature commits
Bash
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

We cannot use - when cherry-picking a range

> git cherry-pick origin/-..-
fatal: bad revision 'origin/-..-'

> git cherry-pick origin/qa-environment..-
fatal: bad revision 'origin/qa-environment..-'

and even if we could we'd still have provide the remote's name (here, origin).

That shorthand doesn't apply in the later reset --hard command, and we cannot use it in the branch -D && checkout approach either. branch -D does not support the - shorthand and once the branch is deleted checkout can't reach it with -:

# assuming that branch-a has an upstream origin/branch-a
> git checkout branch-a
> git checkout branch-b
> git checkout -
> git branch -D -
error: branch '-' not found.
> git branch -D branch-a
> git checkout -
error: pathspec '-' did not match any file(s) known to git

So we have to remember the remote's name (we know it's origin because we are devoting memory space to knowing that this isn't one of those times it's something else), the remote tracking branch's name, the local branch's name, and we're typing those all out. No good! Let's figure out some shorthands.

@{-<n>} is hard to say but easy to fall in love with

We can do a little better by using @{-<n>} (you'll also sometimes see it referred to be the older @{-N}). It is a special construct for referring to the nth previously checked out ref.

> git checkout branch-a
> git checkout branch-b
> git rev-parse --abbrev-rev @{-1} # the name of the previously checked out branch
branch-a
> git checkout branch-c
> git rev-parse --abbrev-rev @{-2} # the name of branch checked out before the previously checked out one
branch-a

Back in our scenario, we're on qa-environment, we switch to feature, and then want to refer to qa-environment. That's @{-1}! So instead of

git cherry-pick origin/qa-environment..qa-environment

We can do

git cherry-pick origin/qa-environment..@{-1}

Here's where we are (🎉 marks wins from -, 💥 marks the win from @{-1})

Bash
# USING - AND @{-1}

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -                # ????
git push
# hack hack hack
# whoops
git checkout -                               # ????
git cherry-pick origin/qa-environment..@{-1} # ????
git push
git checkout -                               # ????
git reset --hard origin/qa-environment
git merge --no-ff --no-edit -                # ????
git checkout -                               # ????
# ready for more feature commits
Bash
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

One down, two to go: we're still relying on memory for the remote's name and the remote branch's name and we're still typing both out in full. Can we replace those with generic shorthands?

@{-1} is the ref itself, not the ref's name, we can't do

> git cherry-pick origin/@{-1}..@{-1}
origin/@{-1}
fatal: ambiguous argument 'origin/@{-1}': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

because there is no branch origin/@{-1}. For the same reason, @{-1} does not give us a generalized shorthand for the scenario's later git reset --hard origin/qa-environment command.

But good news!

Do @{u} @{push}

@{upstream} or its shorthand @{u} is the remote branch a that would be pulled from if git pull were run. @{push} is the remote branch that would be pushed to if git push was run.

> git checkout branch-a
Switched to branch 'branch-a'
Your branch is ahead of 'origin/branch-a' by 3 commits.
  (use "git push" to publish your local commits)
> git reset --hard origin/branch-a
HEAD is now at <the SHA origin/branch-a is at>

we can

> git checkout branch-a
Switched to branch 'branch-a'
Your branch is ahead of 'origin/branch-a' by 3 commits.
  (use "git push" to publish your local commits)
> git reset --hard @{u}                                # <-- So Cool!
HEAD is now at <the SHA origin/branch-a is at>

Tacking either onto a branch name will give that branch's @{upstream} or @{push}. For example

git checkout branch-a@{u}

is the branch branch-a pulls from.

In the common workflow where a branch pulls from and pushes to the same branch, @{upstream} and @{push} will be the same, leaving @{u} as preferable for its terseness. @{push} shines in triangular workflows where you pull from one remote and push to another (see the external links below).

Going back to our scenario, it means short, portable commands with a minimum human memory footprint. (🎉 marks wins from -, 💥 marks the win from @{-1}, 😎 marks the wins from @{u}.)

Bash
# USING - AND @{-1} AND @{u}

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -    # ????
git push
# hack hack hack
# whoops
git checkout -                   # ????
git cherry-pick @{-1}@{u}..@{-1} # ????????
git push
git checkout -                   # ????
git reset --hard @{u}            # ????
git merge --no-ff --no-edit -    # ????
git checkout -                   # ????
# ready for more feature commits
Bash
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

Make the things you repeat the easiest to do

Because these commands are generalized, we can run some series of them once, maybe

git checkout - && git reset --hard @{u} && git checkout -

or

git checkout - && git cherry-pick @{-1}@{u}.. @{-1} && git checkout - && git reset --hard @{u} && git checkout -

and then those will be in the shell history just waiting to be retrieved and run again the next time, whether with CtrlR incremental search or history substring searching bound to the up arrow or however your interactive shell is configured. Or make it an alias, or even better an abbreviation if your interactive shell supports them. Save the body wear and tear, give memory a break, and level up in Git.

And keep going

The GitHub blog has a good primer on triangular workflows and how they can polish your process of contributing to external projects.

The FreeBSD Wiki has a more in-depth article on triangular workflow process (though it doesn't know about @{push} and @{upstream}).

The construct @{-<n>} and the suffixes @{push} and @{upstream} are all part of the gitrevisions spec. Direct links to each:



    • Code
    • Front-end Engineering
    • Back-end Engineering

    mitt

    Committed to the wrong branch? -, @{upstream}, and @{-1} to the rescue

    I get into this situation sometimes. Maybe you do too. I merge feature work into a branch used to collect features, and then continue development but on that branch instead of back on the feature branch

    git checkout feature
    # ... bunch of feature commits ...
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit feature
    git push
    # deploy qa-environment to the QA remote environment
    # ... more feature commits ...
    # oh. I'm not committing in the feature branch like I should be

    and have to move those commits to the feature branch they belong in and take them out of the throwaway accumulator branch

    git checkout feature
    git cherry-pick origin/qa-environment..qa-environment
    git push
    git checkout qa-environment
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit feature
    git checkout feature
    # ready for more feature commits

    Maybe you prefer

    git branch -D qa-environment
    git checkout qa-environment

    over

    git checkout qa-environment
    git reset --hard origin/qa-environment

    Either way, that works. But it'd be nicer if we didn't have to type or even remember the branches' names and the remote's name. They are what is keeping this from being a context-independent string of commands you run any time this mistake happens. That's what we're going to solve here.

    Shorthands for longevity

    I like to use all possible natively supported shorthands. There are two broad motivations for that.

    1. Fingers have a limited number of movements in them. Save as many as possible left late in life.
    2. Current research suggests that multitasking has detrimental effects on memory. Development tends to be very heavy on multitasking. Maybe relieving some of the pressure on quick-access short term memory (like knowing all relevant branch names) add up to leave a healthier memory down the line.

    First up for our scenario: the - shorthand, which refers to the previously checked out branch. There are a few places we can't use it, but it helps a lot:

    Bash
    # USING -
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit -        # ????
    git push
    # hack hack hack
    # whoops
    git checkout -        # now on feature ???? 
    git cherry-pick origin/qa-environment..qa-environment
    git push
    git checkout - # now on qa-environment ????
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit -        # ????
    git checkout -                       # ????
    # on feature and ready for more feature commits
    Bash
    # ORIGINAL
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit feature
    git push
    # hack hack hack
    # whoops
    git checkout feature
    git cherry-pick origin/qa-environment..qa-environment
    git push
    git checkout qa-environment
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit feature
    git checkout feature
    # ready for more feature commits

    We cannot use - when cherry-picking a range

    > git cherry-pick origin/-..-
    fatal: bad revision 'origin/-..-'
    
    > git cherry-pick origin/qa-environment..-
    fatal: bad revision 'origin/qa-environment..-'

    and even if we could we'd still have provide the remote's name (here, origin).

    That shorthand doesn't apply in the later reset --hard command, and we cannot use it in the branch -D && checkout approach either. branch -D does not support the - shorthand and once the branch is deleted checkout can't reach it with -:

    # assuming that branch-a has an upstream origin/branch-a
    > git checkout branch-a
    > git checkout branch-b
    > git checkout -
    > git branch -D -
    error: branch '-' not found.
    > git branch -D branch-a
    > git checkout -
    error: pathspec '-' did not match any file(s) known to git

    So we have to remember the remote's name (we know it's origin because we are devoting memory space to knowing that this isn't one of those times it's something else), the remote tracking branch's name, the local branch's name, and we're typing those all out. No good! Let's figure out some shorthands.

    @{-<n>} is hard to say but easy to fall in love with

    We can do a little better by using @{-<n>} (you'll also sometimes see it referred to be the older @{-N}). It is a special construct for referring to the nth previously checked out ref.

    > git checkout branch-a
    > git checkout branch-b
    > git rev-parse --abbrev-rev @{-1} # the name of the previously checked out branch
    branch-a
    > git checkout branch-c
    > git rev-parse --abbrev-rev @{-2} # the name of branch checked out before the previously checked out one
    branch-a

    Back in our scenario, we're on qa-environment, we switch to feature, and then want to refer to qa-environment. That's @{-1}! So instead of

    git cherry-pick origin/qa-environment..qa-environment

    We can do

    git cherry-pick origin/qa-environment..@{-1}

    Here's where we are (🎉 marks wins from -, 💥 marks the win from @{-1})

    Bash
    # USING - AND @{-1}
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit -                # ????
    git push
    # hack hack hack
    # whoops
    git checkout -                               # ????
    git cherry-pick origin/qa-environment..@{-1} # ????
    git push
    git checkout -                               # ????
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit -                # ????
    git checkout -                               # ????
    # ready for more feature commits
    Bash
    # ORIGINAL
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit feature
    git push
    # hack hack hack
    # whoops
    git checkout feature
    git cherry-pick origin/qa-environment..qa-environment
    git push
    git checkout qa-environment
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit feature
    git checkout feature
    # ready for more feature commits

    One down, two to go: we're still relying on memory for the remote's name and the remote branch's name and we're still typing both out in full. Can we replace those with generic shorthands?

    @{-1} is the ref itself, not the ref's name, we can't do

    > git cherry-pick origin/@{-1}..@{-1}
    origin/@{-1}
    fatal: ambiguous argument 'origin/@{-1}': unknown revision or path not in the working tree.
    Use '--' to separate paths from revisions, like this:
    'git <command> [<revision>...] -- [<file>...]'

    because there is no branch origin/@{-1}. For the same reason, @{-1} does not give us a generalized shorthand for the scenario's later git reset --hard origin/qa-environment command.

    But good news!

    Do @{u} @{push}

    @{upstream} or its shorthand @{u} is the remote branch a that would be pulled from if git pull were run. @{push} is the remote branch that would be pushed to if git push was run.

    > git checkout branch-a
    Switched to branch 'branch-a'
    Your branch is ahead of 'origin/branch-a' by 3 commits.
      (use "git push" to publish your local commits)
    > git reset --hard origin/branch-a
    HEAD is now at <the SHA origin/branch-a is at>

    we can

    > git checkout branch-a
    Switched to branch 'branch-a'
    Your branch is ahead of 'origin/branch-a' by 3 commits.
      (use "git push" to publish your local commits)
    > git reset --hard @{u}                                # <-- So Cool!
    HEAD is now at <the SHA origin/branch-a is at>

    Tacking either onto a branch name will give that branch's @{upstream} or @{push}. For example

    git checkout branch-a@{u}

    is the branch branch-a pulls from.

    In the common workflow where a branch pulls from and pushes to the same branch, @{upstream} and @{push} will be the same, leaving @{u} as preferable for its terseness. @{push} shines in triangular workflows where you pull from one remote and push to another (see the external links below).

    Going back to our scenario, it means short, portable commands with a minimum human memory footprint. (🎉 marks wins from -, 💥 marks the win from @{-1}, 😎 marks the wins from @{u}.)

    Bash
    # USING - AND @{-1} AND @{u}
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit -    # ????
    git push
    # hack hack hack
    # whoops
    git checkout -                   # ????
    git cherry-pick @{-1}@{u}..@{-1} # ????????
    git push
    git checkout -                   # ????
    git reset --hard @{u}            # ????
    git merge --no-ff --no-edit -    # ????
    git checkout -                   # ????
    # ready for more feature commits
    Bash
    # ORIGINAL
    
    git checkout feature
    # hack hack hack
    git push
    git checkout qa-environment
    git merge --no-ff --no-edit feature
    git push
    # hack hack hack
    # whoops
    git checkout feature
    git cherry-pick origin/qa-environment..qa-environment
    git push
    git checkout qa-environment
    git reset --hard origin/qa-environment
    git merge --no-ff --no-edit feature
    git checkout feature
    # ready for more feature commits

    Make the things you repeat the easiest to do

    Because these commands are generalized, we can run some series of them once, maybe

    git checkout - && git reset --hard @{u} && git checkout -

    or

    git checkout - && git cherry-pick @{-1}@{u}.. @{-1} && git checkout - && git reset --hard @{u} && git checkout -

    and then those will be in the shell history just waiting to be retrieved and run again the next time, whether with CtrlR incremental search or history substring searching bound to the up arrow or however your interactive shell is configured. Or make it an alias, or even better an abbreviation if your interactive shell supports them. Save the body wear and tear, give memory a break, and level up in Git.

    And keep going

    The GitHub blog has a good primer on triangular workflows and how they can polish your process of contributing to external projects.

    The FreeBSD Wiki has a more in-depth article on triangular workflow process (though it doesn't know about @{push} and @{upstream}).

    The construct @{-<n>} and the suffixes @{push} and @{upstream} are all part of the gitrevisions spec. Direct links to each:



      • Code
      • Front-end Engineering
      • Back-end Engineering

      mitt

      Committed to the wrong branch? -, @{upstream}, and @{-1} to the rescue

      I get into this situation sometimes. Maybe you do too. I merge feature work into a branch used to collect features, and then continue development but on that branch instead of back on the feature branch

      git checkout feature
      # ... bunch of feature commits ...
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit feature
      git push
      # deploy qa-environment to the QA remote environment
      # ... more feature commits ...
      # oh. I'm not committing in the feature branch like I should be

      and have to move those commits to the feature branch they belong in and take them out of the throwaway accumulator branch

      git checkout feature
      git cherry-pick origin/qa-environment..qa-environment
      git push
      git checkout qa-environment
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit feature
      git checkout feature
      # ready for more feature commits

      Maybe you prefer

      git branch -D qa-environment
      git checkout qa-environment

      over

      git checkout qa-environment
      git reset --hard origin/qa-environment

      Either way, that works. But it'd be nicer if we didn't have to type or even remember the branches' names and the remote's name. They are what is keeping this from being a context-independent string of commands you run any time this mistake happens. That's what we're going to solve here.

      Shorthands for longevity

      I like to use all possible natively supported shorthands. There are two broad motivations for that.

      1. Fingers have a limited number of movements in them. Save as many as possible left late in life.
      2. Current research suggests that multitasking has detrimental effects on memory. Development tends to be very heavy on multitasking. Maybe relieving some of the pressure on quick-access short term memory (like knowing all relevant branch names) add up to leave a healthier memory down the line.

      First up for our scenario: the - shorthand, which refers to the previously checked out branch. There are a few places we can't use it, but it helps a lot:

      Bash
      # USING -
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit -        # ????
      git push
      # hack hack hack
      # whoops
      git checkout -        # now on feature ???? 
      git cherry-pick origin/qa-environment..qa-environment
      git push
      git checkout - # now on qa-environment ????
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit -        # ????
      git checkout -                       # ????
      # on feature and ready for more feature commits
      Bash
      # ORIGINAL
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit feature
      git push
      # hack hack hack
      # whoops
      git checkout feature
      git cherry-pick origin/qa-environment..qa-environment
      git push
      git checkout qa-environment
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit feature
      git checkout feature
      # ready for more feature commits

      We cannot use - when cherry-picking a range

      > git cherry-pick origin/-..-
      fatal: bad revision 'origin/-..-'
      
      > git cherry-pick origin/qa-environment..-
      fatal: bad revision 'origin/qa-environment..-'

      and even if we could we'd still have provide the remote's name (here, origin).

      That shorthand doesn't apply in the later reset --hard command, and we cannot use it in the branch -D && checkout approach either. branch -D does not support the - shorthand and once the branch is deleted checkout can't reach it with -:

      # assuming that branch-a has an upstream origin/branch-a
      > git checkout branch-a
      > git checkout branch-b
      > git checkout -
      > git branch -D -
      error: branch '-' not found.
      > git branch -D branch-a
      > git checkout -
      error: pathspec '-' did not match any file(s) known to git

      So we have to remember the remote's name (we know it's origin because we are devoting memory space to knowing that this isn't one of those times it's something else), the remote tracking branch's name, the local branch's name, and we're typing those all out. No good! Let's figure out some shorthands.

      @{-<n>} is hard to say but easy to fall in love with

      We can do a little better by using @{-<n>} (you'll also sometimes see it referred to be the older @{-N}). It is a special construct for referring to the nth previously checked out ref.

      > git checkout branch-a
      > git checkout branch-b
      > git rev-parse --abbrev-rev @{-1} # the name of the previously checked out branch
      branch-a
      > git checkout branch-c
      > git rev-parse --abbrev-rev @{-2} # the name of branch checked out before the previously checked out one
      branch-a

      Back in our scenario, we're on qa-environment, we switch to feature, and then want to refer to qa-environment. That's @{-1}! So instead of

      git cherry-pick origin/qa-environment..qa-environment

      We can do

      git cherry-pick origin/qa-environment..@{-1}

      Here's where we are (🎉 marks wins from -, 💥 marks the win from @{-1})

      Bash
      # USING - AND @{-1}
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit -                # ????
      git push
      # hack hack hack
      # whoops
      git checkout -                               # ????
      git cherry-pick origin/qa-environment..@{-1} # ????
      git push
      git checkout -                               # ????
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit -                # ????
      git checkout -                               # ????
      # ready for more feature commits
      Bash
      # ORIGINAL
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit feature
      git push
      # hack hack hack
      # whoops
      git checkout feature
      git cherry-pick origin/qa-environment..qa-environment
      git push
      git checkout qa-environment
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit feature
      git checkout feature
      # ready for more feature commits

      One down, two to go: we're still relying on memory for the remote's name and the remote branch's name and we're still typing both out in full. Can we replace those with generic shorthands?

      @{-1} is the ref itself, not the ref's name, we can't do

      > git cherry-pick origin/@{-1}..@{-1}
      origin/@{-1}
      fatal: ambiguous argument 'origin/@{-1}': unknown revision or path not in the working tree.
      Use '--' to separate paths from revisions, like this:
      'git <command> [<revision>...] -- [<file>...]'

      because there is no branch origin/@{-1}. For the same reason, @{-1} does not give us a generalized shorthand for the scenario's later git reset --hard origin/qa-environment command.

      But good news!

      Do @{u} @{push}

      @{upstream} or its shorthand @{u} is the remote branch a that would be pulled from if git pull were run. @{push} is the remote branch that would be pushed to if git push was run.

      > git checkout branch-a
      Switched to branch 'branch-a'
      Your branch is ahead of 'origin/branch-a' by 3 commits.
        (use "git push" to publish your local commits)
      > git reset --hard origin/branch-a
      HEAD is now at <the SHA origin/branch-a is at>

      we can

      > git checkout branch-a
      Switched to branch 'branch-a'
      Your branch is ahead of 'origin/branch-a' by 3 commits.
        (use "git push" to publish your local commits)
      > git reset --hard @{u}                                # <-- So Cool!
      HEAD is now at <the SHA origin/branch-a is at>

      Tacking either onto a branch name will give that branch's @{upstream} or @{push}. For example

      git checkout branch-a@{u}

      is the branch branch-a pulls from.

      In the common workflow where a branch pulls from and pushes to the same branch, @{upstream} and @{push} will be the same, leaving @{u} as preferable for its terseness. @{push} shines in triangular workflows where you pull from one remote and push to another (see the external links below).

      Going back to our scenario, it means short, portable commands with a minimum human memory footprint. (🎉 marks wins from -, 💥 marks the win from @{-1}, 😎 marks the wins from @{u}.)

      Bash
      # USING - AND @{-1} AND @{u}
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit -    # ????
      git push
      # hack hack hack
      # whoops
      git checkout -                   # ????
      git cherry-pick @{-1}@{u}..@{-1} # ????????
      git push
      git checkout -                   # ????
      git reset --hard @{u}            # ????
      git merge --no-ff --no-edit -    # ????
      git checkout -                   # ????
      # ready for more feature commits
      Bash
      # ORIGINAL
      
      git checkout feature
      # hack hack hack
      git push
      git checkout qa-environment
      git merge --no-ff --no-edit feature
      git push
      # hack hack hack
      # whoops
      git checkout feature
      git cherry-pick origin/qa-environment..qa-environment
      git push
      git checkout qa-environment
      git reset --hard origin/qa-environment
      git merge --no-ff --no-edit feature
      git checkout feature
      # ready for more feature commits

      Make the things you repeat the easiest to do

      Because these commands are generalized, we can run some series of them once, maybe

      git checkout - && git reset --hard @{u} && git checkout -

      or

      git checkout - && git cherry-pick @{-1}@{u}.. @{-1} && git checkout - && git reset --hard @{u} && git checkout -

      and then those will be in the shell history just waiting to be retrieved and run again the next time, whether with CtrlR incremental search or history substring searching bound to the up arrow or however your interactive shell is configured. Or make it an alias, or even better an abbreviation if your interactive shell supports them. Save the body wear and tear, give memory a break, and level up in Git.

      And keep going

      The GitHub blog has a good primer on triangular workflows and how they can polish your process of contributing to external projects.

      The FreeBSD Wiki has a more in-depth article on triangular workflow process (though it doesn't know about @{push} and @{upstream}).

      The construct @{-<n>} and the suffixes @{push} and @{upstream} are all part of the gitrevisions spec. Direct links to each:



        • Code
        • Front-end Engineering
        • Back-end Engineering

        mitt

        Committed to the wrong branch? -, @{upstream}, and @{-1} to the rescue

        I get into this situation sometimes. Maybe you do too. I merge feature work into a branch used to collect features, and then continue development but on that branch instead of back on the feature branch

        git checkout feature
        # ... bunch of feature commits ...
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit feature
        git push
        # deploy qa-environment to the QA remote environment
        # ... more feature commits ...
        # oh. I'm not committing in the feature branch like I should be

        and have to move those commits to the feature branch they belong in and take them out of the throwaway accumulator branch

        git checkout feature
        git cherry-pick origin/qa-environment..qa-environment
        git push
        git checkout qa-environment
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit feature
        git checkout feature
        # ready for more feature commits

        Maybe you prefer

        git branch -D qa-environment
        git checkout qa-environment

        over

        git checkout qa-environment
        git reset --hard origin/qa-environment

        Either way, that works. But it'd be nicer if we didn't have to type or even remember the branches' names and the remote's name. They are what is keeping this from being a context-independent string of commands you run any time this mistake happens. That's what we're going to solve here.

        Shorthands for longevity

        I like to use all possible natively supported shorthands. There are two broad motivations for that.

        1. Fingers have a limited number of movements in them. Save as many as possible left late in life.
        2. Current research suggests that multitasking has detrimental effects on memory. Development tends to be very heavy on multitasking. Maybe relieving some of the pressure on quick-access short term memory (like knowing all relevant branch names) add up to leave a healthier memory down the line.

        First up for our scenario: the - shorthand, which refers to the previously checked out branch. There are a few places we can't use it, but it helps a lot:

        Bash
        # USING -
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit -        # ????
        git push
        # hack hack hack
        # whoops
        git checkout -        # now on feature ???? 
        git cherry-pick origin/qa-environment..qa-environment
        git push
        git checkout - # now on qa-environment ????
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit -        # ????
        git checkout -                       # ????
        # on feature and ready for more feature commits
        Bash
        # ORIGINAL
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit feature
        git push
        # hack hack hack
        # whoops
        git checkout feature
        git cherry-pick origin/qa-environment..qa-environment
        git push
        git checkout qa-environment
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit feature
        git checkout feature
        # ready for more feature commits

        We cannot use - when cherry-picking a range

        > git cherry-pick origin/-..-
        fatal: bad revision 'origin/-..-'
        
        > git cherry-pick origin/qa-environment..-
        fatal: bad revision 'origin/qa-environment..-'

        and even if we could we'd still have provide the remote's name (here, origin).

        That shorthand doesn't apply in the later reset --hard command, and we cannot use it in the branch -D && checkout approach either. branch -D does not support the - shorthand and once the branch is deleted checkout can't reach it with -:

        # assuming that branch-a has an upstream origin/branch-a
        > git checkout branch-a
        > git checkout branch-b
        > git checkout -
        > git branch -D -
        error: branch '-' not found.
        > git branch -D branch-a
        > git checkout -
        error: pathspec '-' did not match any file(s) known to git

        So we have to remember the remote's name (we know it's origin because we are devoting memory space to knowing that this isn't one of those times it's something else), the remote tracking branch's name, the local branch's name, and we're typing those all out. No good! Let's figure out some shorthands.

        @{-<n>} is hard to say but easy to fall in love with

        We can do a little better by using @{-<n>} (you'll also sometimes see it referred to be the older @{-N}). It is a special construct for referring to the nth previously checked out ref.

        > git checkout branch-a
        > git checkout branch-b
        > git rev-parse --abbrev-rev @{-1} # the name of the previously checked out branch
        branch-a
        > git checkout branch-c
        > git rev-parse --abbrev-rev @{-2} # the name of branch checked out before the previously checked out one
        branch-a

        Back in our scenario, we're on qa-environment, we switch to feature, and then want to refer to qa-environment. That's @{-1}! So instead of

        git cherry-pick origin/qa-environment..qa-environment

        We can do

        git cherry-pick origin/qa-environment..@{-1}

        Here's where we are (🎉 marks wins from -, 💥 marks the win from @{-1})

        Bash
        # USING - AND @{-1}
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit -                # ????
        git push
        # hack hack hack
        # whoops
        git checkout -                               # ????
        git cherry-pick origin/qa-environment..@{-1} # ????
        git push
        git checkout -                               # ????
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit -                # ????
        git checkout -                               # ????
        # ready for more feature commits
        Bash
        # ORIGINAL
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit feature
        git push
        # hack hack hack
        # whoops
        git checkout feature
        git cherry-pick origin/qa-environment..qa-environment
        git push
        git checkout qa-environment
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit feature
        git checkout feature
        # ready for more feature commits

        One down, two to go: we're still relying on memory for the remote's name and the remote branch's name and we're still typing both out in full. Can we replace those with generic shorthands?

        @{-1} is the ref itself, not the ref's name, we can't do

        > git cherry-pick origin/@{-1}..@{-1}
        origin/@{-1}
        fatal: ambiguous argument 'origin/@{-1}': unknown revision or path not in the working tree.
        Use '--' to separate paths from revisions, like this:
        'git <command> [<revision>...] -- [<file>...]'

        because there is no branch origin/@{-1}. For the same reason, @{-1} does not give us a generalized shorthand for the scenario's later git reset --hard origin/qa-environment command.

        But good news!

        Do @{u} @{push}

        @{upstream} or its shorthand @{u} is the remote branch a that would be pulled from if git pull were run. @{push} is the remote branch that would be pushed to if git push was run.

        > git checkout branch-a
        Switched to branch 'branch-a'
        Your branch is ahead of 'origin/branch-a' by 3 commits.
          (use "git push" to publish your local commits)
        > git reset --hard origin/branch-a
        HEAD is now at <the SHA origin/branch-a is at>

        we can

        > git checkout branch-a
        Switched to branch 'branch-a'
        Your branch is ahead of 'origin/branch-a' by 3 commits.
          (use "git push" to publish your local commits)
        > git reset --hard @{u}                                # <-- So Cool!
        HEAD is now at <the SHA origin/branch-a is at>

        Tacking either onto a branch name will give that branch's @{upstream} or @{push}. For example

        git checkout branch-a@{u}

        is the branch branch-a pulls from.

        In the common workflow where a branch pulls from and pushes to the same branch, @{upstream} and @{push} will be the same, leaving @{u} as preferable for its terseness. @{push} shines in triangular workflows where you pull from one remote and push to another (see the external links below).

        Going back to our scenario, it means short, portable commands with a minimum human memory footprint. (🎉 marks wins from -, 💥 marks the win from @{-1}, 😎 marks the wins from @{u}.)

        Bash
        # USING - AND @{-1} AND @{u}
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit -    # ????
        git push
        # hack hack hack
        # whoops
        git checkout -                   # ????
        git cherry-pick @{-1}@{u}..@{-1} # ????????
        git push
        git checkout -                   # ????
        git reset --hard @{u}            # ????
        git merge --no-ff --no-edit -    # ????
        git checkout -                   # ????
        # ready for more feature commits
        Bash
        # ORIGINAL
        
        git checkout feature
        # hack hack hack
        git push
        git checkout qa-environment
        git merge --no-ff --no-edit feature
        git push
        # hack hack hack
        # whoops
        git checkout feature
        git cherry-pick origin/qa-environment..qa-environment
        git push
        git checkout qa-environment
        git reset --hard origin/qa-environment
        git merge --no-ff --no-edit feature
        git checkout feature
        # ready for more feature commits

        Make the things you repeat the easiest to do

        Because these commands are generalized, we can run some series of them once, maybe

        git checkout - && git reset --hard @{u} && git checkout -

        or

        git checkout - && git cherry-pick @{-1}@{u}.. @{-1} && git checkout - && git reset --hard @{u} && git checkout -

        and then those will be in the shell history just waiting to be retrieved and run again the next time, whether with CtrlR incremental search or history substring searching bound to the up arrow or however your interactive shell is configured. Or make it an alias, or even better an abbreviation if your interactive shell supports them. Save the body wear and tear, give memory a break, and level up in Git.

        And keep going

        The GitHub blog has a good primer on triangular workflows and how they can polish your process of contributing to external projects.

        The FreeBSD Wiki has a more in-depth article on triangular workflow process (though it doesn't know about @{push} and @{upstream}).

        The construct @{-<n>} and the suffixes @{push} and @{upstream} are all part of the gitrevisions spec. Direct links to each:



          • Code
          • Front-end Engineering
          • Back-end Engineering

          mitt

          What’s New With Node? Interview With Bethany Griggs, Node.js Technical Steering Committee

          Node.js 14 is available now. We wanted to get more context and details about the state of Node, and why developers should care about Node.js 14. We talked with Bethany Griggs, Node.js Technical Steering Committee member and Open-source Engineer at IBM, to find out more. 

          Bethany has been a Node Core Collaborator for over two years. She contributes to the open-source Node.js runtime and is a member of the Node.js Release Working Group where she is involved with auditing commits for the long-term support (LTS) release lines and the creation of releases. 




          mitt

          Compound and organic light-emitting device including the same

          A compound represented by Formula 1 below and an organic light-emitting device including an organic layer containing the compound of Formula 1: wherein R1 to R4, X and Y, a and b, and m and n are defined as in the specification.




          mitt

          Light-emitting glass, light-emitting device equipped with the light-emitting glass, and process for producing light-emitting glass

          Provided is a light-emitting glass which is applicable to, e.g., white illuminators including a light-emitting diode as a light source, and which emits light of a warm white color when irradiated with near ultraviolet light and combines long-term weatherability with high heat resistance; a light-emitting device containing same and a process for producing same. The light-emitting glass includes, as the base glass, borosilicate or silicate glass having a separated-phase structure, whereby the base glass is efficiently doped with, for example, transition metal ion clusters which emit light of a warm white color upon irradiation with near ultraviolet light. With this glass, it is possible to attain increases in excitation wavelength and emission wavelength. The glass thus emits, based on a multiple scattering effect, high-intensity light of a warm white color upon irradiation with near ultraviolet light.




          mitt

          Glass ceramic body, substrate for mounting light-emitting element, and light emitting device

          To provide a glass ceramic body wherein the deterioration of the reflectance due to black coloration is suppressed, and the unevenness of the firing shrinkage is suppressed. A glass ceramic body comprising a glass matrix and alumina particles dispersed therein, wherein the glass matrix is not crystallized, a ceramic part composed of the dispersed alumina particles has an α-alumina crystal structure and a crystal structure other than the α-alumina crystal structure.




          mitt

          Epoxy resin composition and light emitting apparatus

          Disclosed are an epoxy resin composition and a light emitting apparatus. The epoxy resin composition includes a triazine derivative epoxy resin and an alicyclic epoxy resin.




          mitt

          Method for transmitting data from an infrastructure of a radio communication network to user devices, and devices for implementing the method

          Within a radio communication network infrastructure transmitting data organized into a sequence of symbols to a receiving device over a plurality of radio links, data to be transmitted is encoded according to an error correction coding scheme in order to produce a set of systematic symbols and a set of corresponding redundancy symbols; the systematic symbols and a first subset of the corresponding redundancy symbols are transmitted, over a first radio link among said plurality of radio links, in broadcast mode, and a second subset of the corresponding redundancy symbols, distinct from the first one, is transmitted over a second radio link among said plurality of radio links.




          mitt

          Apparatus for transmitting and receiving a signal and method of transmitting and receiving a signal

          A method is provided for receiving a signal. The method includes receiving a signal transmitted in a radio frequency (RF) band including at least one RF channel, demodulating the received signal, parsing a preamble of a signal frame including layer-1 information from the demodulated signal, deinterleaving bits of the layer-1 information, decoding the deinterleaved bits using an error correction decoding scheme including a shortening scheme and a puncturing scheme and obtaining physical layer pipes (PLPs) from the signal frame using the error-correction-decoded layer-1 information.




          mitt

          Method and apparatus for generating and transmitting code sequence in a wireless communication system

          A method of generating a code sequence in a wireless communication system is disclosed. More specifically, the method includes recognizing a desired length of the code sequence, generating a code sequence having a length different from the desired length, and modifying the length of the generated code sequence to equal the desired length. Here, the step of modifying includes discarding at least one element of the generated code sequence or inserting at least one null element to the generated code sequence.




          mitt

          Organic compound and organic light-emitting device

          A novel organic compound suitable for emitting green light and an organic light-emitting device including the organic compound are provided. The organic compound is represented by general formula (1). In general formula (1), R1 to R18 are each independently selected from a hydrogen atom, a halogen atom, a substituted or unsubstituted alkyl group, a substituted or unsubstituted alkoxy group, a substituted amino group, a substituted or unsubstituted aryl group, and a substituted or unsubstituted heterocyclic group.




          mitt

          Method for producing conductive material, conductive material obtained by the method, electronic device containing the conductive material, light-emitting device, and method for producing light-emitting device

          An object of the present invention is to provide a method for producing a conductive material that allows a low electric resistance to be generated, and that is obtained by using an inexpensive and stable conductive material composition containing no adhesive. The conductive material can be provided by a producing method that includes the step of sintering a first conductive material composition that contains silver particles having an average particle diameter (median diameter) of 0.1 μm to 15 μm, and a metal oxide, so as to obtain a conductive material. The conductive material can be provided also by a method that includes the step of sintering a second conductive material composition that contains silver particles having an average particle diameter (median diameter) of 0.1 μm to 15 μm in an atmosphere of oxygen or ozone, or ambient atmosphere, at a temperature in a range of 150° C. to 320° C., so as to obtain a conductive material.




          mitt

          Vehicle notification sound emitting apparatus

          A vehicle notification sound emitting apparatus is basically provided with a first sound emitting device, a second sound emitting device and a notification sound control device. The first sound emitting device emits a first intermittent notification sound inside a cabin interior of a vehicle. The second sound emitting device emits a second intermittent notification sound outside of the cabin interior of the vehicle. The notification sound control device operates the first and second sound emitting devices to separately emit the first and second intermittent notification sounds in at least a partially overlapping pattern in response to occurrence of a vehicle condition to convey a same type of vehicle information to both inside and outside of the cabin interior of the vehicle. The notification sound control device includes a cabin interior-exterior notification sound synchronizing section that is configured to synchronize the first and second intermittent notification sounds.




          mitt

          Method for detecting the time messages in the faulty signal of a time-signal transmitter

          A method is described for detecting the time messages in the faulty signal of a time-signal transmitter comprising the steps below. Probabilities are assigned to the received information/bits as they are received and whose sign specifies the value of the bit and whose numerical value indicates the certainty of reception. Except for the bits designating the minute information, the probabilities of successive time messages are totaled with time correctness in a one-dimensional memory field. From the totaled probabilities, a reduced time message is reconstructed that initially contains no information on the minutes. If the reconstructed time message does not change over two successive time intervals, and if preset minimum values for the number of probabilities are exceeded for all bits, then the reduced time message is recognized as being correct. The minutes are determined separately and added to the time message recognized as being correct.




          mitt

          Memory storage apparatus, memory controller, and method for transmitting and identifying data stream

          A memory storage apparatus, a memory controller and method for transmitting and identifying data streams are provided. The memory controller passes at least a portion of a data stream received from a host system to a smart card chip of the memory storage apparatus. Then, the host system accurately receives a response message from the smart card chip by executing a plurality of read commands. The memory controller is capable of adding a first verification code to a response data stream sent to the host system, and is capable of adding a write token to each of data segments of the response data stream. The host system confirms the accuracy of the response data stream by verifying the first verification code or by verifying the write token of each of the data segments.




          mitt

          Signal transmitting and lesion excluding heart implants for pacing, defibrillating, and/or sensing of heart beat

          Devices, systems, and methods for treating a heart of a patient may make use of structures which limit a size of a chamber of the heart, such as by deploying a tensile member to bring a wall of the heart toward (optionally into contact with) a septum of the heart. The implant may include an electrode or other structure for applying pacing signals to one or both ventricles of the heart, for defibrillating the heart, for sensing beating of the heart or the like. A wireless telemetry and control system may allowing the implant to treat congestive heart failure, monitor the results of the treatment, and apply appropriate electrical stimulation.




          mitt

          Method of fabricating substrate for organic light-emitting device

          A substrate for an organic light-emitting device which can improve the light extraction efficiency of an organic light-emitting device while realizing an intended level of transmittance, a method of fabricating the same, and an organic light-emitting device having the same. Light emitted from the OLED is emitted outward through the substrate. The substrate includes a substrate body and a number of crystallized particles disposed inside the substrate body, the number of crystallized particles forming a pattern inside the substrate body.




          mitt

          Manufacturing method of organic light emitting display device

          A manufacturing method of an organic light emitting display device is disclosed which includes: forming a thin film transistor on each sub-pixel region which is defined in a substrate; forming a passivation layer on the substrate provided with the thin film transistor; forming a first electrode of an organic light emitting diode in each sub-pixel region of the passivation layer; forming a bank pattern in boundaries of the sub-pixel region of the passivation layer; forming a photoresist pattern, which exposes a first sub-pixel region, on the bank pattern; forming an organic light emission layer on the first electrode within the first sub-pixel region and an organic material layer on the photoresist pattern by depositing an organic material on the entire surface of the substrate provided with the photoresist pattern; and removing the photoresist pattern and the organic material pattern using a detachment film.




          mitt

          Transmitter position integrity checking

          The subject matter disclosed herein relates to determining whether a reported position of a wireless transmitter is sufficiently accurate in accordance with an accuracy metric based at least in part on a calculated range between an estimated position of a mobile station and the reported position and also based at least in part on one or more measurements taken from one or more signals transmitted by the wireless transmitter.




          mitt

          Data transmitting apparatus, data receiving apparatus, data transreceiving system, data transmitting method, data receiving method and data transreceiving method

          A data transmitting apparatus is provided. The data transmitting apparatus includes a packet generator configured to generate a packet including a plurality of sub packets and a transmitter configured to transmit the generated packet to a data receiving apparatus. Each of the plurality of sub packets includes audio data corresponding to content among a plurality of contents.




          mitt

          Gear, motor-gear unit, vehicle and generator with a gear and force transmitting element

          A vehicle has a motor-gear unit, a trailing wheel of the vehicle being connected the output shaft of the gear and an input shaft of the gear being connected to a motor. The gear has an outer wheel, an inner wheel and a traction means extending between the outer wheel and the inner wheel. A revolving transmitter is also provided which lifts the traction means off the outer periphery of the inner wheel and pushes it against the inner periphery of the outer wheel.




          mitt

          Lubricant base oil, lubricant composition for internal combustion engine and lubricant composition for driving force transmitting device

          The lubricating base oil of the invention is characterized by satisfying at least one of the following conditions (a) or (b). (a) A saturated compound content of 95% by mass or greater, and a proportion of 0.1-10% by mass of cyclic saturated compounds among the saturated compounds.(b) The condition represented by the following formula (1). 1.435≦n20−0.002×kv100≦1.450 (1) wherein n20 represents the refractive index of the lubricating base oil at 20° C., and kv100 represents the kinematic viscosity (mm2/s) of the lubricating base oil at 100° C.




          mitt

          Transmitter optical module

          Disclosed is a transmitter optical module which includes a first package generating an optical signal; a second package bonded with the first package by using chip-to-chip bonding, having a silicon optical circuit platform structure, and amplifying the optical signal; and an optical waveguide forming a transmission path of the optical signal from the first package to the second package.




          mitt

          Rapid assays for neurotransmitter transporters

          The invention describes the finding that 4-(4-dimethylaminostyrl)-N-methylpyridinium or ASP+ is a fluorescent substrate that is transported by several neurotransmitter transporters. Provided are methods for the analysis of neurotransmitter transport and binding using ASP+. The invention also provides rapid methods for screening for modulators of neurotransmitter transport. As neurotransmitter transporter defects are associated with numerous neurological disorders, the invention also provides methods for treating neurotransmitter transport-associated defects/conditions using the modulators identified by the screening methods of the invention.




          mitt

          Organic light emitting device

          An organic light emitting device includes a substrate; a first electrode; a second electrode; and an organic layer including an emission layer between the first electrode and the second electrode. The organic layer includes a first intermediate layer including a first host and a first dopant, a second intermediate layer including the first dopant, and a third intermediate layer including a second host and the first dopant interposed between the first electrode and the emission layer. The organic light emitting device has a long lifetime.




          mitt

          Rotation transmitting apparatus, vehicle steering system, and intermediate shaft

          A rotation transmitting apparatus includes a first shaft on which multiple external teeth are formed so as to be arranged in a circumferential direction, and a second shaft in which multiple internal teeth are formed so as to be arranged in the circumferential direction, the second shaft being fitted to the first shaft so as to be slidable relative to the first shaft in the axial direction and so as to be engageable with the first shaft in a rotational direction through the use of the external teeth and the internal teeth. A protrusion is formed on the tooth flank of one of the external tooth and the internal tooth, the protrusion being projected toward the corresponding tooth flank of the other of the external tooth and the internal tooth. The protrusion is made of a resin that is more elastically deformable than the tooth flank.




          mitt

          Shaft for transmitting torques

          A shaft for transmitting torques includes a hollow shaft made of fiber-reinforced plastic. A flange which can be used to connect the hollow shaft to a driving or driven machine part is fastened at least to one end of the hollow shaft. The flange is fastened to the hollow shaft via a number of screw connections. Each screw connection includes a screw and a nut. The shank of the screw projects in the direction of the hollow shaft through an opening in the flange that is arranged in the connection region between the end edge of the hollow shaft and the flange. The shank extends at least partially inside the shell of the hollow shaft and engages with the nut arranged on the hollow shaft. The head of the screw is supported on that side of the flange opposed to the hollow shaft.




          mitt

          Arrangement for transmitting a torque between a shaft and a hub

          An arrangement transmits a torque between a shaft and a hub. The hub has at least approximately the interior geometry of an equilateral n-sided polygon, the side surfaces of which at least approximately bear against a clutch portion, which is of circular overall cross section, of the shaft, and wherein the shaft has at least one driver portion which is rotationally conjoint with respect to the clutch portion and which extends in the direction of a corner of the n-sided polygon.




          mitt

          Broadcast transmitter, a broadcast transmitting method and a broadcast receiving method

          In one embodiment, a broadcast transmitter includes: a viewer information memory configured to store viewer information regarding a viewer who signs up for a subscription; a generator configured to generate individual information regarding a conditional access of a content including a first expiration time indicating an expiration time of the individual information and a second expiration time set independently of the first expiration time for each the viewer who signs up for the subscription based on the viewer information; and a transmitter configured to transmit a broadcast signal including the generated individual information.




          mitt

          Electroluminescent device with quinazoline complex emitter

          An OLED device comprises a cathode, an anode, and located therebetween a light-emitting layer containing a host material and a tris-C^N-cyclometallated complex of Ir or Rh wherein at least one of the ligands comprises a substituted quinazoline moiety. The device provides useful emission and stability attributes.