text:
St. Laz is a veteran NYC rapper who has been on MTV, BET, & had several songs in rotation on Hot 97. He's collaborated with almost every prominent artist over generations, from Styles P to recent hit songs with Gunna & Roddy Rich. Before all that, however, Laz served a six-year prison sentence, followed by a few parole violations. His journey took him from Rikers Island to correctional institutions throughout the New York State Department of Corrections. He served time at some of the worse facilities, including Comstock, Ft. Greene, Franklin, & more.
In this show Laz will bring you the unfiltered truth of what really goes on inside of "correctional facilities" and he holds nothing back. Sometimes hilarious, sometimes disturbing, and always memorable, Laz will tell you just how barbaric, unnecessary, and damaging mass incarceration is, from the inmates, their families, all the way to the overpoliced communities the cycles begin in.
Watch Laz tell the stories here.
Listen to Laz's Hip-Hop podcast The Super Facts Show here.
Follow St. Laz on Instagram here.
Listen to St. Laz music here.
GenPop St. Laz (Host) Mark Waldo Ward (Co-Host)
#TBT J-Hood On 2018 'Savages' Collab Album With Yukmouth
J-Hood joins the show for this #TBT episode where we discuss his joint album "Savages" with Yukmouth. We discuss how he met Yukmouth, how familiar he was with his music at the time, when they decided to record a project together, working with legends like Dru Down & Keak Da Sneak, how nice Yuk is lyrically, how Godfather from the extended Mobb Deep family came to be on the project & more.
Watch the episode HERE
Stream Yukmouth & J-Hood Savages HERE
Luce Cannon On Wack 100 Diss Song, Introducing Nipsey Hussle To YG, & More
Luce Cannon came on the show to discuss the reason behind his new song Cook Out (Wack I know Your Bitch Ass Ain't Talking) and a lot more. Among the topics we cover is him growing up with Nipsey Hussle, being locked up with YG, introducing them to each other, being in a Cheerios commercial, producing for Nas, Rihanna, & 50 Cent, & his upcoming songs with Offset, Miley Cyrus, & other notables.
Follow Luce Cannon on IG HERE
Watch/Stream "Cook Out (Wack I know Your Bitch Ass Ain't Talking)" HERE
I Hate Crack (Brooklyn Legacy)
Being released from prison presents ex-convicts with problems that are truly incomprehensible for those who haven't experienced them. Daily. Couple that with one of the most (by design) addictive drugs in history and you have this particularly gut-wrenching tale.
Subscribe to St. Laz on YouTube
Cybertron: The Decepticon Headquarters (Brooklyn Legacy)
In this episode of Brooklyn Legacy, Laz recounts his memories of the infamous Decepticons, and their "Cybertron" headquarters. This is a boots-on-the-ground tale, not the misinformation you'll get from the corporate media.Watch Part 1 HERE & Part 2 HEREListen to Laz's Hip-Hop podcast The Super Facts Show here.Follow St. Laz on Instagram here.Listen to St. Laz music here.From Wikipedia: "The Decepticons were a street gang or street organization that thrived from the late 80s through the early 90s. Their members were teenagers and young adults ranging from the age of 15 to their early 20s. The gang was most prominent in Brooklyn, but at their peak, the group consisted of multiple branches, or legions, all across New York City. In an interview with former Decepticon "General Steele", it is mentioned that there were legions of Decepticons in Clinton Hills, Flatbush, East Flatbush, and Bed Stuy Brooklyn, Harlem, Manhattan, and parts of Queens. Steele references in his interview how the Decepticons were all over the place in patches due to the group's upbringing. The legions would initially begin as a formation of a bond of bullied kids who needed strength in numbers. The original group of Decepticons started in Brooklyn, New York with three boys from two different schools. Two of the boys, who went by the names of Cyclonis and Rumble, went to Bushwick High School, and the other, called Megatron, went to Brooklyn Technical High School. They formed their bond in order to make sure no one would harm them. As those founding fathers found more people with common mindsets in the two schools they went to, their numbers grew, and soon after their small group morphed into a feared gang."
A GenPop Conversation
This one isn't particularly centered around anything specific, it's really just a conversation between Laz & Mark. We definitely touch on some of the GenPop stuff, including PopaJock. Laz discusses his aspirations, the music he's sitting on, and what kind of film he'd like to make. Health is broached, particularly with the unfortunate recent spate of rap legends who've passed away, and a lot more.
NY State Prison Greene: PopaJock Vs. The Muslims
PopaJock was Laz's longtime comrade, on the streets and upstate. Truly a memorable individual, Laz could tell stories about him for hours. In this one, he recounts a beef that PopaJock had with some Muslim inmates at Greene in 96-97.
© Copyright 2021 by St. Laz (Host) Mark Waldo Ward (Co-Host)
HERBALIST213 , 04/30/2021
🔥🔥🔥🔥🔥🔥
Yo las you in ya own lane. Keep them comin. SALUTE.
Point Breeze , 02/22/2021
Scorsesesque!!!
Honest, Vivid, Transparent, Heartfelt and at times Hilarious accounts of his time behind the walls of the New York Prison System.
Sunni in SoCal , 02/22/2021
Best Prison Channel out PERIOD
Laz got them Jewelz!!! PEACE to the true & living! SALUTE
Wild Things: Siegfried & Roy
Apple TV+ / AT WILL MEDIA
Gone South
C13Originals
Joe Rogan Experience Review podcast
Adam Thorne
itunesu_sunset


text:
Updates & News!
Human Evolution Timeline Chart
Evolution Articles
Evolution Books
Creation Evidence
Creationists
Faith, Science & Honesty
Evolution and a Creator
Lying for Jesus
Dating Methods
Evolution of Whales: Answering Answers in Genesis
This is a response to an article on the evolution of whales at the Answers in Genesis web site: Another Whale of a Tale.
The Answers in Genesis articles are written against the evidence for the evolution of whales, one of the most well-attested lineages in nature. We can reconstruct most of the families making up whale evolution from 53 million years ago until today!
Answers in Genesis Argument One:
Pakicetids are attested only by jaw and skull fragments
AiG's "Another Whale of a Tale" article gives three arguments against the evolution of whales. The first is:
Pakicetus … it consisted only of jaw and skull fragments yet itís been claimed to be a "walking whale."
Answers in Genesis gives a 2005 date for their article, so there's really no excuse for their inaccuracy. With a little research I pulled the following image from Hans Thewissen's web site. Thewissen is one of the leading researchers on whale evolution.
The caption at Thewissen's site reads:
"Photograph (above) of bones of Pakicetus (large animal) and Ichthyolestes (small animal), and a line drawing of the same skeletons."
As you can see, there's a lot more than skull and jaw fragments. Thewissen's site also gives a picture of two Pakicetus skulls that are almost complete.
Pakicetus can refer either to a family or a genus, since one of the genera in the family Pakicetidae is Pakicetus. However, the bones on the left in the picture above are from the genus Pakicetus, so there's far more than skull and jaw fragments for both the family and the genus.
Why would Answers in Genesis print something false like this about the evolution of whales?
I don't know. I've been stunned by young-earthers' dishonesty for 15 years. Somehow, even after so long a time it still astonishes me. I keep hoping for some other explanation than that they are just lying, but I'm having a lot of trouble coming up with one.
Answers in Genesis Argument Two:
Basilosaurus hind limbs are useful for grasping in reproduction.
Basilosaurus has also been offered as an ancestor to whales; while it did have hind limbs, they were far too small to have anything to do with walking. Yet evolutionists agreed that they were clearly functional, not useless, and the most common view is that they were probably used for grasping in reproduction.
This isn't an argument. There's nothing to answer.
Read my page on whale evolution. As Answers in Genesis says, evolutionists agree that these limbs might have been used for grasping while mating; however, does this answer any of the evidence I presented for the evolution of whales?
It doesn't even apply. This AiG argument is irrelevant.
Anti-evolutionists have always been confused by the multiple uses of evolving organs. As body parts evolve, so their uses can evolve as well.
Our tailbone is what remains of what was once a tail used for grasping branches in trees and for balance. Now, it is an anchor for muscles that help us balance and stand upright.
That sort of thing is common.
Answers in Genesis Argument Three:
Ambulocetus Had Nothing To Do with the History of Whales
Ambulocetus had hind limbs, and could walk; it is thus the latest fossil candidate for the evolution of whales. However, as explained in Refuting Evolution, it is doubtful that this supposed creature (constructed with some imagination) had anything to do with the history of whales.
That's a blanket statement made with no supporting evidence; however, on this page, they argue that the fibula bones, pelvis, and tail bones were not found. They also say that researchers assumed a long tail for Ambulocetus because a tail vertebrae was found five meters away from the rest of the skeleton.
Of course, no researcher would assume a long tail based on something like that. This is a ridiculous charge.
And once again—dare I say of course?—the statement is inaccurate. The following photo, again from Dr. Thewissen's web site, shows four vertebrae.
This skeleton was first described in 1994, but Answers in Genesis' 1996 and 2005 articles give inaccurate information anyway.
Also, as you can see, it is possible to estimate the length of the tail by comparing the size of the tail vertebrae and aligning them in a likely series.
Ambulocetus skeleton first described in 1994 by Dr. Hans Thewissen
It is not just the tail vertebrae statement that is inaccurate. They tell us that the pelvis is missing, which, as you can see, is not true.
The also tell us that the fibula bones are missing. This is true, but this is a four-legged animal. The radius, the arm's equivalent of the fibula, is present and in four-footed creatures the radius and fibula are corresponding bones.
Anti- Evolutionist Arguments Against the Evidence for the Evolution of Whales
I could hunt around AiG's web site to find more inaccuracies concerning the evolution of whales, but 3 strikes and you're out. The rest of their arguments will just be more of the same.
I am not a scientist. It is a very bad thing when a non-scientist can refute supposedly scholarly arguments about the evolution of whales so easily. It took very little research to rebut their arguments.
Return to Creation vs Evolution Debate
Home | Contact Me
Thou Shalt Not Bear False Witness
Nov 05, 14 01:50 PM
As an atheist with believing but rational friends from all of the three major Abrahamic religions, I sympathise. Lying for Jesus is - well, lying. It makes
How could sex have evolved? Organisms are either asexual or sexual. A species cannot change from one to the other.
Why would animals lose survival abilities through evolution?
It seems like humans would've had to evolve from an ancestor that had good survival skills before the brain developed. Other animals that exist now (and
All Bible verses are taken from the King James Version and updated for language and grammar.
Copyright © 2009-2017 Paul F. Pavao. All rights reserved.

redpajama_set_name: RedPajamaCommonCrawl


text:
Could Trump's Budget Priorities Threaten Existing Contracts?
Author: Claude M. Millman Published on: March 6, 2017 Published in: Publications
By Claude M. Millman
New York Nonprofit Media
Nonprofits receiving contract awards from New York City or the state should carefully monitor President Donald Trump's budget policies for potential retroactive effects on pre-existing contracts.
New York City Comptroller Scott Stringer recently reported that while just 9 percent of the city's budget is federally funded, city agencies that provide social services depend heavily on federal grants. The New York City Department of Housing Preservation and Development receives 48 percent of its budget from the federal government, the city Administration for Children's Services receives 43 percent and the city Department of Homeless Services gets 34 percent of its budget from the feds.
While it's obvious that federal funding cuts could affect the availability of future state and city contracts, the new federal policies could also affect prior contracts. The problem stems, in part, from two features of New York City procurement: retroactive contracting and future funding clauses.
Nonprofits often provide social services before securing registered city contracts, so the city benefits from their services before it has any contractual obligation to pay. The city comptroller reported that 69 percent of city contracts in 2015 were retroactive. The five agencies with the most retroactive contracts – all in the human services sector – registered 4,259 contracts worth $4.3 billion. Nonprofits that may be working for up to a year without pay often bridge funding gaps by deferring payrolls, borrowing from commercial banks or the city's Returnable Grant Fund.
Retroactive contracting is generally risky for nonprofits because they have to cover contract costs for an indefinite length of time and have no legal right of ever being repaid by the city. It does not usually matter that a commissioner urged the nonprofit to begin working, issued an award letter or even signed a contract. If no contract has been registered, the nonprofit may only have an "illegal but equitable" claim for a payment from the city comptroller. An appeal to the comptroller's equitable discretion may not be successful when federal funds are scarce.
An unexpected change in federal policies could increase the potentially devastating risk of not being able to recoup costs from the city.
The risks don't even end at contract registration. Multi-year contracts generally contain "future funding" clauses that make payment for each year "subject to the appropriation of funds" for that year. Thus, if a registered contract includes future funding for 2018 or 2019, for example, a loss of federal funds could gut the contract.
There are steps a nonprofit can take to mitigate some risks.
First, where possible, don't perform or continue performing without a registered contract. If your mission requires performance, work with the government – possibly through associations – to accelerate contract registration, while complying with lobbying laws.
Second, keep records of all costs and the proof of benefits bestowed on the public.
Third, identify obligations posing special risks, such as wages and taxes. The state attorney general warns that board members may be personally liable for failing to pay employees' wages and benefits, and for failing to pay state and federal taxes on employees' wages. Work with counsel to ensure that these obligations are addressed.
Fourth, investigate "pay when paid" arrangements with subcontractors, suppliers and other partners to spread the risks of performing work without a registered contract. Work with lawyers to select contract structures that are most likely to protect such agreements, such as choosing the law of a favorable jurisdiction.
Fifth, avoid giving personal guarantees to secure the organization's debts and explore whether existing guarantees can be released.
Sixth, consider disclosing risks to board members, auditors, creditors, major funders and other stakeholders. While these risks should not surprise diligent stakeholders, written disclosures discourage disputes.
Perhaps local government will seize this moment to end retroactive contracting. Such a long-awaited reform would be most welcome now.
View The Original Article
Government Procurement and Contracting Claude M. Millman Share On


text:
Person: Jules Spinatsch
8 Apr '22 – 17 Jul '22
Take Care: Kunst & Medizin | Kunsthaus Zürich
Group show curated by Cathérine Hug, with works by Panteha Abareshi, Ilit Azoulay, Jean-Michel Basquiat, Sabian Baumann, Judith Bernstein, Joseph Beuys, Louise Bourgeois, Rachal Bradley, Stefan Burger, Sophie Calle, Sabina Carraro, Georges Chicotot, Honoré Daumier, Jean Dubuffet, Albrecht Dürer, Max Ernst, Adolf Fleischmann, General Idea, Michael Günzburger, Anna Halprin and Ruedi Gerber, Barbara Hammer, Christoph Hänsli, Duane Hanson, Lynn Hershman Leeson, Damien Hirst, Ferdinand Hodler, Andreas Hofer, Hanspeter Hofmann, huber.huber, Anna Jermolaewa, Hennric Jokeit, Fritz Kahn, Martin Kippenberger, Paul Klee, Herlinde Koelbl, Bruce Nauman, MANON, Michelle Miles, Shana Moulton, Thomas Müllenbach, Matt Mullican, Meret Oppenheim, Uriel Orlow, Herbert Ploberger, Maria Pomiansky, Marc Quinn, Arnulf Rainer, RELAX chiarenza & hauser & co, Pipilotti Rist, Ana Roldán, Pamela Rosenkranz, Corinne L. Rusch, Talaya Schmid, Kiki Smith, Veronika Spierenburg, Jules Spinatsch, Lucy Stein, Daniel Spoerri, Rosemarie Trockel, Luc Tuymans, Varlin, Andreas Vesalius, Lotte Luise Volger, Christine Tien Wang and Nives Widauer.
Health is a timeless human preoccupation. The sensitive body is at once a working tool and object of observation. Taking their cue from works in the Kunsthaus collection, six chapters examine the productive interplay of sickness and pain, medicine, care and healing through 300 exhibits, over 200 of which are being made available by some 40 national and international lenders. Early examples date back to the 15th century, while the most recent are works from 2022 produced specially for the exhibition.
4 Oct '21 – 6 Feb '22
Earth Beats, Naturbild im Wandel | Kunsthaus Zürich
A major exhibition exploring artists' engagement with the planet and its vulnerability. It considers both the history of ideas and future scenarios for the sustainable use of natural resources. 'Earth Beats' is an artists' plea to preserve the Earth and its natural resources, born out of the urgency of the present situation. Nature, in the form of landscape painting, is firmly embedded in art history. In works from earlier centuries we generally encounter it as idyllic scenery, but since the 1970s it has been depicted with ever greater clarity as an entity threatened by human intervention and at the same time deserving of protection.
Curated by Sandra Gianfreda and Cathérine Hug, with some 120 works by Lothar Baumgarten, Vaughn Bell, Bernd & Hilla Becher, Joseph Beuys, Ursula Biemann, Nomin Bold, Laurence Bonvin, Herbert Brandl, Julian Charrière, Edward Theodore Compton, Gustave Courbet, Tony Cragg, Buby Durini, Thomas Fearnley, Peter Fischli & David Weiss, Francesca Gabbiani, Ludwig Hess, Cornelia Hesse-Honegger, Ferdinand Hodler, Anna Jermolaewa, Ruth Kaaserer, Mikhail Karikis & Uriel Orlow, Armin Linke & Giulia Bruno & Giuseppe Ielasi, Richard Long, Marcus Maeder, Maurice Maggi, Ana Mendieta, Conrad Meyer, Johann Heinrich Meyer, Otto Morach, Harald Naegeli, Walter Niedermayr, Katie Paterson, Albert Renger-Patzsch, Oliver Ressler, Germaine Richier, Ed Ruscha, David Shrigley, Jules Spinatsch, Johann Gottfried Steffan, Annelies Štrba, Thomas Struth, Vivian Suter, Félix Vallotton, Auguste Veillon, Hans Beat Wieland, Caspar Wolf, Robert Zünd.


text:
import os
import Tkinter

def _load_tkdnd(master):
    tkdndlib = os.environ.get('TKDND_LIBRARY')
    if tkdndlib:
        master.tk.eval('global auto_path; lappend auto_path {%s}' % tkdndlib)
    master.tk.eval('package require tkdnd')
    master._tkdnd_loaded = True

class TkDND(object):
    def __init__(self, master):
        if not getattr(master, '_tkdnd_loaded', False):
            _load_tkdnd(master)
        self.master = master
        self.tk = master.tk

    # Available pre-defined values for the 'dndtype' parameter:
    #   text/plain
    #   text/plain;charset=UTF-8
    #   text/uri-list

    def bindtarget(self, window, callback, dndtype, event='<Drop>', priority=50):
        cmd = self._prepare_tkdnd_func(callback)
        return self.tk.call('dnd', 'bindtarget', window, dndtype, event,
                cmd, priority)

    def bindtarget_query(self, window, dndtype=None, event='<Drop>'):
        return self.tk.call('dnd', 'bindtarget', window, dndtype, event)

    def cleartarget(self, window):
        self.tk.call('dnd', 'cleartarget', window)

    def bindsource(self, window, callback, dndtype, priority=50):
        cmd = self._prepare_tkdnd_func(callback)
        self.tk.call('dnd', 'bindsource', window, dndtype, cmd, priority)

    def bindsource_query(self, window, dndtype=None):
        return self.tk.call('dnd', 'bindsource', window, dndtype)

    def clearsource(self, window):
        self.tk.call('dnd', 'clearsource', window)

    def drag(self, window, actions=None, descriptions=None,
            cursorwin=None, callback=None):
        cmd = None
        if cursorwin is not None:
            if callback is not None:
                cmd = self._prepare_tkdnd_func(callback)
        self.tk.call('dnd', 'drag', window, actions, descriptions,
                cursorwin, cmd)

    _subst_format = ('%A', '%a', '%b', '%D', '%d', '%m', '%T',
            '%W', '%X', '%Y', '%x', '%y')
    _subst_format_str = " ".join(_subst_format)

    def _prepare_tkdnd_func(self, callback):
        funcid = self.master.register(callback, self._dndsubstitute)
        cmd = ('%s %s' % (funcid, self._subst_format_str))
        return cmd

    def _dndsubstitute(self, *args):
        if len(args) != len(self._subst_format):
            return args

        def try_int(x):
            x = str(x)
            try:
                return int(x)
            except ValueError:
                return x

        A, a, b, D, d, m, T, W, X, Y, x, y = args

        event = Tkinter.Event()
        event.action = A       # Current action of the drag and drop operation.
        event.action_list = a  # Action list supported by the drag source.
        event.mouse_button = b # Mouse button pressed during the drag and drop.
        event.data = D         # The data that has been dropped.
        event.descr = d        # The list of descriptions.
        event.modifier = m     # The list of modifier keyboard keys pressed.
        event.dndtype = T
        event.widget = self.master.nametowidget(W)
        event.x_root = X       # Mouse pointer x coord, relative to the root win.
        event.y_root = Y
        event.x = x            # Mouse pointer x coord, relative to the widget.
        event.y = y

        event.action_list = str(event.action_list).split()
        for name in ('mouse_button', 'x', 'y', 'x_root', 'y_root'):
            setattr(event, name, try_int(getattr(event, name)))

        return (event, )

##  the second  tkdnd implement .
class DnD:
    def __init__(self, tkroot):
        self._tkroot = tkroot
        tkroot.tk.eval('package require tkdnd')
        # make self an attribute of the parent window for easy access in child classes
        tkroot.dnd = self

    def bindsource(self, widget, type=None, command=None, arguments=None, priority=None):
        '''Register widget as drag source; for details on type, command and arguments, see bindtarget().
        priority can be a value between 1 and 100, where 100 is the highest available priority (default: 50).
        If command is omitted, return the current binding for type; if both type and command are omitted,
        return a list of registered types for widget.'''
        command = self._generate_callback(command, arguments)
        tkcmd = self._generate_tkcommand('bindsource', widget, type, command, priority)
        res = self._tkroot.tk.eval(tkcmd)
        if type == None:
            res = res.split()
        return res

    def bindtarget(self, widget, type=None, sequence=None, command=None, arguments=None, priority=None):
        '''Register widget as drop target; type may be one of text/plain, text/uri-list, text/plain;charset=UTF-8
        (see the man page tkDND for details on other (platform specific) types);
        sequence may be one of '<Drag>', '<DragEnter>', '<DragLeave>', '<Drop>' or '<Ask>' ;
        command is the callback associated with the specified event, argument is an optional tuple of arguments
        that will be passed to the callback; possible arguments include: %A %a %b %C %c %D %d %L %m %T %t %W %X %x %Y %y
        (see the tkDND man page for details); priority may be a value in the range 1 to 100 ; if there are
        bindings for different types, the one with the priority value will be proceeded first (default: 50).
        If command is omitted, return the current binding for type, where sequence defaults to '<Drop>'.
        If both type and command are omitted, return a list of registered types for widget.'''
        command = self._generate_callback(command, arguments)
        tkcmd = self._generate_tkcommand('bindtarget', widget, type, sequence, command, priority)
        res = self._tkroot.tk.eval(tkcmd)
        if type == None:
            res = res.split()
        return res

    def clearsource(self, widget):
        '''Unregister widget as drag source.'''
        self._tkroot.tk.call('dnd', 'clearsource', widget)

    def cleartarget(self, widget):
        '''Unregister widget as drop target.'''
        self._tkroot.tk.call('dnd', 'cleartarget', widget)

    def drag(self, widget, actions=None, descriptions=None, cursorwindow=None, command=None, arguments=None):
        '''Initiate a drag operation with source widget.'''
        command = self._generate_callback(command, arguments)
        if actions:
            if actions[1:]:
                actions = '-actions {%s}' % ' '.join(actions)
            else:
                actions = '-actions %s' % actions[0]
        if descriptions:
            descriptions = ['{%s}'%i for i in descriptions]
            descriptions = '{%s}' % ' '.join(descriptions)
        if cursorwindow:
            cursorwindow = '-cursorwindow %s' % cursorwindow
        tkcmd = self._generate_tkcommand('drag', widget, actions, descriptions, cursorwindow, command)
        self._tkroot.tk.eval(tkcmd)

    def _generate_callback(self, command, arguments):
        '''Register command as tk callback with an optional list of arguments.'''
        cmd = None
        if command:
            cmd = self._tkroot._register(command)
            if arguments:
                cmd = '{%s %s}' % (cmd, ' '.join(arguments))
        return cmd

    def _generate_tkcommand(self, base, widget, *opts):
        '''Create the command string that will be passed to tk.'''
        tkcmd = 'dnd %s %s' % (base, widget)
        for i in opts:
            if i is not None:
                tkcmd += ' %s' % i
        return tkcmd

redpajama_set_name: RedPajamaGithub


text:
Red Raider girls win thriller
By Nick Celario | Thursday, September 17, 2015, 1 a.m.
LIHUE — The Red Raider wahine held on to win a stirring five-set match at home.
Kauai High School's varsity girls volleyball team defeated Waimea, 3-2, Tuesday evening.
"I felt that this was an awesome game. The girls had been playing well together the last two games," said Kauai head coach Dorene Matias. "They made some mistakes. That's normal. Nobody can play a perfect game. But I think they did good."
Kauai (2-3 KIF) won the first two sets, 25-22 and 25-19, and were poised to win in straight sets. Waimea, however, rallied and won the following two sets to force a fifth.
With the score tied at 12, senior outside hitter Adrienne Graycochea scored Kauai's next three points, the last being a block, to seal the final frame for the Red Raiders, 15-12.
"That was amazing. That was like the best feeling ever," Graycochea said about the game-winning block. "I'll always remember it."
Though the Red Raiders are out of contention for the season's first round, Matias hopes the win will serve as a launching point.
"I hope that they remember how it feels and that they remember how to finish, because they've done it already. Let's see," she said.
Waimea (4-1 KIF) won the third and fourth sets, 25-23 and 25-20. In the fourth, senior outside hitter Ariell Aquino-Lazaro scored seven consecutive points for Waimea.
"We worked. Being down 2-0 and on the road, they showed a lot of character tonight," said Waimea head coach Chad Delanoza about his players. "They showed a lot of sticking together, like we've been talking about. Working through a lot of things. In the end, I'm proud of them."
Delanoza added though the comeback fell short, he hopes the loss will serve as a learning experience.
"You have to be tested to see how all these pieces are going to turn out," he said. "In the end, they fought and they fought hard. You cannot take nothing away from our kids tonight. Maybe not in the win column tonight, but I think in the end, I think it's going to help us in the long run."
Graycochea was Kauai High's leading scorer with 19 kills, three blocks and an ace. Junior middle Taegan Keep had four blocks, three kills and an assist, and senior setter Leisa Eto recorded 17 assists, five kills, two blocks and two aces.
Aquino-Lazaro had 27 kills and two aces for the Menehune. Senior setter Alyssa Pigao recorded 52 assists. Senior middle blocker Brandee Burton had 11 kills, a block and an ace.
Kauai also won the junior varsity match against Waimea, 2-1. The JV Red Raiders won the first two sets, 25-16 and 25-20, and the Menehune won the last, 25-18.
In the night's other Kauai Interscholastic Federation match, Kapaa (4-1 KIF) topped Island School in straight sets, 25-13, 25-13 and 25-15. The Warriors also won the JV match, 2-1, winning the first and third sets, 25-20 and 25-17. The JV Voyagers won the second set, 25-17.
Waimea will host Kapaa and Kauai will play at home against Island School (0-5 KIF) on Friday. The JV games will begin at 5 p.m. and the varsity will follow.
Whoever wins the contest between the Menehune and the Warriors will claim the KIF season's first round.
"The first thing we'll do is get back to practice tomorrow, and then we'll sort out what we got to sort out to make things right," Delanoza said. "Friday is Friday. We don't want to get too far ahead. We still want to know why everything turned out like it did tonight. Hopefully, it will kind of work its way through."
Charity golf tourney raises $50K
Trestles, touchdowns headline another busy weekend


text:
package voldemort.store.routed;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang.mutable.MutableInt;

import voldemort.VoldemortApplicationException;
import voldemort.VoldemortException;
import voldemort.client.TimeoutConfig;
import voldemort.cluster.Cluster;
import voldemort.cluster.Node;
import voldemort.cluster.failuredetector.FailureDetector;
import voldemort.common.VoldemortOpCode;
import voldemort.store.InsufficientOperationalNodesException;
import voldemort.store.Store;
import voldemort.store.StoreDefinition;
import voldemort.store.StoreUtils;
import voldemort.store.UnreachableStoreException;
import voldemort.utils.ByteArray;
import voldemort.utils.ByteUtils;
import voldemort.utils.SystemTime;
import voldemort.utils.Time;
import voldemort.versioning.ObsoleteVersionException;
import voldemort.versioning.VectorClock;
import voldemort.versioning.Version;
import voldemort.versioning.Versioned;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

/**
 * A Store which multiplexes requests to different internal Stores
 *
 *
 */
@Deprecated
public class ThreadPoolRoutedStore extends RoutedStore {

    private final static StoreOp<Versioned<byte[]>> VERSIONED_OP = new StoreOp<Versioned<byte[]>>() {

        @Override
        public List<Versioned<byte[]>> execute(Store<ByteArray, byte[], byte[]> store,
                                               ByteArray key,
                                               byte[] transforms) {
            return store.get(key, transforms);
        }
    };

    private final static StoreOp<Version> VERSION_OP = new StoreOp<Version>() {

        @Override
        public List<Version> execute(Store<ByteArray, byte[], byte[]> store,
                                     ByteArray key,
                                     byte[] transforms) {
            return store.getVersions(key);
        }
    };

    private final ExecutorService executor;

    /**
     * Create a RoutedStoreClient
     *
     * @param name The name of the store
     * @param innerStores The mapping of node to client
     * @param cluster The cluster metadata
     * @param storeDef The store definition
     * @param numberOfThreads The number of threads in the threadpool
     * @param repairReads Do we want to do read repairs?
     * @param timeoutConfig The timeout configuration
     * @param failureDetector The failure detector implementation
     */
    public ThreadPoolRoutedStore(String name,
                                 Map<Integer, Store<ByteArray, byte[], byte[]>> innerStores,
                                 Cluster cluster,
                                 StoreDefinition storeDef,
                                 int numberOfThreads,
                                 boolean repairReads,
                                 TimeoutConfig timeoutConfig,
                                 FailureDetector failureDetector) {
        this(name,
             innerStores,
             cluster,
             storeDef,
             repairReads,
             Executors.newFixedThreadPool(numberOfThreads),
             timeoutConfig,
             failureDetector,
             SystemTime.INSTANCE);
    }

    /**
     * Create a RoutedStoreClient
     *
     * @param name The name of the store
     * @param innerStores The mapping of node to client
     * @param cluster The cluster metadata
     * @param storeDef The store definition
     * @param repairReads Do we want to do read repairs?
     * @param threadPool The threadpool to use
     * @param timeoutConfig The timeout configuration
     * @param failureDetector The failure detector implementation
     * @param time Time instance
     */
    public ThreadPoolRoutedStore(String name,
                                 Map<Integer, Store<ByteArray, byte[], byte[]>> innerStores,
                                 Cluster cluster,
                                 StoreDefinition storeDef,
                                 boolean repairReads,
                                 ExecutorService threadPool,
                                 TimeoutConfig timeoutConfig,
                                 FailureDetector failureDetector,
                                 Time time) {
        super(name,
              innerStores,
              cluster,
              storeDef,
              repairReads,
              timeoutConfig,
              failureDetector,
              time);
        this.executor = threadPool;
    }

    @Override
    public boolean delete(final ByteArray key, final Version version) throws VoldemortException {
        StoreUtils.assertValidKey(key);
        final List<Node> nodes = availableNodes(routingStrategy.routeRequest(key.get()));

        // quickly fail if there aren't enough live nodes to meet the
        // requirements
        final int numNodes = nodes.size();
        if(numNodes < this.storeDef.getRequiredWrites())
            throw new InsufficientOperationalNodesException("Only " + numNodes
                                                            + " nodes in preference list, but "
                                                            + this.storeDef.getRequiredWrites()
                                                            + " writes required.");

        // A count of the number of successful operations
        final AtomicInteger successes = new AtomicInteger(0);
        final AtomicBoolean deletedSomething = new AtomicBoolean(false);
        // A list of thrown exceptions, indicating the number of failures
        final List<Exception> failures = new CopyOnWriteArrayList<Exception>();

        // A semaphore indicating the number of completed operations
        // Once inititialized all permits are acquired, after that
        // permits are released when an operation is completed.
        // semaphore.acquire(n) waits for n operations to complete
        final Semaphore semaphore = new Semaphore(0, false);
        // Add the operations to the pool
        for(final Node node: nodes) {
            this.executor.execute(new Runnable() {

                @Override
                public void run() {
                    long startNs = System.nanoTime();
                    try {
                        boolean deleted = innerStores.get(node.getId()).delete(key, version);
                        successes.incrementAndGet();
                        deletedSomething.compareAndSet(false, deleted);
                        recordSuccess(node, startNs);
                    } catch(UnreachableStoreException e) {
                        failures.add(e);
                        recordException(node, startNs, e);
                    } catch(VoldemortApplicationException e) {
                        throw e;
                    } catch(Exception e) {
                        failures.add(e);
                        logger.warn("Error in DELETE on node " + node.getId() + "("
                                            + node.getHost() + ")",
                                    e);
                    } finally {
                        // signal that the operation is complete
                        semaphore.release();
                    }
                }
            });
        }

        int attempts = Math.min(storeDef.getPreferredWrites(), numNodes);
        if(this.storeDef.getPreferredWrites() <= 0) {
            return true;
        } else {
            for(int i = 0; i < numNodes; i++) {
                try {
                    long timeoutMs = timeoutConfig.getOperationTimeout(VoldemortOpCode.DELETE_OP_CODE);
                    boolean acquired = semaphore.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS);
                    if(!acquired)
                        logger.warn("Delete operation timed out waiting for operation " + i
                                    + " to complete after waiting " + timeoutMs + " ms.");
                    // okay, at least the required number of operations have
                    // completed, were they successful?
                    if(successes.get() >= attempts)
                        return deletedSomething.get();
                } catch(InterruptedException e) {
                    throw new InsufficientOperationalNodesException("Delete operation interrupted!",
                                                                    e);
                }
            }
        }

        // If we get to here, that means we couldn't hit the preferred number
        // of writes, throw an exception if you can't even hit the required
        // number
        if(successes.get() < storeDef.getRequiredWrites())
            throw new InsufficientOperationalNodesException(this.storeDef.getRequiredWrites()
                                                                    + " deletes required, but "
                                                                    + successes.get()
                                                                    + " succeeded.",
                                                            failures);
        else
            return deletedSomething.get();
    }

    @Override
    public Map<ByteArray, List<Versioned<byte[]>>> getAll(Iterable<ByteArray> keys,
                                                          Map<ByteArray, byte[]> transforms)
            throws VoldemortException {
        StoreUtils.assertValidKeys(keys);

        Map<ByteArray, List<Versioned<byte[]>>> result = StoreUtils.newEmptyHashMap(keys);

        // Keys for each node needed to satisfy storeDef.getPreferredReads() if
        // no failures.
        Map<Node, List<ByteArray>> nodeToKeysMap = Maps.newHashMap();

        // Keep track of nodes per key that might be needed if there are
        // failures during getAll
        Map<ByteArray, List<Node>> keyToExtraNodesMap = Maps.newHashMap();

        for(ByteArray key: keys) {
            List<Node> availableNodes = availableNodes(routingStrategy.routeRequest(key.get()));

            // quickly fail if there aren't enough nodes to meet the requirement
            checkRequiredReads(availableNodes);
            int preferredReads = storeDef.getPreferredReads();
            List<Node> preferredNodes = Lists.newArrayListWithCapacity(preferredReads);
            List<Node> extraNodes = Lists.newArrayListWithCapacity(3);

            for(Node node: availableNodes) {
                if(preferredNodes.size() < preferredReads)
                    preferredNodes.add(node);
                else
                    extraNodes.add(node);
            }

            for(Node node: preferredNodes) {
                List<ByteArray> nodeKeys = nodeToKeysMap.get(node);
                if(nodeKeys == null) {
                    nodeKeys = Lists.newArrayList();
                    nodeToKeysMap.put(node, nodeKeys);
                }
                nodeKeys.add(key);
            }
            if(!extraNodes.isEmpty()) {
                List<Node> nodes = keyToExtraNodesMap.get(key);
                if(nodes == null)
                    keyToExtraNodesMap.put(key, extraNodes);
                else
                    nodes.addAll(extraNodes);
            }
        }

        List<Callable<GetAllResult>> callables = Lists.newArrayList();
        for(Map.Entry<Node, List<ByteArray>> entry: nodeToKeysMap.entrySet()) {
            final Node node = entry.getKey();
            final Collection<ByteArray> nodeKeys = entry.getValue();
            if(failureDetector.isAvailable(node))
                callables.add(new GetAllCallable(node, nodeKeys, transforms));
        }

        // A list of thrown exceptions, indicating the number of failures
        List<Throwable> failures = new CopyOnWriteArrayList<Throwable>();
        List<NodeValue<ByteArray, byte[]>> nodeValues = Lists.newArrayList();

        Map<ByteArray, MutableInt> keyToSuccessCount = Maps.newHashMap();
        for(ByteArray key: keys)
            keyToSuccessCount.put(key, new MutableInt(0));

        List<Future<GetAllResult>> futures;
        long timeoutMs = timeoutConfig.getOperationTimeout(VoldemortOpCode.GET_ALL_OP_CODE);
        try {
            // TODO What to do about timeouts? They should be longer as getAll
            // is likely to
            // take longer. At the moment, it's just timeoutMs * 3, but should
            // this be based on the number of the keys?
            futures = executor.invokeAll(callables, timeoutMs * 3, TimeUnit.MILLISECONDS);
        } catch(InterruptedException e) {
            throw new InsufficientOperationalNodesException("getAll operation interrupted.", e);
        }
        for(Future<GetAllResult> f: futures) {
            if(f.isCancelled()) {
                logger.warn("Get operation timed out after " + timeoutMs + " ms.");
                continue;
            }
            try {
                GetAllResult getResult = f.get();
                if(getResult.exception != null) {
                    if(getResult.exception instanceof VoldemortApplicationException) {
                        throw (VoldemortException) getResult.exception;
                    }
                    failures.add(getResult.exception);
                    continue;
                }
                for(ByteArray key: getResult.callable.nodeKeys) {
                    List<Versioned<byte[]>> retrieved = getResult.retrieved.get(key);
                    MutableInt successCount = keyToSuccessCount.get(key);
                    successCount.increment();

                    /*
                     * retrieved can be null if there are no values for the key
                     * provided
                     */
                    if(retrieved != null) {
                        List<Versioned<byte[]>> existing = result.get(key);
                        if(existing == null)
                            result.put(key, Lists.newArrayList(retrieved));
                        else
                            existing.addAll(retrieved);
                    }
                }
                nodeValues.addAll(getResult.nodeValues);

            } catch(InterruptedException e) {
                throw new InsufficientOperationalNodesException("getAll operation interrupted.", e);
            } catch(ExecutionException e) {
                // We catch all Throwables apart from Error in the callable, so
                // the else part
                // should never happen
                if(e.getCause() instanceof Error)
                    throw (Error) e.getCause();
                else
                    logger.error(e.getMessage(), e);
            }
        }

        for(ByteArray key: keys) {
            MutableInt successCountWrapper = keyToSuccessCount.get(key);
            int successCount = successCountWrapper.intValue();
            if(successCount < storeDef.getPreferredReads()) {
                List<Node> extraNodes = keyToExtraNodesMap.get(key);
                if(extraNodes != null) {
                    for(Node node: extraNodes) {
                        long startNs = System.nanoTime();
                        try {
                            List<Versioned<byte[]>> values = innerStores.get(node.getId())
                                                                        .get(key,
                                                                             transforms == null ? null
                                                                                : transforms.get(key));
                            fillRepairReadsValues(nodeValues, key, node, values);
                            List<Versioned<byte[]>> versioneds = result.get(key);
                            if(versioneds == null)
                                result.put(key, Lists.newArrayList(values));
                            else
                                versioneds.addAll(values);
                            recordSuccess(node, startNs);
                            if(++successCount >= storeDef.getPreferredReads())
                                break;

                        } catch(UnreachableStoreException e) {
                            failures.add(e);
                            recordException(node, startNs, e);
                        } catch(VoldemortApplicationException e) {
                            throw e;
                        } catch(Exception e) {
                            logger.warn("Error in GET_ALL on node " + node.getId() + "("
                                                + node.getHost() + ")",
                                        e);
                            failures.add(e);
                        }
                    }
                }
            }
            successCountWrapper.setValue(successCount);
        }

        repairReads(nodeValues, repairReads && (transforms == null || transforms.size() == 0));

        for(Map.Entry<ByteArray, MutableInt> mapEntry: keyToSuccessCount.entrySet()) {
            int successCount = mapEntry.getValue().intValue();
            if(successCount < storeDef.getRequiredReads())
                throw new InsufficientOperationalNodesException(this.storeDef.getRequiredReads()
                                                                        + " reads required, but "
                                                                        + successCount
                                                                        + " succeeded.",
                                                                failures);
        }

        return result;
    }

    @Override
    public List<Versioned<byte[]>> get(ByteArray key, final byte[] transforms) {
        Function<List<GetResult<Versioned<byte[]>>>, Void> readRepairFunction = new Function<List<GetResult<Versioned<byte[]>>>, Void>() {

            @Override
            public Void apply(List<GetResult<Versioned<byte[]>>> nodeResults) {
                List<NodeValue<ByteArray, byte[]>> nodeValues = Lists.newArrayListWithExpectedSize(nodeResults.size());
                for(GetResult<Versioned<byte[]>> getResult: nodeResults)
                    fillRepairReadsValues(nodeValues,
                                          getResult.key,
                                          getResult.node,
                                          getResult.retrieved);
                repairReads(nodeValues, repairReads && transforms == null);
                return null;
            }
        };
        return get(key, transforms, VERSIONED_OP, readRepairFunction);
    }

    /*
     * 1. Attempt preferredReads, and then wait for these to complete 2. If we
     * got all the reads we wanted, then we are done. 3. If not then continue
     * serially attempting to read from each node until we get preferredReads or
     * run out of nodes. 4. If we have multiple results do a read repair 5. If
     * we have at least requiredReads return. Otherwise throw an exception.
     */
    private <R> List<R> get(final ByteArray key,
                            final byte[] transforms,
                            StoreOp<R> fetcher,
                            Function<List<GetResult<R>>, Void> preReturnProcedure)
            throws VoldemortException {
        StoreUtils.assertValidKey(key);
        final List<Node> nodes = availableNodes(routingStrategy.routeRequest(key.get()));

        // quickly fail if there aren't enough nodes to meet the requirement
        checkRequiredReads(nodes);

        final List<GetResult<R>> retrieved = Lists.newArrayList();

        // A count of the number of successful operations
        int successes = 0;
        // A list of thrown exceptions, indicating the number of failures
        final List<Throwable> failures = new CopyOnWriteArrayList<Throwable>();

        // Do the preferred number of reads in parallel
        int attempts = Math.min(this.storeDef.getPreferredReads(), nodes.size());
        int nodeIndex = 0;
        List<Callable<GetResult<R>>> callables = Lists.newArrayListWithCapacity(attempts);
        for(; nodeIndex < attempts; nodeIndex++) {
            final Node node = nodes.get(nodeIndex);
            callables.add(new GetCallable<R>(node, key, transforms, fetcher));
        }

        List<Future<GetResult<R>>> futures;
        long timeoutMs = (fetcher == VERSION_OP) ? timeoutConfig.getOperationTimeout(VoldemortOpCode.GET_VERSION_OP_CODE)
                                                : timeoutConfig.getOperationTimeout(VoldemortOpCode.GET_OP_CODE);
        try {
            futures = executor.invokeAll(callables, timeoutMs, TimeUnit.MILLISECONDS);
        } catch(InterruptedException e) {
            throw new InsufficientOperationalNodesException("Get operation interrupted!", e);
        }

        for(Future<GetResult<R>> f: futures) {
            if(f.isCancelled()) {
                logger.warn("Get operation timed out after " + timeoutMs + " ms.");
                continue;
            }
            try {
                GetResult<R> getResult = f.get();
                if(getResult.exception != null) {
                    if(getResult.exception instanceof VoldemortApplicationException) {
                        throw (VoldemortException) getResult.exception;
                    }
                    failures.add(getResult.exception);
                    continue;
                }
                ++successes;
                retrieved.add(getResult);
            } catch(InterruptedException e) {
                throw new InsufficientOperationalNodesException("Get operation interrupted!", e);
            } catch(ExecutionException e) {
                // We catch all Throwable subclasses apart from Error in the
                // callable, so the else
                // part should never happen.
                if(e.getCause() instanceof Error)
                    throw (Error) e.getCause();
                else
                    logger.error(e.getMessage(), e);
            }
        }

        // Now if we had any failures we will be short a few reads. Do serial
        // reads to make up for these.
        while(successes < this.storeDef.getPreferredReads() && nodeIndex < nodes.size()) {
            Node node = nodes.get(nodeIndex);
            long startNs = System.nanoTime();
            try {
                retrieved.add(new GetResult<R>(node,
                                               key,
                                               fetcher.execute(innerStores.get(node.getId()),
                                                               key,
                                                               transforms), null));
                ++successes;
                recordSuccess(node, startNs);
            } catch(UnreachableStoreException e) {
                failures.add(e);
                recordException(node, startNs, e);
            } catch(VoldemortApplicationException e) {
                throw e;
            } catch(Exception e) {
                logger.warn("Error in GET on node " + node.getId() + "(" + node.getHost() + ")", e);
                failures.add(e);
            }
            nodeIndex++;
        }

        if(logger.isTraceEnabled())
            logger.trace("GET retrieved the following node values: " + formatNodeValues(retrieved));

        if(preReturnProcedure != null)
            preReturnProcedure.apply(retrieved);

        if(successes >= this.storeDef.getRequiredReads()) {
            List<R> result = Lists.newArrayListWithExpectedSize(retrieved.size());
            for(GetResult<R> getResult: retrieved)
                result.addAll(getResult.retrieved);
            return result;
        } else
            throw new InsufficientOperationalNodesException(this.storeDef.getRequiredReads()
                                                            + " reads required, but " + successes
                                                            + " succeeded.", failures);
    }

    private void fillRepairReadsValues(final List<NodeValue<ByteArray, byte[]>> nodeValues,
                                       final ByteArray key,
                                       Node node,
                                       List<Versioned<byte[]>> fetched) {
        if(repairReads) {
            if(fetched.size() == 0)
                nodeValues.add(nullValue(node, key));
            else {
                for(Versioned<byte[]> f: fetched)
                    nodeValues.add(new NodeValue<ByteArray, byte[]>(node.getId(), key, f));
            }
        }
    }

    private NodeValue<ByteArray, byte[]> nullValue(Node node, ByteArray key) {
        return new NodeValue<ByteArray, byte[]>(node.getId(), key, new Versioned<byte[]>(null));
    }

    private void repairReads(List<NodeValue<ByteArray, byte[]>> nodeValues, boolean allowReadRepair) {
        if(!allowReadRepair || nodeValues.size() <= 1 || storeDef.getPreferredReads() <= 1)
            return;

        final List<NodeValue<ByteArray, byte[]>> toReadRepair = Lists.newArrayList();
        /*
         * We clone after computing read repairs in the assumption that the
         * output will be smaller than the input. Note that we clone the
         * version, but not the key or value as the latter two are not mutated.
         */
        for(NodeValue<ByteArray, byte[]> v: readRepairer.getRepairs(nodeValues)) {
            Versioned<byte[]> versioned = Versioned.value(v.getVersioned().getValue(),
                                                          ((VectorClock) v.getVersion()).clone());
            toReadRepair.add(new NodeValue<ByteArray, byte[]>(v.getNodeId(), v.getKey(), versioned));
        }

        this.executor.execute(new Runnable() {

            @Override
            public void run() {
                for(NodeValue<ByteArray, byte[]> v: toReadRepair) {
                    try {
                        if(logger.isDebugEnabled())
                            logger.debug("Doing read repair on node " + v.getNodeId()
                                         + " for key '" + v.getKey() + "' with version "
                                         + v.getVersion() + ".");
                        // no transforms since this is read repair
                        innerStores.get(v.getNodeId()).put(v.getKey(), v.getVersioned(), null);
                    } catch(VoldemortApplicationException e) {
                        if(logger.isDebugEnabled())
                            logger.debug("Read repair cancelled due to application level exception on node "
                                         + v.getNodeId()
                                         + " for key '"
                                         + v.getKey()
                                         + "' with version "
                                         + v.getVersion()
                                         + ": "
                                         + e.getMessage());
                    } catch(Exception e) {
                        logger.debug("Read repair failed: ", e);
                    }
                }
            }
        });
    }

    private void checkRequiredReads(final List<Node> nodes)
            throws InsufficientOperationalNodesException {
        if(nodes.size() < this.storeDef.getRequiredReads())
            throw new InsufficientOperationalNodesException("Only " + nodes.size()
                                                            + " nodes in preference list, but "
                                                            + this.storeDef.getRequiredReads()
                                                            + " reads required.");
    }

    private <R> String formatNodeValues(List<GetResult<R>> results) {
        // log all retrieved values
        StringBuilder builder = new StringBuilder();
        builder.append("{");
        for(GetResult<?> r: results) {
            builder.append("GetResult(nodeId=" + r.node.getId() + ", key=" + r.key
                           + ", retrieved= " + r.retrieved + ")");
            builder.append(", ");
        }
        builder.append("}");

        return builder.toString();
    }

    @Override
    public void put(final ByteArray key, final Versioned<byte[]> versioned, final byte[] transforms)
            throws VoldemortException {
        long startNs = System.nanoTime();
        StoreUtils.assertValidKey(key);
        final List<Node> nodes = availableNodes(routingStrategy.routeRequest(key.get()));

        // quickly fail if there aren't enough nodes to meet the requirement
        final int numNodes = nodes.size();
        if(numNodes < this.storeDef.getRequiredWrites())
            throw new InsufficientOperationalNodesException("Only " + numNodes
                                                            + " nodes in preference list, but "
                                                            + this.storeDef.getRequiredWrites()
                                                            + " writes required.");

        // A count of the number of successful operations
        final AtomicInteger successes = new AtomicInteger(0);

        // A list of thrown exceptions, indicating the number of failures
        final List<Exception> failures = new CopyOnWriteArrayList<Exception>();

        // If requiredWrites > 0 then do a single blocking write to the first
        // live node in the preference list if this node throws an
        // ObsoleteVersionException allow it to propagate
        Node master = null;
        int currentNode = 0;
        Versioned<byte[]> versionedCopy = null;
        for(; currentNode < numNodes; currentNode++) {
            Node current = nodes.get(currentNode);
            long startNsLocal = System.nanoTime();
            try {
                versionedCopy = incremented(versioned, current.getId());
                innerStores.get(current.getId()).put(key, versionedCopy, transforms);
                successes.getAndIncrement();
                recordSuccess(current, startNsLocal);
                master = current;
                break;
            } catch(UnreachableStoreException e) {
                recordException(current, startNsLocal, e);
                failures.add(e);
            } catch(VoldemortApplicationException e) {
                throw e;
            } catch(Exception e) {
                failures.add(e);
            }
        }

        if(successes.get() < 1)
            throw new InsufficientOperationalNodesException("No master node succeeded!", failures);
        else
            currentNode++;

        // A semaphore indicating the number of completed operations
        // Once inititialized all permits are acquired, after that
        // permits are released when an operation is completed.
        // semaphore.acquire(n) waits for n operations to complete
        final Versioned<byte[]> finalVersionedCopy = versionedCopy;
        final Semaphore semaphore = new Semaphore(0, false);
        // Add the operations to the pool
        int attempts = 0;
        for(; currentNode < numNodes; currentNode++) {
            attempts++;
            final Node node = nodes.get(currentNode);
            this.executor.execute(new Runnable() {

                @Override
                public void run() {
                    long startNsLocal = System.nanoTime();
                    try {
                        innerStores.get(node.getId()).put(key, finalVersionedCopy, transforms);
                        successes.incrementAndGet();
                        recordSuccess(node, startNsLocal);
                    } catch(UnreachableStoreException e) {
                        recordException(node, startNsLocal, e);
                        failures.add(e);
                    } catch(ObsoleteVersionException e) {
                        // ignore this completely here
                        // this means that a higher version was able
                        // to write on this node and should be termed as clean
                        // success.
                    } catch(VoldemortApplicationException e) {
                        throw e;
                    } catch(Exception e) {
                        logger.warn("Error in PUT on node " + node.getId() + "(" + node.getHost()
                                    + ")", e);
                        failures.add(e);
                    } finally {
                        // signal that the operation is complete
                        semaphore.release();
                    }
                }
            });
        }

        // Block until we get enough completions
        int blockCount = Math.min(storeDef.getPreferredWrites() - 1, attempts);
        boolean noTimeout = blockOnPut(startNs,
                                       semaphore,
                                       0,
                                       blockCount,
                                       successes,
                                       storeDef.getPreferredWrites());

        if(successes.get() < storeDef.getRequiredWrites()) {
            /*
             * We don't have enough required writes, but we haven't timed out
             * yet, so block a little more if there are healthy nodes that can
             * help us achieve our target.
             */
            if(noTimeout) {
                int startingIndex = blockCount - 1;
                blockCount = Math.max(storeDef.getPreferredWrites() - 1, attempts);
                blockOnPut(startNs,
                           semaphore,
                           startingIndex,
                           blockCount,
                           successes,
                           storeDef.getRequiredWrites());
            }
            if(successes.get() < storeDef.getRequiredWrites())
                throw new InsufficientOperationalNodesException(successes.get()
                                                                + " writes succeeded, but "
                                                                + this.storeDef.getRequiredWrites()
                                                                + " are required.", failures);
        }

        // Okay looks like it worked, increment the version for the caller
        VectorClock versionedClock = (VectorClock) versioned.getVersion();
        versionedClock.incrementVersion(master.getId(), time.getMilliseconds());
    }

    /**
     * @return false if the operation timed out, true otherwise.
     */
    private boolean blockOnPut(long startNs,
                               Semaphore semaphore,
                               int startingIndex,
                               int blockCount,
                               AtomicInteger successes,
                               int successesRequired) {
        for(int i = startingIndex; i < blockCount; i++) {
            try {
                long ellapsedNs = System.nanoTime() - startNs;
                long remainingNs = (timeoutConfig.getOperationTimeout(VoldemortOpCode.PUT_OP_CODE) * Time.NS_PER_MS)
                                   - ellapsedNs;
                boolean acquiredPermit = semaphore.tryAcquire(Math.max(remainingNs, 0),
                                                              TimeUnit.NANOSECONDS);
                if(!acquiredPermit) {
                    logger.warn("Timed out waiting for put # " + (i + 1) + " of " + blockCount
                                + " to succeed.");
                    return false;
                }
                if(successes.get() >= successesRequired)
                    break;
            } catch(InterruptedException e) {
                throw new InsufficientOperationalNodesException("Put operation interrupted", e);
            }
        }
        return true;
    }

    private Versioned<byte[]> incremented(Versioned<byte[]> versioned, int nodeId) {
        return new Versioned<byte[]>(versioned.getValue(),
                                     ((VectorClock) versioned.getVersion()).incremented(nodeId,
                                                                                time.getMilliseconds()));
    }

    private List<Node> availableNodes(List<Node> list) {
        List<Node> available = new ArrayList<Node>(list.size());
        for(Node node: list)
            if(failureDetector.isAvailable(node))
                available.add(node);
        return available;
    }

    @Override
    public List<Version> getVersions(ByteArray key) {
        return get(key, null, VERSION_OP, null);
    }

    private void recordException(Node node, long startNs, UnreachableStoreException e) {
        failureDetector.recordException(node, (System.nanoTime() - startNs) / Time.NS_PER_MS, e);
    }

    private void recordSuccess(Node node, long startNs) {
        failureDetector.recordSuccess(node, (System.nanoTime() - startNs) / Time.NS_PER_MS);
    }

    private final class GetCallable<R> implements Callable<GetResult<R>> {

        private final Node node;
        private final ByteArray key;
        private final byte[] transforms;
        private final StoreOp<R> fetcher;

        public GetCallable(Node node, ByteArray key, byte[] transforms, StoreOp<R> fetcher) {
            this.node = node;
            this.key = key;
            this.transforms = transforms;
            this.fetcher = fetcher;
        }

        @Override
        public GetResult<R> call() throws Exception {
            List<R> fetched = Collections.emptyList();
            Throwable exception = null;
            long startNs = System.nanoTime();
            try {
                if(logger.isTraceEnabled())
                    logger.trace("Attempting get operation on node " + node.getId() + " for key '"
                                 + ByteUtils.toHexString(key.get()) + "'.");
                fetched = fetcher.execute(innerStores.get(node.getId()), key, transforms);
                recordSuccess(node, startNs);
            } catch(UnreachableStoreException e) {
                exception = e;
                recordException(node, startNs, e);
            } catch(Throwable e) {
                if(e instanceof Error)
                    throw (Error) e;
                logger.warn("Error in GET on node " + node.getId() + "(" + node.getHost() + ")", e);
                exception = e;
            }
            return new GetResult<R>(node, key, fetched, exception);
        }
    }

    private final static class GetResult<R> {

        final Node node;
        final ByteArray key;
        final List<R> retrieved;
        final Throwable exception;

        public GetResult(Node node, ByteArray key, List<R> retrieved, Throwable exception) {
            this.node = node;
            this.key = key;
            this.retrieved = retrieved;
            this.exception = exception;
        }

    }

    private final class GetAllCallable implements Callable<GetAllResult> {

        private final Node node;
        private final Collection<ByteArray> nodeKeys;
        private final Map<ByteArray, byte[]> transforms;

        private GetAllCallable(Node node,
                               Collection<ByteArray> nodeKeys,
                               Map<ByteArray, byte[]> transforms) {
            this.node = node;
            this.nodeKeys = nodeKeys;
            this.transforms = transforms;
        }

        @Override
        public GetAllResult call() {
            Map<ByteArray, List<Versioned<byte[]>>> retrieved = Collections.emptyMap();
            Throwable exception = null;
            List<NodeValue<ByteArray, byte[]>> nodeValues = Lists.newArrayList();
            long startNs = System.nanoTime();
            try {
                retrieved = innerStores.get(node.getId()).getAll(nodeKeys, transforms);
                if(repairReads) {
                    for(Map.Entry<ByteArray, List<Versioned<byte[]>>> entry: retrieved.entrySet())
                        fillRepairReadsValues(nodeValues, entry.getKey(), node, entry.getValue());
                    for(ByteArray nodeKey: nodeKeys) {
                        if(!retrieved.containsKey(nodeKey))
                            fillRepairReadsValues(nodeValues,
                                                  nodeKey,
                                                  node,
                                                  Collections.<Versioned<byte[]>> emptyList());
                    }
                }
                recordSuccess(node, startNs);
            } catch(UnreachableStoreException e) {
                exception = e;
                recordException(node, startNs, e);
            } catch(Throwable e) {
                if(e instanceof Error)
                    throw (Error) e;
                exception = e;
                logger.warn("Error in GET on node " + node.getId() + "(" + node.getHost() + ")", e);
            }
            return new GetAllResult(this, retrieved, nodeValues, exception);
        }
    }

    private static class GetAllResult {

        final GetAllCallable callable;
        final Map<ByteArray, List<Versioned<byte[]>>> retrieved;
        /* Note that this can never be an Error subclass */
        final Throwable exception;
        final List<NodeValue<ByteArray, byte[]>> nodeValues;

        private GetAllResult(GetAllCallable callable,
                             Map<ByteArray, List<Versioned<byte[]>>> retrieved,
                             List<NodeValue<ByteArray, byte[]>> nodeValues,
                             Throwable exception) {
            this.callable = callable;
            this.exception = exception;
            this.retrieved = retrieved;
            this.nodeValues = nodeValues;
        }
    }

    private interface StoreOp<R> {

        List<R> execute(Store<ByteArray, byte[], byte[]> store, ByteArray key, byte[] transforms);
    }
}


