mmi

The Justice Department and the Federal Trade Commission Announce Expedited Antitrust Procedure and Guidance for Coronavirus Public Health Efforts

The U.S. Department of Justice Antitrust Division and The Federal Trade Commission today issued a joint statement detailing an expedited antitrust procedure and providing guidance for collaborations of businesses working to protect the health and safety of Americans during the COVID-19 pandemic.




mmi

Justice Department and Federal Trade Commission Jointly Issue Statement on COVID-19 and Competition in U.S. Labor Markets

The Department of Justice’s Antitrust Division and the Federal Trade Commission’s (FTC) Bureau of Competition jointly released a statement today affirming the importance of competition for American workers.  The agencies also announced that they will protect competition for workers on the frontlines of the Coronavirus Disease 2019 (COVID-19) response in the United States by enforcing the antitrust laws against those who seek to exploit the pandemic to engage in anticompetitive conduct in labor markets.




mmi

Beshear Appoints Four New Kentucky Racing Commissioners, Rabinowitz New Chairman

When the Kentucky Horse Racing Committee holds its next scheduled meeting on June 16, it will have a new chairman and four new members. On April 28, an executive order from Democratic Gov. Andy Beshear appointed Alan J. Leavitt, Dr. Naveed Chowhan, Jonathan Rabinowitz and James Edwin “Ed” Worley to the commission. Charles Francis O'Connor […]

The post Beshear Appoints Four New Kentucky Racing Commissioners, Rabinowitz New Chairman appeared first on Horse Racing News | Paulick Report.




mmi

'Vida' and 'Never Have I Ever': shining examples of TV finally welcoming immigrants with open arms




mmi

Cummings: Secret Service 'Worked Well' When Apprehending White House Fence Jumper

Cummings says on MSNBC that security will have to be upgraded at the White House, and it will have to strike a balance.




mmi

Congressman Cummings Defends Ebola Response In NYC

Some members of Congress say the new Ebola infection in New York City is exposing flaws in the system and raising new concerns.




mmi

See a historic brownstone row house on Summit Avenue

Home is in same row as F. Scott Fitzgerald's former home




mmi

Himmicanes!

Just a reminder that life goes on (thanks to commenter Lemmus), from the British Journal of Social Psychology: Are women more likely to wear red and pink at peak fertility? What about on cold days? Conceptual, close, and extended replications with novel clothing colour measures. Evolutionarily minded researchers have hypothesized that women advertise their ovulatory […]




mmi

Tree Removal and Trimming at Indian Garden, September 28-30, 2015

Tree removal and trimming will occur adjacent to the Bright Angel Trail near the Indian Garden day-use area Monday, September 28 through Wednesday, September 30. https://www.nps.gov/grca/learn/news/indian-garden-tree-trimming.htm




mmi

ALSC and ACM accepting applications for Forum on Service to Immigrants/Refugees

CHICAGO — The Association for Library Service to Children (ALSC) and the Association of Children’s Museums (ACM) are accepting applications to participate in the Welcoming Spaces National Forum on June 25, 2020 in Chicago, IL, as part of a National Leadership Grant from the Institute of Museum and Library Services.




mmi

NAB Files Comments With FCC Supporting Geotargeted Separate Programming On FM Booster Stations

The proposal by GEOBROADCAST SOLUTIONS to allow FM boosters to transmit geotargeted programming like ads and news separate from the primary station's programming has gained the support of … more




mmi

Inaugural JBE SummitFest Postponed Until 2021, 2020 Virtual SummitFest Plans Announced

Due to the COVID-19 CORONAVIRUS pandemic, JACK BARTON ENTERTAINMENT (JBE) has decided to postpone the first JBE TRIPLE A SUMMITFEST in BOULDER, CO, scheduled for AUGUST 4-7, until AUGUST … more




mmi

SummitMedia/Richmond Launches Online Food Drive

SUMMITMEDIA's RICHMOND cluster is holding an online food drive TODAY through MAY 31st to support FEED MORE, a food bank serving CENTRAL VIRGINIA. The stations usually hold the "FEED … more




mmi

Swimming Pool

Viem from Luna condominium tower in CityPlace....




mmi

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.  




mmi

Heart disease risk profiles differ widely among African Americans, blacks from the Caribbean and African immigrants

Research Highlights: Black immigrants from Africa and from the Caribbean differ from U.S.-born blacks in rates of high blood pressure, diabetes, smoking and overweight/obesity. The research supports a more detailed look at black populations and the...




mmi

