stream

The Newest Athletes: eSports Gamers and Video Game Streamers

Most kids spend countless hours playing video games in their free time, but for some this hobby could potentially turn into a career. eSports and video game streaming have become a multibillion-dollar industry, drawing sponsorships from companies like Procter and… Read More

The post The Newest Athletes: eSports Gamers and Video Game Streamers appeared first on Anders CPAs.




stream

370- The Pool and the Stream Redux

This is the newly updated story of a curvy, kidney-shaped swimming pool born in Northern Europe that had a huge ripple effect on popular culture in Southern California and landscape architecture in Northern California, and then the world. A documentary in three parts with a brand new update about how this episode resulted in a brand new skate park in a very special city.

The Pool and the Stream Redux




stream

Before you regulate, streamline

​​Without any protocol for resolving conflicting views between regulators on the same issue, stakeholders such as the parties involved in disputes, as well as consumers, at large suffer. Moreover, the regulatory burden for entities involved to supply information, litigate at multiple fora, etc, adding to the cost and (un)ease of doing business.




stream

Eight Defendants Charged with Running Two of the Largest Illegal Television Show and Movie Streaming Services in the United States

A federal grand jury returned an indictment today charging eight individuals with conspiring to violate federal criminal copyright law by running two of the largest unauthorized streaming services in the United States, resulting in the loss of millions of dollars by television program and motion picture copyright owners.




stream

Newport Man Pleads Guilty to Copyright Infringement for Creating Illegal Video Streaming and Downloading Websites




stream

First 2-Year-Old By Kentucky Derby Winner Nyquist Races At Gulfstream On Friday

Wesley Ward-trained Breakthrough, a son of 2016 Florida Derby (G1) and Kentucky Derby (G1) winner Nyquist, has been installed as the 6-5 morning-line favorite in a $65,000 maiden special weight race for 2-year-olds on Friday's program at Gulfstream Park. Breakthrough, who was purchased for $330,000 at the 2019 Fasig Tipton Kentucky July sale, is scheduled […]

The post First 2-Year-Old By Kentucky Derby Winner Nyquist Races At Gulfstream On Friday appeared first on Horse Racing News | Paulick Report.




stream

Former Old Friends Retiree Sunshine Forever Honored With Stakes Race Saturday At Gulfstream

On Saturday May 9, 2020, the featured stakes at Florida's Gulfstream Park will be the Sunshine Forever Stakes, a tribute to the champion grass runner who was the first stallion retired to Old Friends, the non-profit Thoroughbred retirement facility based in Georgetown, KY. The son of Roberto out of the stakes-placed mare Outward Sunshine (by […]

The post Former Old Friends Retiree Sunshine Forever Honored With Stakes Race Saturday At Gulfstream appeared first on Horse Racing News | Paulick Report.




stream

Nicoletti, Courtney Handicap Gulfstream’s Rainbow 6 Mandatory Payout

Gulfstream Park's mandatory payout of its 20-cent Rainbow 6 is expected to have a final pool Saturday of more than $6 million. The sequence, which begins in the seventh race with a $55,000 allowance event at five furlongs on the turf, also includes the 4-year-old debut of Preakness (G1) winner War of Will in the […]

The post Nicoletti, Courtney Handicap Gulfstream’s Rainbow 6 Mandatory Payout appeared first on Horse Racing News | Paulick Report.




stream

War Of Will Back On Turf For Saturday’s Sunshine Forever Stakes At Gulfstream

Trainer Mark Casse believes the performance by Gary Barber's War of Will in the 2018 Breeders' Cup Juvenile Turf (G1) may have been good enough to win had he gotten a better trip War of Will's fifth-place finish, though, turned to be a blessing in disguise. “He could have easily won the Breeders' Cup. If […]

The post War Of Will Back On Turf For Saturday’s Sunshine Forever Stakes At Gulfstream appeared first on Horse Racing News | Paulick Report.




stream

Silvies Valley Ranch, OR: using artificial beaver dams to restore incised streams