text:
History and place, Judi Sutherland's Following Teisa
As Judi Sutherland mentions in the introduction to her new book-length, beautifully illustrated poem, Following Teisa (The Book Mill Press, 2021), rivers have long played an important role in U.K. poetry. From Wordsworth to Oswald, water in general is perhaps more present and prevalent as a symbol, an image, a leitmotif or even a theme in itself than in other countries. This might well because the poets in question are living on an island or in a dodgy climate, of course. However, leaving aside attempts at cod psychology, the fact remains that Sutherland is acknowledging and tapping into a rich seam.
History and the significance of place are both important cornerstones of this collection. The title itself, for instance, references an 18th Century long poem about the River Tees which was titled Teisa, Sutherland explores our relationship with the evolving role of our surroundings. In doing so, her perspective is also crucial, as explained in the following extract from the introduction:
…I moved to Teesdale in 2014 and felt dreadfully homesick for my previous village near the Thames. I started walking by the Tees as a way of getting to know and love my new environment and decided to repeat Anne Wilson's poetic journey for a different generation…
In other words, Sutherland engages as an outsider. There's no forced attempt at vernacular, for instance. Instead, she invites us along on her own exploration of the River Tees, portraying it in language that's both rich yet deft, as is indicated by the opening lines to the poem itself:
How it wells up from nowhere to chase
gravity downhill, becomes a rill,
a rickle of old stones, then hurtles rocks,
purls and pools in reed…
There's huge skill present here, not just in the assonance, alliteration and internal rhyme, but in the precise way it's all patterned and interlinked, one device starting before the previous one has come to an end: downhill-rill/rill-rickle/rickle-hurtle/hurtle-purls/purls-pools. The effect is to mirror the onrushing movement of water.
In thematic terms, the poem also evokes tensions between manmade features and the natural world. Here's one such instance:
…Below the concrete dam, a dry spillway,
while the river is re-birthed – an indignity
of outfall – with barely time to find its feet before
tumbling at forty-five degrees, a whitewater
staircase with a grand balustrade of columned rock.
Those tensions are then placed in historical context, starting from the point of departure of the allusive title and stretching throughout the book. Some references are closer to the present day…
…Once, a whole wartime platoon
of lowland men was washed away,
with their bridge pontoons, at Barne…
Others, meanwhile, engage with a more distant past:
...Above the town, a stand of pines on a barrow,
Bronze Age elders whose watchful eyes
follow. Turn around, you'll swear they've shifted
in their rootball, their wooden footfall
silent on the hill. In comes the Lune
from its lonely dale, escaping the broad dams
of Selset and Grassholme...
Throughout Following Teisa, Judi Sutherland portrays the interaction of the River Tess with people over the course of history. Her achievement in this poem lies in her ability to carry us along and immerse us in her psychogeographic exploration, inviting us to reassess our own surrounding and their own significance in our lives, all this on top of bringing us a book that's a gorgeous object in itself. Thoroughly recommended!
Posted by Matthew Stewart at 01:22
Labels: Following Teisa, Judi Sutherland
Kathleen Jones 8 February 2022 at 03:56
A fabulous review - thoroughly agree with everything you say.
Poetry submissions via Submittable
Anja König on being an unprofessional poet
The theatre of life, Barry Smith's Performance Rites