Iowa should give cash to undocumented immigrants

Immigrants have been disproportionately affected by COVID-19 pandemic. They’re more likely than native-born Americans to be laboring to keep our essential services running, especially in the...




mmi

Iowa should give cash to undocumented immigrants

Immigrants have been disproportionately affected by COVID-19 pandemic. They’re more likely than native-born Americans to be laboring to keep our essential services running, especially in the food processing sector that has been ravaged by the pandemic.

And yet immigrants living here illegally — including many food industry workers, their family members and people who have been living here since they were children — do not get the same coronavirus relief that legal citizens do, such as the $1,200 federal payment millions of Americans are receiving.

To remedy the situation, Iowa could coordinate direct cash payments to undocumented immigrants who were left out of the federal program. California announced such a program last month, offering $500 payments to thousands of undocumented Californians.

The public health crisis is tightly bound to the immigration crisis. It has exposed disparities in the workforce and also given rise to protectionists who want to restrict migration.

Iowa’s meat processing industry has been slammed by the virus, with at least one plant in Iowa reporting more than half of its workers have tested positive. Those production lines are heavily populated by immigrants. Well over 1,000 combined cases have been reported at four major packing facilities.

Nationally, 28 percent of agriculture workers and 29 percent of food processing workers are foreign-born, according to the pro-immigration New American Economy Research Fund.

Most immigrant workers have legal status, but many don’t. Some of those who are legal have family members who are undocumented. An influx of cash would help bring some stability to struggling families so they can weather the crisis.

At the same time we are asking essential workers to risk their health to sustain us, the anti-immigration lobby has used the pandemic as an opportunity to ramp up their campaign to cut off the flow of workers across borders. As one recent example, four GOP senators — including Iowa’s Sen. Chuck Grassley — sent a letter this week to the Trump administration, asking for guest worker visas to be suspended until next year.

In the pandemic, the idea of giving people money quickly gained political support. Direct payments are not mucked up by the corporate cronyism that plagues traditional economic development, a la checks to companies and targeted tax breaks. When politicians and bureaucrats pick certain businesses to stimulate, they do a bad job.

As long as the government is doing stimulus, the best avenue is writing checks to individuals. People need to buy stuff and as long as the economy limps on, they can buy stuff with money. Immigrants are people, even if they came here illegally. They are also workers, caretakers and taxpayers.

Direct payments would not be a special kickback or a reward for people living in the country illegally. It would be just like the $1,200 direct deposit I got from the government. It comes with a recognition that they are the same as us, important contributors of our culture and economy who are victims of an unworkable legal system.

If the federal government won’t do it, Iowa should.

adam.sullivan@thegazette.com; (319) 339-3156




