ups

Leading Health Care Groups Issue Urgent Call for Federal Action to Address Medical Equipment Shortages

  WASHINGTON, D.C., March 30, 2020 — As longstanding organizations representing and supporting those on the front lines who are risking their lives caring for the world’s most vulnerable patients, we stand united in voicing our concern over the ...




ups

28 Patient and consumer groups urge the administration to implement a special enrollment period for Healthcare.gov

WASHINGTON, D.C., April 1, 2020 – 28 patient and consumer groups representing millions of people nationwide with pre-existing health conditions issued the following statement regarding the administration’s decision not to initiate a special enrollment...




ups

More than 200 patient groups call on Administration to take additional action to alleviate critical shortage of ventilators, PPE, ensure safety of providers, patients

Today, more than patient advocacy, medical and public health organizations sent a letter to senior Trump Administration officials, appealing to the Administration to take immediate action to alleviate the critical shortage across the nation ventilators...




ups

21 health and medical groups speak out against EPA finalizing a rule that could undermine the Mercury and Air Toxics Standards

Today, the U.S. Environmental Protection Agency (EPA) announced a final rule that threatens to undermine the Mercury and Air Toxics Standards. The American Lung Association, Allergy & Asthma Network, Alliance of Nurses for Healthy Environments, American...




ups

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

    ups

    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

      ups

      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

        ups

        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

          ups

          Freaky Logo Friday. Logo Mash-Ups

          What would happen if the logos of famous brands suddenly wake up in the bed of another? Thats what the new tumblr blog Logo Mashups explores. It makes us think in the in the connections they share and how they are constantly appealing to our consumer mind through the commons grounds of symbology and typography.




          ups

          Non-associative Frobenius algebras for simply laced Chevalley groups. (arXiv:2005.02625v1 [math.RA] CROSS LISTED)

          We provide an explicit construction for a class of commutative, non-associative algebras for each of the simple Chevalley groups of simply laced type. Moreover, we equip these algebras with an associating bilinear form, which turns them into Frobenius algebras. This class includes a 3876-dimensional algebra on which the Chevalley group of type E8 acts by automorphisms. We also prove that these algebras admit the structure of (axial) decomposition algebras.




          ups

          The entropy of holomorphic correspondences: exact computations and rational semigroups. (arXiv:2004.13691v1 [math.DS] CROSS LISTED)

          We study two notions of topological entropy of correspondences introduced by Friedland and Dinh-Sibony. Upper bounds are known for both. We identify a class of holomorphic correspondences whose entropy in the sense of Dinh-Sibony equals the known upper bound. This provides an exact computation of the entropy for rational semigroups. We also explore a connection between these two notions of entropy.




          ups

          Automorphisms of shift spaces and the Higman--Thomspon groups: the one-sided case. (arXiv:2004.08478v2 [math.GR] UPDATED)

          Let $1 le r < n$ be integers. We give a proof that the group $mathop{mathrm{Aut}}({X_{n}^{mathbb{N}}, sigma_{n}})$ of automorphisms of the one-sided shift on $n$ letters embeds naturally as a subgroup $mathcal{h}_{n}$ of the outer automorphism group $mathop{mathrm{Out}}(G_{n,r})$ of the Higman-Thompson group $G_{n,r}$. From this, we can represent the elements of $mathop{mathrm{Aut}}({X_{n}^{mathbb{N}}, sigma_{n}})$ by finite state non-initial transducers admitting a very strong synchronizing condition.

          Let $H in mathcal{H}_{n}$ and write $|H|$ for the number of states of the minimal transducer representing $H$. We show that $H$ can be written as a product of at most $|H|$ torsion elements. This result strengthens a similar result of Boyle, Franks and Kitchens, where the decomposition involves more complex torsion elements and also does not support practical extit{a priori} estimates of the length of the resulting product.

          We also give new proofs of some known results about $mathop{mathrm{Aut}}({X_{n}^{mathbb{N}}, sigma_{n}})$.




          ups

          $5$-rank of ambiguous class groups of quintic Kummer extensions. (arXiv:2003.00761v2 [math.NT] UPDATED)

          Let $k ,=, mathbb{Q}(sqrt[5]{n},zeta_5)$, where $n$ is a positive integer, $5^{th}$ power-free, whose $5-$class group is isomorphic to $mathbb{Z}/5mathbb{Z} imesmathbb{Z}/5mathbb{Z}$. Let $k_0,=,mathbb{Q}(zeta_5)$ be the cyclotomic field containing a primitive $5^{th}$ root of unity $zeta_5$. Let $C_{k,5}^{(sigma)}$ the group of the ambiguous classes under the action of $Gal(k/k_0)$ = $<sigma>$. The aim of this paper is to determine all integers $n$ such that the group of ambiguous classes $C_{k,5}^{(sigma)}$ has rank $1$ or $2$.




          ups

          Universal Covers of Finite Groups. (arXiv:1910.11453v2 [math.GR] UPDATED)

          Motivated by quotient algorithms, such as the well-known $p$-quotient or solvable quotient algorithms, we describe how to compute extensions $ ilde H$ of a finite group $H$ by a direct sum of isomorphic simple $mathbb{Z}_p H$-modules such that $H$ and $ ilde H$ have the same number of generators. Similar to other quotient algorithms, our description will be via a suitable covering group of $H$. Defining this covering group requires a study of the representation module, as introduced by Gasch"utz in 1954. Our investigation involves so-called Fox derivatives (coming from free differential calculus) and, as a by-product, we prove that these can be naturally described via a wreath product construction. An important application of our results is that they can be used to compute, for a given epimorphism $G o H$ and simple $mathbb{Z}_p H$-module $V$, the largest quotient of $G$ that maps onto $H$ with kernel isomorphic to a direct sum of copies of $V$. For this we also provide a description of how to compute second cohomology groups for the (not necessarily solvable) group $H$, assuming a confluent rewriting system for $H$. To represent the corresponding group extensions on the computer, we introduce a new hybrid format that combines this rewriting system with the polycyclic presentation of the module.




          ups

          On $p$-groups with automorphism groups related to the exceptional Chevalley groups. (arXiv:1810.08365v3 [math.GR] UPDATED)

          Let $hat G$ be the finite simply connected version of an exceptional Chevalley group, and let $V$ be a nontrivial irreducible module, of minimal dimension, for $hat G$ over its field of definition. We explore the overgroup structure of $hat G$ in $mathrm{GL}(V)$, and the submodule structure of the exterior square (and sometimes the third Lie power) of $V$. When $hat G$ is defined over a field of odd prime order $p$, this allows us to construct the smallest (with respect to certain properties) $p$-groups $P$ such that the group induced by $mathrm{Aut}(P)$ on $P/Phi(P)$ is either $hat G$ or its normaliser in $mathrm{GL}(V)$.




          ups

          Word problems for finite nilpotent groups. (arXiv:2005.03634v1 [math.GR])

          Let $w$ be a word in $k$ variables. For a finite nilpotent group $G$, a conjecture of Amit states that $N_w(1) ge |G|^{k-1}$, where $N_w(1)$ is the number of $k$-tuples $(g_1,...,g_k)in G^{(k)}$ such that $w(g_1,...,g_k)=1$. Currently, this conjecture is known to be true for groups of nilpotency class 2. Here we consider a generalized version of Amit's conjecture, and prove that $N_w(g) ge |G|^{k-2}$, where $g$ is a $w$-value in $G$, for finite groups $G$ of odd order and nilpotency class 2. If $w$ is a word in two variables, we further show that $N_w(g) ge |G|$, where $g$ is a $w$-value in $G$ for finite groups $G$ of nilpotency class 2. In addition, for $p$ a prime, we show that finite $p$-groups $G$, with two distinct irreducible complex character degrees, satisfy the generalized Amit conjecture for words $w_k =[x_1,y_1]...[x_k,y_k]$ with $k$ a natural number; that is, for $g$ a $w_k$-value in $G$ we have $N_{w_k}(g) ge |G|^{2k-1}$.

          Finally, we discuss the related group properties of being rational and chiral, and show that every finite group of nilpotency class 2 is rational.




          ups

          A survey of Hardy type inequalities on homogeneous groups. (arXiv:2005.03614v1 [math.FA])

          In this review paper, we survey Hardy type inequalities from the point of view of Folland and Stein's homogeneous groups. Particular attention is paid to Hardy type inequalities on stratified groups which give a special class of homogeneous groups. In this environment, the theory of Hardy type inequalities becomes intricately intertwined with the properties of sub-Laplacians and more general subelliptic partial differential equations. Particularly, we discuss the Badiale-Tarantello conjecture and a conjecture on the geometric Hardy inequality in a half-space of the Heisenberg group with a sharp constant.




          ups

          On products of groups and indices not divisible by a given prime. (arXiv:2005.03608v1 [math.GR])

          Let the group $G = AB$ be the product of subgroups $A$ and $B$, and let $p$ be a prime. We prove that $p$ does not divide the conjugacy class size (index) of each $p$-regular element of prime power order $xin Acup B$ if and only if $G$ is $p$-decomposable, i.e. $G=O_p(G) imes O_{p'}(G)$.




          ups

          Groups up to congruence relation and from categorical groups to c-crossed modules. (arXiv:2005.03601v1 [math.CT])

          We introduce a notion of c-group, which is a group up to congruence relation and consider the corresponding category. Extensions, actions and crossed modules (c-crossed modules) are defined in this category and the semi-direct product is constructed. We prove that each categorical group gives rise to c-groups and to a c-crossed module, which is a connected, special and strict c-crossed module in the sense defined by us. The results obtained here will be applied in the proof of an equivalence of the categories of categorical groups and connected, special and strict c-crossed modules.




          ups

          A reducibility problem for even Unitary groups: The depth zero case. (arXiv:2005.03386v1 [math.RT])

          We study a problem concerning parabolic induction in certain p-adic unitary groups. More precisely, for $E/F$ a quadratic extension of p-adic fields the associated unitary group $G=mathrm{U}(n,n)$ contains a parabolic subgroup $P$ with Levi component $L$ isomorphic to $mathrm{GL}_n(E)$. Let $pi$ be an irreducible supercuspidal representation of $L$ of depth zero. We use Hecke algebra methods to determine when the parabolically induced representation $iota_P^G pi$ is reducible.




          ups

          The Congruence Subgroup Problem for finitely generated Nilpotent Groups. (arXiv:2005.03263v1 [math.GR])

          The congruence subgroup problem for a finitely generated group $Gamma$ and $Gleq Aut(Gamma)$ asks whether the map $hat{G} o Aut(hat{Gamma})$ is injective, or more generally, what is its kernel $Cleft(G,Gamma ight)$? Here $hat{X}$ denotes the profinite completion of $X$. In the case $G=Aut(Gamma)$ we denote $Cleft(Gamma ight)=Cleft(Aut(Gamma),Gamma ight)$.

          Let $Gamma$ be a finitely generated group, $ar{Gamma}=Gamma/[Gamma,Gamma]$, and $Gamma^{*}=ar{Gamma}/tor(ar{Gamma})congmathbb{Z}^{(d)}$. Denote $Aut^{*}(Gamma)= extrm{Im}(Aut(Gamma) o Aut(Gamma^{*}))leq GL_{d}(mathbb{Z})$. In this paper we show that when $Gamma$ is nilpotent, there is a canonical isomorphism $Cleft(Gamma ight)simeq C(Aut^{*}(Gamma),Gamma^{*})$. In other words, $Cleft(Gamma ight)$ is completely determined by the solution to the classical congruence subgroup problem for the arithmetic group $Aut^{*}(Gamma)$.

          In particular, in the case where $Gamma=Psi_{n,c}$ is a finitely generated free nilpotent group of class $c$ on $n$ elements, we get that $C(Psi_{n,c})=C(mathbb{Z}^{(n)})={e}$ whenever $ngeq3$, and $C(Psi_{2,c})=C(mathbb{Z}^{(2)})=hat{F}_{omega}$ = the free profinite group on countable number of generators.




          ups

          New constructions of strongly regular Cayley graphs on abelian groups. (arXiv:2005.03183v1 [math.CO])

          In this paper, we give new constructions of strongly regular Cayley graphs on abelian groups as generalizations of a series of known constructions: the construction of covering extended building sets in finite fields by Xia (1992), the product construction of Menon-Hadamard difference sets by Turyn (1984), and the construction of Paley type partial difference sets by Polhill (2010). Then, we obtain new large families of strongly regular Cayley graphs of Latin square type or negative Latin square type.




          ups

          Spokane groups create fund to help undocumented families during pandemic

          A coalition of immigrant-focused organizations has created the Spokane Relief Fund for Undocumented Immigrants, in order to help families who are unable to access federal aid during the coronavirus shutdowns. The partners sponsoring the work include the Spokane Immigrant Rights Coalition (SIRC), the Hispanic Business and Professional Association, Latinos en Spokane, Mujeres in Action and Raiz.…



          • News/Local News

          ups

          Process for cyclopentadiene substitution with groups differing from each other

          Polysubstituted cyclopentadiene compound wherein at least two different substituents are present from the group consisting of linear, branched and cyclic alkyls, aralkyls and alkenyls, and a process for the preparation of a cyclopentadiene compound substituted with at least two different groups chosen from the group consisting of linear, branched, cyclic and aromatic alkyls and alkenyls, characterized in that it comprises the reacting of a halide of a first substituting group in a mixture of the cyclopentadiene compound and an aqueous solution of a base, in which the quantity of the base relative to the cyclopentadiene compound is between 5 and 30 mol/mol, in the presence of a phase transfer catalyst, followed by the addition of a halide of a second or optionally a third substituting group to the reaction mixture.




          ups

          Agrochemical formulations of microcapsules for compounds containing carboxamide groups

          The present invention is directed towards microcapsules, uses and methods of microencapsulation with improved properties regarding agglomeration, bleeding and control of the reaction. The invention is especially suitable for chemical compounds with at least one carboxamide group, preferably for microencapsulation of those compounds wherein the carbonyl group is attached to a nitrogen atom or nitrogenated heterocycle and wherein the microencapsulation reaction may be too vigorous. The microcapsules are characterized by a mixed glycoluril-polyurea polymer wall, wherein the polyurea groups come from a urea-formaldehyde resin and not from isocyanate monomers or prepolymers. The process of making such microcapsules a dispersant in the oil phase of the type of block copolymer of vinylpyrrolidone/vinylalkene and/or vinylpyrrolidone/vinyl acetate and the microencapsulation reaction may be carried out without the presence of any polyamine/polyol acting as a catalyst.




          ups

          Indolesulfonyl protecting groups for protection of guanidino and amino groups

          The invention relates to indolesulfonyl halogenides which are useful for the protection of organic compounds comprising at least one guanidino moiety and/or at least one amino group. The invention further relates to a process for their preparation and their use as protecting reagents. The invention also relates to the process for the protecting reaction and to the protected compounds thereof.




          ups

          Ethylenically unsaturated polymerizable groups comprising polycarbosiloxane monomers

          The present application relates to novel monomers comprising polycarbosiloxane monomers useful in certain specific embodiments in the manufacture of devices. More particularly, the present application relates to certain ethylenically unsaturated free radical polymerizable monomers comprising polycarbosiloxane monomers. Even more particularly, the present application pertains to monomers comprising polycarbosiloxane monomers which further comprise at least two ethylenically unsaturated free radical polymerizable groups.




          ups

          Organo-copper reagents for attaching perfluorosulfonic acid groups to polyolefins

          An ion conducting membrane for fuel cells involves coupling a compound having a sulfonic acid group with a polymeric backbone. Each of the compounds having a sulfonic acid group and the polymeric backbone are first functionalized with a halogen.




          ups

          Nitrile rubbers which optionally contain alkylthio terminal groups and which are optionally hydrogenated

          An improved polymerization and process method allows the production of special nitrile rubbers which are characterized by a specific anion content and an excellent storage stability and allow a particularly good vulcanization rate and moreover result in vulcanized materials that have advantageous properties, especially with regard to the contact with metal components of molded parts based on said vulcanized materials.




          ups

          Process for exchanging functional groups by halogen-metal exchange reaction

          A method by which a halogen atom of a halogen compound can be efficiently replaced with an electrophilic group. Also provided are: a reagent for converting a functional group through a halogen-metal exchange reaction, characterized by comprising either a mixture of a magnesium compound represented by the formula R1—Mg—X (I) (wherein R1 represents a halogen atom or an optionally substituted hydrocarbon residue; and X1 represents a halogen atom) and an organolithium compound represented by the formula R2—Li (II)(wherein R2 represents an optionally substituted hydrocarbon residue) or a product of the reaction of the magnesium compound with the organolithium compound; and a process for producing with the reagent a compound in which a halogen atom of a halogen compound has been replaced with an electrophilic group.




          ups

          Water heater having upstream and downstream manifolds

          A water heater system comprises a water tank, a burner plenum, a flue, a blower, a combustion air passageway, a dilution air passageway, an upstream manifold, and a downstream manifold. The upstream manifold divides air from the blower so that some air flows through the combustion air passageway to the burner plenum and some air flows through the dilution air passageway to the downstream manifold. The downstream manifold combines the air from the dilution air passageway with combustion products from the flue.




          ups

          Combustor with a combustion region between an inner pipe and outer pipe with an ignition device upstream of the combustion region

          Includes a low flow-rate region (R2) that is disposed on an upstream side of a combustion region (R1) within a second pipe (2), and that has a relatively slow flow-rate of combustion gas (G1) within the second pipe, and a flame kernel formation unit (3a) is disposed in the low flow-rate region.




          ups

          Boot accessory for limiting foot movement in stirrups

          A boot accessory for limiting how far a user can push his/her boot into a stirrup comprises an arch for hugging a front edge of the boot; a first hook disposed on the first end of the arch and a second hook disposed on the second end of the arch. The first hook curves outwardly from the first end of the arch and further a first end of the first hook curves back toward the front edge of the boot. The second hook curves outwardly from the second end of the arch and further a first end of the second hook curves back toward the front edge of the boot. A gap exists between the first end of the first hook and the arch and between the first end of the second hook and the arch, wherein the gaps are for engaging sides of the stirrup.




          ups

          PHOTOCONDUCTOR HAVING CROSSLINKABLE TRANSPORT MOLECULES HAVING FOUR RADICAL POLYMERIZABLE GROUPS AND METHOD TO MAKE THE SAME

          An improved organic photoconductor drum having a protective overcoat layer and method to make the same is provided. The protective overcoat layer is prepared from a curable composition including a crosslinkable hole transport molecule containing four radical polymerizable functional groups in combination with a crosslinkable acrylate having at least 6 functional groups.




          ups

          CANCER PROGRESSION OBSERVATION INDEX GENE GROUP AND METHOD OF DETECTING THE GENE GROUPS

          A method of detecting a cancer progression observation index gene group, comprising: a) preparing a plurality of AKR/J mice in which an oncogene is inserted into a thymocyte; b) dividing the AKR/J mice into three groups, raising the first group of the AKR/J mice after high-dose ionizing radiation of 0.8 Gy/min, raising the second group of the AKR/J mice after low-dose ionizing radiation of 0.7 mGy/hr, and raising the third group of the AKR/J mice in a general environment; c) obtaining a thymus of a dead mouse of the first or second group of the AKR/J mice throughout the b) operation and diagnosing cancer when a weight of the thymus is increased to twice or more than before radiation; d) extracting thymuses by sacrificing the first to third groups of the AKR/J mice at the time at which the third group of the AKR/J mice initially die; and e) selecting only a thymus having no change in weight compared to the organs of the same-aged non-irradiated AKR/J mice from the organs extracted in d) and detecting a gene of the organ whose weight is increased or decreased by a factor of two or more through gene analysis.




          ups

          Katy Perry and Christina Aguilera Added to 'Disney Family Singalong: Volume II' Line-Ups

          The sequel to Disney Family Singalong will be aired on Mother's Day with Jennifer Hudson and John Legend set to deliver their version of the 'Beauty and the Beast' theme.




          ups

          Donald Trump 'Upset' After His Personal Valet Tests Positive for Coronavirus

          The valet's positive diagnosis sparks fear of COVID-19 spread in the West Wing, but the White House assures that the president and Vice President Mike Pence 'have since tested negative for the virus.'




          ups

          Erdington Neighbourhood Network Scheme looking for support groups

          Funding available to help local residents.




          ups

          Hospice launches Harborne Fundraising Groups to raise vital funds

          Birmingham St Mary’s Hospice has unveiled its latest venture aimed at supporting the services on which so many rely.




          ups

          Council opposition groups condemn Perry Barr flyover proposal

          Joint Lib Dem and Conservative call for demolition plans to be scrapped.





          ups

          Startups like Oyo, Zomato offer more Esops to staff to ease pay cut pain

          In April, Zomato initiated a voluntary salary reduction programme, which also offers affected employees’ additional stock in lieu of the cash cut from their pay cheques.




          ups

          Payments platform Simpl records about 35% upsurge in daily essentials transactions through online orders

          Green Visor Capital backed-Simpl, that allows users to buy now and checkout with pay-later function, said the surge in the number of transactions done for daily essentials increased despite supply and workforce issues by merchant partners.




          ups

          Anil Ambani-led Reliance Games to incubate and invest in gaming startups

          “For incubators, we want to look at India as the first starting point,” said Manish Agarwal, CEO of Reliance Entertainment.




          ups

          Indian gaming and mobile app startups leveraging cloud

          The mobile app development companies as well as independent developers are leveraging this to pitch their apps into the market.




          ups

          Hundreds of short-legged pups celebrate Corgi Con

          Corgi Con is a semi-annual celebration of short, sausage-shaped dogs called Corgis. Hundreds of dogs and their families descend on Ocean Beach for a day of events and festivities.




          ups

          4 Dead After Armed Robbers Hijack UPS Truck

          Updated at 11:35 a.m. ET on Saturday A pair of armed robbers and two others, including the driver of a hijacked UPS truck, were killed in an exchange of gunfire with South Florida police officers after the suspects led authorities on a high-speed chase. The robbers held up a jewelry store on Thursday before commandeering the UPS truck and holding its driver hostage, according to Coral Gables Police . After fleeing the scene and evading police for dozens of miles, the truck stopped in the middle of rush-hour traffic as armed officers surrounded it. "There was exchanged fire between law enforcement and the suspects, and unfortunately, the suspects are now deceased," George Piro, the special agent in charge of the FBI's Miami office, said . "But two additional innocent civilians were also deceased." Former Department of Housing and Urban Development official Brandon Friedman described the shootout as "appalling." He said the police department should be held accountable for "choosing to




          ups

          Für Wein-Start-ups ist die Corona-Krise ein Glücksfall

          Wein erweist sich in Corona-Zeiten als krisenfest. Davon profitieren vor allem Gründer und ihre Internetshops. Dabei halten typische Käufer eigentlich nicht viel vom Online-Shopping. Das könnte sich nun ändern.




          ups

          TWTHE, Identity, Social Groups, and Behavior Change

          There is an observation in psychology that looks at how people behave when they have not lived up to the expectations they set for themselves; The What The Hell Effect. In this episode of Two Guys on Your Head, Dr. Art Markman, and Dr. Bob Duke discussion about TWTHE and how it relates to identity,...




          ups

          Frantic fundraising, relief that can’t meet demand: Artists and arts groups scramble amid coronavirus crisis


          The coronavirus-shutdown crisis has ripped through Seattle’s arts and culture scene, guillotining income for individual artists and organizations while they scramble to cut expenses.