text:
Home >> Information hub >> File wrapper estoppel in the UK - the exception, not the rule?
Thu 19th Apr 2018
File wrapper estoppel in the UK - the exception, not the rule?
Services: IP portfolio management, IP strategy, Patents
Sectors: Life sciences and health
In Activis v Eli Lilly Lord Neuberger referred to certain circumstances where it would be appropriate to consider prosecution history to assist in claim interpretation. Jeff Daniels explains that this does not open the door generally to file wrapper estoppel, and reference to the prosecution history is the exception and not the rule.
In last year's UK Supreme Court decision in Activis v Eli Lilly Lord Neuberger changed the law on patent infringement by effectively introducing a doctrine of equivalents. Lord Neuberger also referred to certain circumstances where it would be appropriate to consider prosecution history to assist in claim interpretation. Some commentators took this to open the door generally to file wrapper estoppel.
However, in response to a contention that the prosecution history of an application should be used to interpret the scope of protection, the UK Patents Court has recently observed that reference to the prosecution history is the exception and not the rule.
The Patents Court case in question was L'Oréal v RN Ventures before Mr Justice Carr. At the European Patent Office, L'Oréal obtained a patent directed to an apparatus for treating acne. They brought a claim for infringement of the patent against RN Ventures, who relied upon a defence of non-infringement. The apparatus was a mechanical device suitable for treating acne through removal of sebaceous plugs from skin pores by the action of skin-contacting elements. During the proceedings two principal modes of action for the apparatus were identified: a 'shear mode' and a 'tension-compression' mode, each mode relating to the action of the skin-contacting elements of the device when applied to skin. In shear mode the skin-contacting elements generate shear force on the skin to dislodge the sebaceous plugs. In tension-compression mode the skin is subjected to alternating tension and compression to dislodge the sebaceous plugs.
RN Ventures submitted that L'Oréal had limited their main claim during prosecution to the tension-compression mode in order to support inventive step. In proposing a text for grant, the EPO examiner deleted the specific embodiment relating to the shear mode from the description. The reason given by the examiner was that this embodiment was no longer covered by the amended main claim. The examiner also deleted a claim specifically directed to the shear mode.
Mr Justice Carr referred to Lord Neuberger in his Activis judgement where it was stated that the approach of the UK Courts to prosecution history is "sceptical but not absolutist". Lord Neuberger had stated that reference to the prosecution file would only be appropriate in two circumstances where:
the point at issue is truly unclear if one confines oneself to the specification and claims of the patent, and the contents of the file unambiguously resolve the point; or
it would be contrary to the public interest for the contents of the file to be ignored.
Mr Justice Carr rejected RN's reference to the prosecution history by looking at each of the two circumstances identified by Lord Neuberger in turn. For the first circumstance Mr Justice Carr did not find the points at issue to be truly unclear in the light of the specification and claims of the L'Oréal patent, nor did he consider that the file unambiguously resolved any issue. His view was that there was no statement by L'Oréal which amounted to a clear disclaimer of the shear mode and the amendments did not have that effect. He was also not satisfied that all claims relating to shear mode were deleted. Regarding the second circumstance, Mr Justice Carr did not consider that L'Oréal was under a duty to correct any misunderstanding about of the scope of the claims on the part of the Examiner. His view was that L'Oréal was satisfied with the text, and its interpretation was a matter for national courts and not the examiner.
His final comment is particularly noteworthy: "It should be emphasised that reference to the prosecution history is the exception, and not the rule. I understand why it was relied upon in the present case, although I have not accepted RN Ventures' submissions about it. Parties should think carefully in future before incurring additional costs in arguing about the prosecution history".
So, at least as far as the Patents Court is concerned, we have been warned. Do not expect a sympathetic hearing when relying upon prosecution history in the UK Courts unless you can satisfy the Court that one of the two exceptional circumstances identified by Lord Neuberger is met. Otherwise, an award of costs may be made against you.
For prosecution at the EPO and UKIPO it is already good practice to be careful about what is put on file in view of the potential for our words to be scrutinized in related US proceedings. Adopting this standard, our practice need not be modified to accommodate the latest decisions in the UK courts.
For advice on intellectual property protection and patents in the UK, Europe and internationally, please contact Jeff Daniels on 44 (0) 207 831 7929 or email jeff.daniels@pagewhite.com.
This briefing is for general information purposes only and should not be used as a substitute for legal advice relating to your particular circumstances. We can discuss specific issues and facts on an individual basis. Please note that the law may have changed since the day this was first published in April 2018.
Jeff Daniels+44 (0) 20 7831 7929jeff.daniels@pagewhite.com