The Silvies Valley Ranch is an example of using local innovation to combat the global problem of incised streams on rangelands. Incised channels reduce the flow between water in the channel and water in the surrounding soils, which reduces the vegetation available for wildlife habitat and cattle forage. One of the ranch owners, Scott Campbell, a doctor of veterinary medicine, believes that stream incision is related to the decline of beaver populations; thus, the ranch’s approach to restoration includes efforts to mimic beavers’ influence on the system. He is using an extensive network of low-rise dams made from locally available materials (dirt, gravel, rock, and logs), commonly referred to as “artificial beaver dams” (ABDs). Campbell said that the ABDs on the ranch successfully increased stream connectivity to their floodplains and increased the quantity and forage quality of wet meadows on the property, with no changes in where cattle were grazing. The experiences of this landowner exemplify a unique approach that provides a model for others facing similar challenges to doing restoration on private land. The transformation taking place on the Silvies Valley Ranch has garnered the attention of neighboring ranch owners, some of whom are beginning to experiment with similar restoration technologies. Campbell would like to continue installing structures, but has encountered numerous roadblocks in the permitting process. He has since taken an active role in building legislative support for the ABD technology being used on the ranch, and in facilitating its adoption in other places. This case study—based on interviews with stakeholders involved in the Silvies Valley Ranch project—highlights the social benefits and challenges experienced by one rancher using ABDs as a restoration tool, and provides insights for improving their use in the future. It is part of a larger interdisciplinary study that explores the potential of different beaver-related restoration approaches for achieving watershed restoration and livestock production goals on rangelands in the Western United States.




stream

Flows of the future—How will climate change affect streamflows in the Pacific Northwest?

Much of the water supply in the Pacific Northwest originates in national forests. It sustains the region’s aquatic ecosystems, agriculture, hydroelectric power, and community water supplies.




stream

The idiosyncrasies of streams: local variability mitigates vulnerability of trout to changing conditions

Land use and climate change are two key factors with the potential to affect stream conditions and fish habitat. Since the 1950s, Washington and Oregon have required forest practices designed to mitigate the effects of timber harvest on streams and fish.




stream

Undercover isotopes: tracking the fate of nitrogen in streams

Excess nitrogen stemming from human activities is a common water pollutant. Fertilizer runoff, sewage, and fossil fuel emission all contain nitrogen that often ends in streams, rivers, and ultimately the ocean.




stream

Topic Tomographies. A visual approach to distil information from media streams.

The project is a collaboration between DensityDesign Lab and ISI... more




stream

Does It Work? Monitoring The Effectiveness of Stream Management Practices In Alaska

The condition of aquatic habitat and the health of aquatic species, particularly salmon, are a significant concern in the Pacific Northwest. Land management agencies use fish and riparian guidelines intended to maintain or improve aquatic habitat.




stream

Assessment of The Risk of Invasion of National Forest Streams In The Pacific Northwest By Farmed Atlantic Salmon

This report describes the evidence for invasion of Pacific Northwest streams by Atlantic salmon (Salmo salar) that have escaped from marine salmon farms, and assesses the potential impact of farmed salmon invasion on native fishes inhabiting streams on National Forest System lands. The current risk to streams on National Forest lands in the Pacific Northwest from Atlantic salmon invasions appears to be low and is limited to a few areas in northwest Washington and southeast Alaska. However, long-term risks may be substantial if fish continue to escape from marine rearing pens or freshwater hatcheries. The two greatest threats appear to be that (1) Atlantic salmon could transmit a serious disease or parasite to native fishes, and (2) escaped salmon could eventually adapt to local conditions, leading to self-sustaining populations. If Atlantic salmon populations are eventually established, this species' preference for swiftly flowing stream habitats could facilitate competition with currently at-risk species such as steelhead (Oncorhynchus mykiss). This could result in a pattern of expansion similar to that observed in other nonnative aquatic plants and animals, in which a prolonged early colonization period is followed by a rapid phase of exponential growth as breeding populations adapt to local conditions.




stream

Adrian Michaels Joins Stoney Creek As VP/Innovation, Radio & Streaming

ADRIAN MICHAELS has been named VP/Innovation, Radio & Streaming at BBR MUSIC GROUP’s STONEY CREEK RECORDS label effective MONDAY, JUNE 1st. He announced plans last week to depart … more




stream

Brody Smith Joins WKJO (Country Superstars 102.3)/Raleigh, Adds Video Livestream For His Podcast

BRODY SMITH, the former iHEARTMEDIA AC KSNE (SUNNY 106.5)/LAS VEGAS. Top 40 WDCG (G105)/RALEIGH, and Top 40 WLDI (WILD 95.5)/W. PALM BEACH personality, has joined TRIANGLE MARKETING … more