mmi

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

    mmi

    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

      mmi

      How to Set a Default Commit Message

      Having a default commit message is really useful for a number of reasons: It can formalize your commit messages It serves as a good reminder for the information you should add to your commit message, like issue number If you set it to “Drunk AF, don’t accept this” To set a default commit message on […]

      The post How to Set a Default Commit Message appeared first on David Walsh Blog.




      mmi

      Which Programming Language Should Mobile Developers Choose?

      When building new apps, the most important thing developers must decide is which language to program in. There are several languages out there, and some are preferred for certain operating...




      mmi

      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

        mmi

        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

          mmi

          Cameron-Liebler sets in Hamming graphs. (arXiv:2005.02227v2 [math.CO] UPDATED)

          In this paper, we discuss Cameron-Liebler sets in Hamming graphs, obtain several equivalent definitions and present all classification results.




          mmi

          Multitype branching process with nonhomogeneous Poisson and generalized Polya immigration. (arXiv:1909.03684v2 [math.PR] UPDATED)

          In a multitype branching process, it is assumed that immigrants arrive according to a nonhomogeneous Poisson or a generalized Polya process (both processes are formulated as a nonhomogeneous birth process with an appropriate choice of transition intensities). We show that the renormalized numbers of objects of the various types alive at time $t$ for supercritical, critical, and subcritical cases jointly converge in distribution under those two different arrival processes. Furthermore, some transient moment analysis when there are only two types of particles is provided. AMS 2000 subject classifications: Primary 60J80, 60J85; secondary 60K10, 60K25, 90B15.




          mmi

          Decentralized and Parallelized Primal and Dual Accelerated Methods for Stochastic Convex Programming Problems. (arXiv:1904.09015v10 [math.OC] UPDATED)

          We introduce primal and dual stochastic gradient oracle methods for decentralized convex optimization problems. Both for primal and dual oracles the proposed methods are optimal in terms of the number of communication steps. However, for all classes of the objective, the optimality in terms of the number of oracle calls per node in the class of methods with optimal number of communication steps takes place only up to a logarithmic factor and the notion of smoothness. By using mini-batching technique we show that all proposed methods with stochastic oracle can be additionally parallelized at each node.




          mmi

          Converging outer approximations to global attractors using semidefinite programming. (arXiv:2005.03346v1 [math.OC])

          This paper develops a method for obtaining guaranteed outer approximations for global attractors of continuous and discrete time nonlinear dynamical systems. The method is based on a hierarchy of semidefinite programming problems of increasing size with guaranteed convergence to the global attractor. The approach taken follows an established line of reasoning, where we first characterize the global attractor via an infinite dimensional linear programming problem (LP) in the space of Borel measures. The dual to this LP is in the space of continuous functions and its feasible solutions provide guaranteed outer approximations to the global attractor. For systems with polynomial dynamics, a hierarchy of finite-dimensional sum-of-squares tightenings of the dual LP provides a sequence of outer approximations to the global attractor with guaranteed convergence in the sense of volume discrepancy tending to zero. The method is very simple to use and based purely on convex optimization. Numerical examples with the code available online demonstrate the method.




          mmi

          A Note on Cores and Quasi Relative Interiors in Partially Finite Convex Programming. (arXiv:2005.03265v1 [math.FA])

          The problem of minimizing an entropy functional subject to linear constraints is a useful example of partially finite convex programming. In the 1990s, Borwein and Lewis provided broad and easy-to-verify conditions that guarantee strong duality for such problems. Their approach is to construct a function in the quasi-relative interior of the relevant infinite-dimensional set, which assures the existence of a point in the core of the relevant finite-dimensional set. We revisit this problem, and provide an alternative proof by directly appealing to the definition of the core, rather than by relying on any properties of the quasi-relative interior. Our approach admits a minor relaxation of the linear independence requirements in Borwein and Lewis' framework, which allows us to work with certain piecewise-defined moment functions precluded by their conditions. We provide such a computed example that illustrates how this relaxation may be used to tame observed Gibbs phenomenon when the underlying data is discontinuous. The relaxation illustrates the understanding we may gain by tackling partially-finite problems from both the finite-dimensional and infinite-dimensional sides. The comparison of these two approaches is informative, as both proofs are constructive.




          mmi

          Electricity-Aware Heat Unit Commitment: A Bid-Validity Approach. (arXiv:2005.03120v1 [eess.SY])

          Coordinating the operation of combined heat and power plants (CHPs) and heat pumps (HPs) at the interface between heat and power systems is essential to achieve a cost-effective and efficient operation of the overall energy system. Indeed, in the current sequential market practice, the heat market has no insight into the impacts of heat dispatch on the electricity market. While preserving this sequential practice, this paper introduces an electricity-aware heat unit commitment model. Coordination is achieved through bid validity constraints, which embed the techno-economic linkage between heat and electricity outputs and costs of CHPs and HPs. This approach constitutes a novel market mechanism for the coordination of heat and power systems, defining heat bids conditionally on electricity market prices. The resulting model is a trilevel optimization problem, which we recast as a mixed-integer linear program using a lexicographic function. We use a realistic case study based on the Danish power and heat system, and show that the proposed model yields a 4.5% reduction in total operating cost of heat and power systems compared to a traditional decoupled unit commitment model, while reducing the financial losses of each CHP and HP due to invalid bids by up-to 20.3 million euros.




          mmi

          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. 




          mmi

          Spokane Comedy Club bringing the laughs from Dan Cummins, Spokane's Kelsey Cook and more right to your computer this weekend

          The Spokane Comedy Club might be quiet right now, but there are still laughs to be had on Zoom, and not just from watching your co-workers try to navigate the online meeting platform. Saturday night, and again next Saturday, the comedy club is hosting Comedians Doing Comedy: A Virtual Comedy Show.…



          • Arts & Culture

          mmi

          How to make cannabis gummies at home

          The Cannabis Issue Like the best gas station treats that tempt even the most mature adults on a good road trip, gummies cater to that need to chew on something sweet while basking in the sunshine.…



          • Special Guides/Cannabis Issue

          mmi

          Multipass programming in buffers implemented in non-volatile data storage systems

          The various implementations described herein include systems, methods and/or devices used to enable multipass programming in buffers implemented in non-volatile data storage systems (e.g., using one or more flash memory devices). In one aspect, a portion of memory (e.g., a page in a block of a flash memory device) may be programmed many (e.g., 1000) times before an erase is required. Some embodiments include systems, methods and/or devices to integrate Bloom filter functionality in a non-volatile data storage system, where a portion of memory storing one or more bits of a Bloom filter array may be programmed many (e.g., 1000) times before the contents of the portion of memory need to be moved to an unused location in the memory.




          mmi

          Applying coding standards in graphical programming environments

          Graphical programming or modeling environments in which a coding standard can be applied to graphical programs or models are disclosed. The present invention provides mechanisms for applying the coding standard to graphical programs/models in the graphical programming/modeling environments. The mechanisms may detect violations of the coding standard in the graphical model and report such violations to the users. The mechanisms may automatically correct the graphical model to remove the violations from the graphical model. The mechanisms may also automatically avoid the violations in the simulation and/or code generation of the graphical model.




          mmi

          Application programming interface, system, and method for collaborative online applications

          An application framework including different application programming interfaces (APIs) is described which performs a variety of mobile device functions in response to API calls from applications. For example, in response to relatively simple API calls made by applications the application framework manages the complex tasks associated with invitations and matchmaking. By way of example, the details of complex transactions such as establishing peer-to-peer connections between mobile devices may be transparent to the application developer, thereby simplifying the application design process. The application framework may include an application daemon for communicating with a first set of services and an applications services module for communicating with a separate set of services. The application framework may also include a cache for caching data for each of the services based on different cache management policies driven by each of the services. The cache may be updated by push notification cache updates sent from each of the services.




          mmi

          System and method to boost application performance by using a proxy for executing synchronous application programming interface calls

          Techniques are described for utilizing synchronous APIs which normally block callers until a result is returned. In particular, the techniques described herein enable an application or other programming construct to boost performance by executing synchronous APIs (e.g., long running time APIs) within a proxy container rather than executing the synchronous APIs in the context of the application itself. Since the proxy is a separate process or thread, the caller application is thereby released from waiting for the synchronous API call and may proceed with other processing instead of waiting for the synchronous API to return. The application may then monitor the proxy to determine whether a result has been received, such as by periodically polling the proxy.




          mmi

          Programming language conditional event dispatcher

          Methods and systems of monitoring events occurring in a computer system are provided. An event monitoring instruction including a condition is parsed, the event monitoring instruction expressed using syntax defined in source code, the parsing resulting in an event channel to monitor and the condition. Then execution of an application is paused. The event channel is monitored until an event occurs on the event channel. Then an event handler for the event is run in response to the event occurring on the event channel. The condition is evaluated to determine whether the condition is satisfied. Execution of the application is resumed in response to the condition being satisfied.




          mmi

          Communicating physical layer wireless parameters over an application programming interface

          Methods, systems, and devices are described for communicating physical layer wireless parameters over an application programming interface. A wireless modem of a wireless device may measure at least one physical layer wireless parameter. The wireless modem may report the at least one physical layer wireless parameter to an application running on the wireless device over an application programming interface between the wireless modem and the application. A behavior of the application may be adapted to control wireless communications between the application and a network based on the at least one physical layer wireless parameter reported by the wireless modem. Other aspects, embodiments, and features are also claimed and described.




          mmi

          Trimming circuit for clock source

          A semiconductor trimming circuit includes parallel coupled PMOS devices coupled in parallel with parallel coupled NMOS devices and an additional pair of dummy NMOS devices. The dummy NMOS devices are coupled in parallel with the NMOS devices. A trimming circuit for an internal clock source may be formed with an array of such switches for selecting one or more trimming capacitors of the trimming circuit. Such an array has a low leakage current and permits good trimming linearity.




          mmi

          Chair to assist physically challenged persons in swimming

          The present invention relates to a swim chair that allows a mobility challenged individual to be transported across the sand with exceptional ease, to lounge on the chair and enjoy the company and sights, to be pulled into the water and, if able, to slip off the chair to go for a swim, remount the chair and return to shore. The chair includes a main frame, defined by a top frame member and two side frame members; two axle support plates, at or in communication with the side frame members of the main frame, the axle support plates having a plurality of openings to receive a wheel axle and optionally a pull rod axle; a wheel assembly; a drop seat; a footrest and a backrest.




          mmi

          Multipass rotary shear comminution process to produce corn stover particles

          A process of comminution of corn stover having a grain direction to produce a mixture of corn stover, by feeding the corn stover in a direction of travel substantially randomly to the grain direction one or more times through a counter rotating pair of intermeshing arrays of cutting discs (D) arrayed axially perpendicular to the direction of corn stover travel.




          mmi

          Apparatus for circulating comminuted materials

          An improved scraper plate assembly is provided on a comminuting device having compliant rounded edges, sloped walls, and reduced height for placement along recycle flow paths within a comminuting apparatus when circulating subdivided waste material from between a pair of scissor rolls for further delivery to a scissor roll for further movement and subdividing of the subdivided waste material. A comminuting apparatus is also provided.




          mmi

          Swimming pool net

          A swimming pool net includes a mesh material and a frame that circumscribes the mesh. Fasteners are positioned in the frame to secure the mesh to the frame. A pair of mounts is formed in the frame in opposed relation to one another. A spring has opposed ends that respectively engage the opposed mounts. The spring is taut when its opposite ends engage the mounts. A middle section of the spring is manually pulled and spaced apart from the mesh by a preselected distance, followed by abrupt release of the spring, causing the middle section to travel from a first side of the frame to a second side, striking the mesh as the spring passes through the plane of the frame and ejecting items away from the mesh. The mounts may be apertures or posts or the ends of the spring may be embedded in the frame.




          mmi

          Visual system for programming of simultaneous and synchronous machining operations on lathes

          A system and method allows visual programming of simultaneous and synchronous machining operations on multi-axis lathes. The system and method accounts for different combinations of simultaneous and synchronized lathe operations on the spindles which can utilize multiple tools. A graphic synchronization icon is assigned to each mode that preferably represents the lathe operation. Appropriate synchronous operations are grouped together in synchronization groups. The system and method are universal since a postprocessor processes the synchronization modes and synchronization groups, and translates them for use with computer programs understood by a particular CNC lathe.




          mmi

          Hummingbird feeder

          A system for creating a plurality of sheltered stalls around feeding ports of a hummingbird feeder. The sheltered stalls may be formed by generally V-shaped members having opposed curved wings, one stall being formed beneath abutting wings of two abutting generally V-shaped members. The generally V-shaped members may be supported on mounting hooks which are either integral with or removable from the hummingbird feeder. The sheltered stalls and mounting hooks are red. The system may include the hummingbird feeder. The system deters dominant males from preventing use of the hummingbird feeder by competing hummingbirds.




          mmi

          Waterless degumming system

          A method and system for cleaning lignin and other gums from lignocellulosic fiber is disclosed. Lignocellulosic fiber is rapidly depressurized to a pressure lower than atmospheric pressure. The fiber is exposed to ionized air during the rapid depressurization. The fiber is then repressurized to a pressure equal to or greater than atmospheric pressure.




          mmi

          Data flow programming of computing apparatus with vector estimation-based graph partitioning

          In various embodiments, a spectral graph partitioner (“SP”) of a graph partitioning system (“GPS”) may partition a data flow graph associated with a program into a plurality of subgraphs to be used to perform analysis or debugging. The SP may generate estimated eigenvectors for a matrix representing the graph through minimization of a function on the vectors. The SP may generate multiple eigenvectors to perform the clustering in a multi-dimensional space described by the eigenvectors. The SP may refine the clustering by repeating generation of eigenvectors to describe higher-dimensional spaces and perform further clustering. The SP may also determine quality metrics for the clusters and may stop refinement based on the quality metrics. The GPS may select between utilizing the SP or utilizing one or more other partitioners based on various factors such as, for example, graph size or quality metrics. Other embodiments may be described and/or claimed.




          mmi

          REDUCING PROGRAMMING DISTURBANCE IN MEMORY DEVICES

          Apparatus and methods are disclosed, such as a method that includes precharging channel material of a string of memory cells in an unselected sub-block of a block of memory cells to a precharge voltage during a first portion of a programming operation. A programming voltage can then he applied to a selected memory cell in a selected sub-block of the block of memory cells during a second portion of the programming operation. The selected memory cell is coupled to a same access line as an unselected memory cell in the unselected sub-block. Additional methods and apparatus are disclosed.




          mmi

          NONVOLATILE MEMORY DEVICE AND METHOD OF PROGRAMMING THE SAME

          A nonvolatile memory device is provided as follows. A memory cell array includes a plurality of memory cells. An address decoder provides a first verify voltage to selected memory cells among the plurality of memory cells in a first program loop and provides a second verify voltage to the selected memory cells in a second program loop. A control logic determines the second program loop as a verify voltage offset point in which the first verify voltage is changed to the second verify voltage based on a result of a verify operation of the first program loop.