text:
Der Jüdische Friedhof Gerolzhofen ist ein jüdischer Friedhof in Gerolzhofen, einer Stadt im unterfränkischen Landkreis Schweinfurt.

Geschichte
Der Friedhof entstand im Jahre 1639 einige hundert Meter östlich des Stadtrandes. Eine Chewra Kadischa (Beerdigungsbruderschaft) wurde 1715 gegründet. 1788 folgte eine Chewra Anoschim (Beerdigungsbruderschaft für Frauen). Der Friedhof hat im Lauf der Zeit mehrere Erweiterungen erfahren und es wurden auf ihm auch Juden umliegender Gemeinden bestattet.

In der Geschichte des Friedhofs kam es zu mehreren Schändungen: Im Jahr 1927 durch zwei NSDAP-Mitglieder und auch in den Jahren 1936 und 1938. Zuletzt wurden am 24. Januar 1999 NS-Symbole auf Mauer und Taharahaus gesprüht.

Lage und Charakterisierung
Der Friedhof befindet sich am Stadtrand von Gerolzhofen an der B286.

Die drei Teile des Friedhofs entsprechen drei Belegungszeiträumen. Auf dem 120,35 Ar großen Friedhof sind in 44 Reihen 528 Verstorbene bestattet, von denen 250 namentlich zugeordnet werden können.