stream

UFC 249 TV info, live stream, start time and full fight card

It is being headlined by the interim lightweight title bout between Tony Ferguson and Justin Gaethje




stream

The Lumineers Present ‘Colorado Gives Back’ Live Stream Benefit

COLORADO-based THE LUMINEERS are presenting TODAY (5/8) COLORADO GIVES BACK, a live stream benefit concert from 1-4p MT for the COLORADO RESTAURANT WORKERS and NATIONAL MUSIC COMMUNITY. The … more




stream

311 To Stream Concert To Benefit Heartland Food Bank

Veteran rock band 311 is planning to give back via a free concert stream tomorrow, MAY 5th at 5p PT/8pET on their FACEBOOK and YOUTUBE pages. The band's social media pages will … more




stream

Fearless Records Presents Livestream Event 'Fearless At Home'

FEARLESS RECORDS is presenting a livestream event called "FEARLESS AT HOME" this SATURDAY, MAY 9th at 3p (ET), featuring acoustic performances from FEARLESS artists like ICE NINE … more




stream

Volbeat Streaming 'Live From Beyond Hell/Above Heaven' Concert Film

REPUBLIC Rockers VOLBEAT are treating their fans to a live stream of their concert film "Live from Beyond Hell/Above Heaven" on their YOUTUBE channel FRIDAY, MAY 8th at 10a (ET). … more




stream

Global DJ Live-Stream Fundraiser 'Set For Love' Planned For May 8-10

U.K.'s BRIGHTON MUSIC CONFERENCE has partnered with the charity LAST NIGHT A DJ SAVED MY LIFE (LNADJ) and issued an invitation to DJ's around the world to take part in Set For Love, … more




stream

88rising Presents Asia Rising Forever Live Stream

88RISING presented ASIA RISING FOREVER, an online live stream fundraising festival last night (5/6) featuring performances by many of their artists and other ASIAN recording acts from around … more




stream

Facebook Live Streaming and Audio/Video Hosting connected to Auphonic

Facebook is not only a social media giant, the company also provides valuable tools for broadcasting. Today we release a connection to Facebook, which allows to use the Facebook tools for video/audio production and publishing within Auphonic and our connected services.

The following workflows are possible with Facebook and Auphonic:
  • Use Facebook for live streaming, then import, process and distribute the audio/video with Auphonic.
  • Post your Auphonic audio or video productions directly to the news feed of your Facebook Page or User.
  • Use Facebook as a general media hosting service and share the link or embed the audio/video on any webpage (also visible to non-Facebook users).

Connect to Facebook

First you have to connect to a Facebook account at our External Services Page, click on the "Facebook" button.

Select if you want to connect to your personal Facebook User or to a Facebook Page:

It is always possible to remove or edit the connection in your Facebook Settings (Tab Business Integrations).

Import (Live) Videos from Facebook to Auphonic

Facebook Live is an easy (and free) way to stream live videos:

We implemented an interface to use Facebook as an Incoming External Service. Please select a (live or non-live) video from your Facebook Page/User as the source of a production and then process it with Auphonic:

This workflow allows you to use Facebook for live streaming, import and process the audio/video with Auphonic, then publish a podcast and video version of your live video to any of our connected services.

Export from Auphonic to Facebook

Similar to Youtube, it is possible to use Facebook for media file hosting.
Please add your Facebook Page/User as an External Service in your Productions or Presets to upload the Auphonic results directly to Facebook:

Options for the Facebook export:
  • Distribution Settings
    • Post to News Feed: The exported video is posted directly to your news feed / timeline.
    • Exclude from News Feed: The exported video is visible in the videos tab of your Facebook Page/User (see for example Auphonic's video tab), but it is not posted to your news feed (you can do that later if you want).
    • Secret: Only you can see the exported video, it is not shown in the Facebook video tab and it is not posted to your news feed (you can do that later if you want).
  • Embeddable
    Choose if the exported video should be embeddable in third-party websites.

It is always possible to change the distribution/privacy and embeddable options later directly on Facebook. For example, you can export a video to Facebook as Secret and publish it to your news feed whenever you want.


If your production is audio-only, we automatically generate a video track from the Cover Image and (possible) Chapter Images.
Alternatively you can select an Audiogram Output File, if you want to add an Audiogram (audio waveform visualization) to your Facebook video - for details please see Auphonic Audiogram Generator.

Auphonic Title and Description metadata fields are exported to Facebook as well.
If you add Speech Recognition to your production, we create an SRT file with the speech recognition results and add it to your Facebook video as captions.
See the example below.

Facebook Video Hosting Example with Audiogram and Automatic Captions

Facebook can be used as a general video hosting service: even if you export videos as Secret, you will get a direct link to the video which can be shared or embedded in any third-party websites. Users without a Facebook account are also able to view these videos.

In the example below, we automatically generate an Audiogram Video for an audio-only production, use our integrated Speech Recognition system to create captions and export the video as Secret to Facebook.
Afterwards it can be embedded directly into this blog post (enable Captions if they don't show up per default) - for details please see How to embed a video:

It is also possible to just use the generated result URL from Auphonic to share the link to your video (also visible to non-Facebook users):
https://www.facebook.com/auphonic/videos/1687244844638091/

Important Note:
Facebook needs some time to process an exported video (up to a few minutes) and the direct video link won't work before the processing is finished - please try again a bit later!
On Facebook Pages, you can see the processing progress in your Video Library.

Conclusion

Facebook has many broadcasting tools to offer and is a perfect addition to Auphonic.
Both systems and our other external services can be used to create automated processing and publishing workflows. Furthermore, the export and import to/from Facebook is also fully supported in the Auphonic API.

Please contact us if you have any questions or further ideas!




stream

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

    stream

    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

      stream

      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

        stream

        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

          stream

          Two-Stream FCNs to Balance Content and Style for Style Transfer. (arXiv:1911.08079v2 [cs.CV] UPDATED)

          Style transfer is to render given image contents in given styles, and it has an important role in both computer vision fundamental research and industrial applications. Following the success of deep learning based approaches, this problem has been re-launched recently, but still remains a difficult task because of trade-off between preserving contents and faithful rendering of styles. Indeed, how well-balanced content and style are is crucial in evaluating the quality of stylized images. In this paper, we propose an end-to-end two-stream Fully Convolutional Networks (FCNs) aiming at balancing the contributions of the content and the style in rendered images. Our proposed network consists of the encoder and decoder parts. The encoder part utilizes a FCN for content and a FCN for style where the two FCNs have feature injections and are independently trained to preserve the semantic content and to learn the faithful style representation in each. The semantic content feature and the style representation feature are then concatenated adaptively and fed into the decoder to generate style-transferred (stylized) images. In order to train our proposed network, we employ a loss network, the pre-trained VGG-16, to compute content loss and style loss, both of which are efficiently used for the feature injection as well as the feature concatenation. Our intensive experiments show that our proposed model generates more balanced stylized images in content and style than state-of-the-art methods. Moreover, our proposed network achieves efficiency in speed.




          stream

          t-SS3: a text classifier with dynamic n-grams for early risk detection over text streams. (arXiv:1911.06147v2 [cs.CL] UPDATED)

          A recently introduced classifier, called SS3, has shown to be well suited to deal with early risk detection (ERD) problems on text streams. It obtained state-of-the-art performance on early depression and anorexia detection on Reddit in the CLEF's eRisk open tasks. SS3 was created to deal with ERD problems naturally since: it supports incremental training and classification over text streams, and it can visually explain its rationale. However, SS3 processes the input using a bag-of-word model lacking the ability to recognize important word sequences. This aspect could negatively affect the classification performance and also reduces the descriptiveness of visual explanations. In the standard document classification field, it is very common to use word n-grams to try to overcome some of these limitations. Unfortunately, when working with text streams, using n-grams is not trivial since the system must learn and recognize which n-grams are important "on the fly". This paper introduces t-SS3, an extension of SS3 that allows it to recognize useful patterns over text streams dynamically. We evaluated our model in the eRisk 2017 and 2018 tasks on early depression and anorexia detection. Experimental results suggest that t-SS3 is able to improve both current results and the richness of visual explanations.




          stream

          Musicians are posting live streams and personal concerts to make your self-isolation a bit more tuneful

          Celebrities: They're just like us! Along with everyone else, famous people are self-isolating at home, and some of them have taken to social media to alleviate the stress of the outside world. We don't need to tell you that events everywhere are canceled, so a few big-time musicians are putting on personal concerts for their fans and followers, and a lot of them — save for that cringe-inducing, star-studded cover of "Imagine" that was going around yesterday — are actually pretty good.…




          stream

          New music and live streams for your self-isolation pleasure, and ways to support the local music scene

          Welcome to the quarantine.…




          stream

          Some memorable music streams to help while away your time social distancing

          While not every musician has taken to the internet to perform live shows during the (almost) nationwide lockdown, it sure seems that way. At least, it does according to my social media feeds, which lean heavily on bands and solo artists.…




          stream

          In lieu of in-person performances, musicians are using social media and live streams to connect with fans

          Ask any working musician why they play live, why they lug their equipment to and from bars and restaurants and wine-tasting rooms week after week, and they'll point to the same nebulous thing: It's the connection with an audience.…




          stream

          TV Time: 12 totally free TV streamers

          You’re out of a job. You’ve been stuck inside for weeks.…



          • Arts & Culture

          stream

          Live stream the University of Idaho's short film festival on Friday evening

          Every spring, audiences in Moscow are typically congregating for the Kino Short Film Festival, an evening of shorts made by the University of Idaho's senior film students. Things being as they are, the Kenworthy Theater won't be open for this year's event, but the U of I will be streaming a virtual version this Friday, May 8, at 6 pm.…



          • Film/Film News

          stream

          Scanning data streams in real-time against large pattern collections

          Embodiments of the disclosure include a method for partitioning a deterministic finite automaton (DFA) into a plurality of groups. The method includes selecting, with a processing device, a subset of the plurality of states and mapping each state of the subset onto a group of the plurality of groups by assigning one or more transition rules associated with each state to a rule line of the group, wherein each rule line is assigned at most two transition rules and an extended address associated with one of the at most two transition rules. The method also includes iteratively processing each state of the subset mapped onto the group by removing the extended address from each rule line in the group with transition rules referring to a current state if the transition rules in the rule line branch within the group.




          stream

          Process for removing oxygenate from an olefin stream

          The present invention provides a process for removing oxygenate from an olefin stream comprising oxygenate, comprising providing to an oxygenate recovery zone the olefin stream comprising oxygenate and a solvent comprising ethanol, treating the olefin stream comprising oxygenate with the solvent, and retrieving from the oxygenate recovery zone at least one oxygenate-depleted olefinic product stream comprising olefin and a spent solvent comprising at least part of the oxygenate.




          stream

          Separation of components from a multi-component hydrocarbon stream which includes ethylene

          A process to separate a multi-component hydrocarbon stream which includes ethylene and other components with at least some of the components being present in a number of phases, is provided. The process includes in a first flash stage, flashing the multi-component hydrocarbon stream, from an elevated pressure and temperature to a pressure in the range of 10-18 bar(a), producing a first ethylene-containing vapor stream at a pressure in the range of 10-18 bar(a) and a multi-phase stream which includes some ethylene. In a second flash stage, the multi-phase stream is flashed to a pressure of less than 6 bar(a), producing a second vapor stream at a pressure of less than 6 bar(a) and a bottoms stream. The first ethylene-containing vapor stream is removed from the first flash stage, the second vapor stream is removed from the second flash stage and the bottoms stream is removed from the second flash stage.




          stream

          Methods for removing weakly basic nitrogen compounds from a hydrocarbon stream using basic molecular sieves

          Disclosed is a method for removing weakly basic nitrogen compounds from a hydrocarbon feed stream by contacting the hydrocarbon feed stream with a basic catalyst to convert a portion of the weakly basic nitrogen compounds to basic nitrogen compounds. The method also includes contacting the hydrocarbon feed stream with an acidic adsorbent to adsorb the basic nitrogen compounds from the stream. The hydrocarbon feed stream comprises an aromatic compound and a weakly basic nitrogen compound.




          stream

          Methods for removing weakly basic nitrogen compounds from a hydrocarbon stream using acidic clay

          Disclosed is a method for removing weakly basic nitrogen compounds from a hydrocarbon feed stream by contacting the hydrocarbon feed stream with acidic clay to produce a hydrocarbon effluent stream having a lower weakly basic nitrogen compound content relative to the hydrocarbon feed stream. The hydrocarbon feed stream comprises an aromatic compound and a weakly basic nitrogen compound.




          stream

          Reduced fossil fuel in an oxidizer downstream of a biomass furnace

          Method of extracting syngas between the zone in a furnace where oxygen-starved combustion of biomass occurs and the zone in the furnace where secondary air is added to complete combustion, conditioning and cleaning the extracted syngas, and delivering it in a metered amount to the oxidizer or upstream of the oxidizer to reduce or eliminate the need for additional fossil fuels once the oxidizer has achieved its operating temperature. The gasifier or furnace burns solid waste and produces a syngas containing relatively high levels of CO, which is extracted from the furnace, conditioned, and introduced into an RTO as a fuel source. In certain embodiments, no extraction of syngas from the furnace takes place; the furnace conditions are manipulated so that normally undesirable levels of CO and other VOC's remain in the process stream. The heat from the furnace is used as intended (e.g., to heat a dryer), the stream is conditioned, and ultimately proceeds to a downstream RTO. Since the gas stream remains rich in CO and VOC's, its fuel value in the RTO is substantially higher than otherwise would be the case.




          stream

          Hardware streaming unit

          A processor having a streaming unit is disclosed. In one embodiment, a processor includes one or more execution units configured to execute instructions of a processor instruction set. The processor further includes a streaming unit configured to execute a first instruction of the processor instruction set, wherein executing the first instruction comprises the streaming unit loading a first data stream from a memory of a computer system responsive to execution of a first instruction. The first data stream comprises a plurality of data elements. The first instruction includes a first argument indicating a starting address of the first stream, a second argument indicating a stride between the data elements, and a third argument indicative of an ending address of the stream. The streaming unit is configured to output a second data stream corresponding to the first data stream.




          stream

          Generating hardware events via the instruction stream for microprocessor verification

          A processor receives an instruction operation (OP) code from a verification system. The instruction OP code includes instruction bits and forced event bits. The processor identifies a forced event based upon the forced event bits, which is unrelated to an instruction that corresponds to the instruction bits. In turn, the processor executes the forced event.




          stream

          System for generating readable and meaningful descriptions of stream processing source code

          An information processing system, computer readable storage medium, and method for automatically generating human readable and meaningful documentation for one or more source code files. A processor of the information processing system receives one or more source code files containing source code artifacts (SCA) and infers semantics therefrom based on predefined rules. The processor, based on the inferred semantics, extracts documentation from another source code file. The extracted documentation and the inferred semantics are used to generate new human readable and meaningful documentation for the SCA, such new documentation being previously missing from the SCA. The generated new documentation is included with the SCA in one or more source code files.




          stream

          Predictive software streaming

          A software streaming platform may be implemented that predictively chooses units of a program to download based on the value of downloading the unit. In one example, a program is divided into blocks. The sequence in which blocks of the program historically have been requested is analyzed in order to determine, for a given history, what block is the next most likely to be requested. Blocks then may be combined into chunks, where each chunk represents a chain of blocks that have a high likelihood of occurring in a sequence. A table is then constructed indicating, for a given chunk, the chunks that are most likely to follow the given chunk. Based on the likelihood table and various other considerations, the value of downloading particular chunks is determined, and the chunk with the highest expected value is downloaded.




          stream

          Using a dilute acid stream as an extractive agent

          Recovery of ethanol from a crude ethanol product obtained from the hydrogenation of acetic acid using an extractive distillation column. A diluted acid stream, comprising less than 30 wt. % acetic acid, is used as the extractive agent and is fed at a point above the crude feed stream. The column yields a residue that comprises ethanol, acetic acid, and water. The diluted acid stream may be separated from the residue and returned to the extractive distillation column.




          stream

          Encoder, decoder and methods for encoding and decoding data segments representing a time-domain data stream

          An apparatus for decoding data segments representing a time-domain data stream, a data segment being encoded in the time domain or in the frequency domain, a data segment being encoded in the frequency domain having successive blocks of data representing successive and overlapping blocks of time-domain data samples. The apparatus includes a time-domain decoder for decoding a data segment being encoded in the time domain and a processor for processing the data segment being encoded in the frequency domain and output data of the time-domain decoder to obtain overlapping time-domain data blocks. The apparatus further includes an overlap/add-combiner for combining the overlapping time-domain data blocks to obtain a decoded data segment of the time-domain data stream.