Taharahaus

Literatur
 Lothar Mayer: Jüdische Friedhöfe in Unterfranken. Michael Imhof Verlag, Petersberg 2010, S. 60–63, ISBN 978-3-86568-071-6 (mit vielen Fotos)

Weblinks

  Der jüdische Friedhof von Gerolzhofen bei Alemannia Judaica (mit vielen Fotos)
  Das Zentralarchiv zur Erforschung der Geschichte der Juden in Deutschland über den jüdischen Friedhof in Gerolzhofen
  Das Haus der Bayerischen Geschichte über den jüdischen Friedhof in Gerolzhofen

Gerolzhofen
Friedhof
Bauwerk in Gerolzhofen
Baudenkmal in Gerolzhofen
Sakralbau im Landkreis Schweinfurt
Gerolzhofen

redpajama_set_name: RedPajamaWikipedia


text:
DWU baseball team earns fourth seed in GPAC tourney
SIOUX CITY, Iowa--The Dakota Wesleyan University baseball team split with Morningside College on Sunday and earned the No. 4 seed in the Great Plains Athletic Conference Tournament. The Tigers lost game one 5-4, but came back for a 6-1 victory in...
By Daily Republic Sports
SIOUX CITY, Iowa-The Dakota Wesleyan University baseball team split with Morningside College on Sunday and earned the No. 4 seed in the Great Plains Athletic Conference Tournament. The Tigers lost game one 5-4, but came back for a 6-1 victory in the second game.
The victory gave coach John Greicar his 100th career win as the head coach of the DWU baseball team.
The Tigers will now play No. 5 Mount Marty College at 3 p.m. Thursday in Seward, Nebraska, in the opening round of the GPAC Tournament.
In Sunday's Game 2, JT Miller and Joseph Hanisch opened the scoring with two straight RBI singles. Mitchell's Landon Neugebauer reached base on a fielding error later in the inning that led to a DWU score, giving the Tigers a 3-0 lead.
Morningside collected its' lone run of the game in the fifth frame following an RBI single to left field. Hanisch gave the Tigers an insurance run in the sixth inning with an RBI single to right field. DeMers and Kyle Bailey tallied an RBI each as the Tigers went on to win the second game, 6-1.
Hanisch finished the game going 3-for-4 with a pair of runs batted in. DeMers, Bailey and Miller each went 2-for-5 with an RBI. Gavin Reichmuth picked up the win on the mound as he pitched eight innings and struck out three batters.
In Game 1, the Tigers took a 2-0 lead after the first inning and tacked one two more in the third inning for a 4-3 advantage. Bailey doubled down left field, bringing Reed Harter home for the score. One batter later, Miller reached on a fielder's choice, while Chandler Bakley scored off a Mustang error.
Morningside, however, regained the lead with a two-run fourth inning with two runs coming home after a Tiger error. This proved to be too much as the Mustangs took the opening game, 5-4.
DeMers went 1-for-2 with an RBI and a run scored, as Miller tallied a run batted in and Bailey finished 1-for-4 with an RBI. Gunnar Johnson pitched six innings and struck out three batters.
Related Topics: DAKOTA WESLEYAN UNIVERSITYBASEBALL
Prep basketball action from around the state for Saturday, Jan. 28.
By Mitchell Republic
Summit hoops roundup: Jackrabbit women extend winning streak to 11
SDSU men blow 22-point lead in loss at Western Illinois
By Matt Zimmer
Mitchell girls basketball downs Rapid City Central, moves back above .500
As a team, the Kernels knocked down six of their 16 (37.5%) 3-point tries and shot 17-for-43 (39.5%) from the field.
By Zech Lambert
Area basketball roundup for Jan. 27: Ethan girls, Howard boys win Class B showdowns
Prep basketball action from around the state for Friday, Jan. 27.


BLACK HAWK DOWN is one of the most harrowing and realistic war movies made to date. In times like these, when the movie market is saturated with feel-good films and patriotic-pride-propaganda (ever heard of PEARL HARBOR), BLACK HAWK DOWN casts a clear eye on the horror of war and paints its characters vividly and true to form.
HAWK chronicles the U.S. battle of Mogadishu. On October 3, 1993, U.S. forces engaged in the longest sustained ground battle involving American soldiers since the Vietnam War. U.S. Special Forces invaded the Somali city by Humvee and helicopter to abduct two of Somalian warlord Mohamed Farrah Aidid's lieutenants. Soon into the skirmish, one of the Black Hawk helicopters plummets to the earth due to enemy fire. Under orders from Major General William Garrison, no man is to be left behind. The Humvee convoys sent to gather the wounded soldiers meet with constant fire from the Somalis and have to maneuver labyrinthine city roads. As the battle ensues, two more helicopters crash, leaving the army with countless men to rescue.
In many war movies, the screenplay serves up either one or a few characters to follow their tribulations throughout the military ordeal. When one of the men dies, you can't help feeling a sense of loss as well. This technique puts a human face on the senselessness of war. HAWK does not do this. What this movie does do is present an ensemble of men (several of them notable actors, including Josh Hartnett fresh off the Hawaiian isles, Tom Sizemore, Ewan McGregor, and Sam Shepard) who collectively carry the action of the movie. When a man dies sometimes you don't really recognize him. It realistically represents the facelessness of war—men don't know who they kill in battle, just faces of the enemy.
I wouldn't recommend this film to the weak of stomach due to highly graphic war scenes and countless injuries. I would recommend this film to those who want to see a piece of history to help reflect on the current situation America finds itself in—although in this war we are not fighting someone else's war; we are fighting our own. We are not trying to rescue another country, but our own.


HighDesign 2017 is now available for download at http://www.ilexsoft.com/downloads/index.html. This latest version introduces a new, entry-level LT edition aimed at individuals who simply need professional-grade drafting tools within an easy-to-use, yet affordable solution.
HighDesign 2017 is also coming to the Windows platform. HighDesign for Windows has been designed to preserve the same user experience, features, file format and usability as the Mac version, thus enabling the users to freely choose the platform that best suits their needs. HighDesign for Windows is currently in the final beta testing stage and will be available in the first quarter of 2017.
Textures: The HighDesign library now includes a selection of textures ready to use in projects. Textures can have custom origin, scale and orientation. In the Standard and Pro editions, the Drawing Manager allows the user to extend the library with new, custom textures.
Improved drafting: many tools have been improved to provide more powerful drafting features, such as circular holes inside hatches, more accurate input and dimensioning, new special line types such as grass and ridge, more options for poly-lines, and better management of the project resources.
Smarter Columns: the Columns tool in HighDesign Pro now automatically aligns the insertion point of new columns to the grid defined by existing columns. With this feature, it is now possible to effortlessly create structural grids at a defined angle and offset.
Better DXF/DWG compatibility: HighDesign 2017 adds a much improved layout support, more entities and better support for user coordinate systems which is critical when importing drawings created by BIM packages.
Many improvements aimed at stability, speed and overall consistency.
As a recent 2016 Pro purchaser, do I get the 2017 release free? If so, How do I update?
If you purchased through our store, your license includes one year of free updates, after which you can renew for another year at a discounted price. For example, if you purchased in June 2016, you can install and use all the updates that are released until June 2017, no matter their version number.
To update, simply download the new DMG package and copy the app to your Applications folder. We usually advise to remove the previous version because having two different versions can create some confusion in the Finder, but that is optional.
Andrew, so If I purchased 2016 Pro via Apple App Store, I don't have one year free updates? If this is the case, what are my options to update to 2017 Pro?
rudy@viscon wrote: Andrew, so If I purchased 2016 Pro via Apple App Store, I don't have one year free updates? If this is the case, what are my options to update to 2017 Pro?
Rudy, unfortunately the App Store makes it impossible for developers to implement upgrades and renewals. However, we want to do all we can to provide the best conditions to our users. Please contact us privately so we can find an arrangement.


text:
The concept's Georgia franchise partner, Five Guys Taverns, LLC, comprises a group of highly experienced franchisees and developers.
Jon Taffer's Restaurant Signs Deal for First Location
Taffer's Tavern, the restaurant concept created by award-winning hospitality expert and world-renowned business consultant Jon Taffer, signed a lease to open its first franchise location in the nation in downtown Alpharetta, Georgia. Located at 33 South Main Street, Taffer's Tavern is situated in the Liberty Hall building directly across from City Hall and is anticipated to open by February 2020.
The concept's Georgia franchise partner, Five Guys Taverns, LLC, comprises a group of highly experienced franchisees and developers—one partner of which is the CEO of Chandlee and Sons Construction, the construction company responsible for designing popular Atlanta dining spots like Big Sky Buckhead and Ladybird Grove & Mess Hall. After signing a multi-unit franchise deal with Taffer's Tavern earlier this year, Five Guys Taverns, LLC, aims to open four additional units across the state.
"I worked with Jon on a 'Bar Rescue' renovation and witnessed firsthand his expertise and heightened understanding when it comes to the restaurant and bar experience," says Seth Chandlee, CEO of Chandlee and Sons Construction and founding partner of Five Guys Taverns, LLC. "The idea of 'tavern dining' is a timeless concept rooted in community, which makes Taffer's Tavern the perfect addition to Alpharetta's historical downtown area."
With a streamlined kitchen design that eliminates the need for costly traditional commercial equipment, Taffer's Tavern leverages advanced sous vide food preparation methods to deliver interesting, delicious bar fare and a unique array of premium beverage choices. The new Alpharetta restaurant boasts high vaulted ceilings and combines modern architecture with old-world tavern charm, including the main bar, which was built in the 1700s and imported from England.
"The casual dining segment has become stale and predictable in recent years – customers are no longer satisfied with a simple hamburger on a plate," says Taffer. "Taffer's Tavern is purposefully designed to disrupt the industry by combining advanced technology solutions with elevated cuisine, effectively delivering a first-rate dining experience for customers while maximizing investment for franchisees. Alpharetta is growing in popularity and rated as one of the best places to live in the country, making it a prime market to establish Taffer's Tavern and set the stage for future state- and nationwide expansion."
To facilitate growth for the emerging brand, Taffer has partnered with Fransmart, the industry-leading franchise development company behind the explosive growth of brands like Five Guys Burgers and Fries, and Qdoba Mexican Grill, as the exclusive franchise development partner for Taffer's Tavern.