--- layout: default home: true js: - home - stacks - twitterWidgets css: - home - blog seo-title: Kabanero ---
Kabanero is an open source project focused on bringing together foundational open source technologies into a modern microservices-based framework. Developing apps for container platforms requires harmony between developers, architects, and operations. Today’s developers need to be efficient at much more than writing code. Architects and operations get overloaded with choices, standards, and compliance. Kabanero speeds development of applications built for Kubernetes while meeting the technology standards and policies your company defines. Design, develop, deploy, and manage with speed and control!
Try ItKabanero can help your team modernize existing applications to leverage benefits of cloud and containers.
Kabanero can help you create cloud native applications with your team.
An Application Stack leads a company down a golden path to develop quality microservice-based applications. They provide guides for developers, templates for simplicity, consistency for developing applications, and a runtime in a certified base container image infused with expertise for Kubernetes deployments.
Eclipse MicroProfile is a set of APIs used to optimize Java applications for a microservices architecture. With this stack, you can deliver microservices based upon the Eclipse MicroProfile specifications. Build and run high-quality applications with Open Liberty runtime, which includes OpenJDK with container-optimizations in OpenJ9.
Spring® is a framework used in Java application development. With this application stack, you can deliver microservices based upon the Spring framework provided by Pivotal. Spring Boot applications run on OpenJDK.
Node.js is a JavaScript runtime environment that can execute JavaScript code anywhere, not limited to a browser. Due to its single-threaded nature, Node.js enables the creation of non-blocking and event-driven servers. It fits well in web-based frontends and backend API services for microservices-based applications.
Modernize Applications
Languages & Runtimes
Develop
Build
Manage
Modernize Applications
Plan, execute, and enhance your cloud modernization journey. Kabanero integrates with free modernization tooling from IBM for Java applications. Choose to re-factor applications based on ROI. Accelerate development efforts with assistance within your IDE using guided code changes.
Languages and Runtimes
Use the right language for the job. Java is at the core of most modern application environments and can support Eclipse MicroProfile or Spring-based microservices. No matter your workload, we have runtimes and application stacks to simplify application development and delivery on Kubernetes.
Develop
Develop applications for Kubernetes faster using extensions to industry leading IDEs. Perform inner loop development of applications directly in containers from day one. Eclipse Codewind provides extensions to VS Code, Eclipse, as well as Eclipse Che for teams preferring a cloud hosted IDE. Hosted or local, it’s the same experience.
Build
DevOps is critical for a successful microservices-based deployment. Kabanero supplies an integrated open source CI/CD (continuous integration / continuous delivery) infrastructure based on the open source project Tekton. Kabanero provides for a rich set of stages that pipelines can use to integrate features like patching, vulnerability scanning, and more.
Manage
Applications are deployed with best practices for Kubernetes deployments including scale, security, health and liveness probes. Kabanero also provides the ability to augment the base images with additional management capabilities as defined in the application stack. See everything from a single pane of glass with insights and correlation spanning traditional and Kubernetes applications for proactive problem determination.
{{ post.seo-description | escape }}
{% else %}{{ post.seo-description | escape }}
{% endif %}


Lineup!
First, add your players marking who is active and then click "Build Lineup".
Add Player
Build Lineup
Demo
Team roster: {{activePlayersCount}} active, {{players.length}} total
Active
Name
Number
Position
Skill
Delete
{{player.active ? 'Yes' : 'No'}}
Please enter a name. ("~" not allowed)
Please enter a jersey number. (
Select an option
Goalie
Defense
Center
Wing
Please enter a skill level.
X
The Lineup
×
Period 1
Period 2
Period 3
#
Name
No.
Position
1
2
3
4
5
6
7
8
9
{{index + 1}}
{{player.name}}
{{player.number}}
{{player.position}}
Standard Deviation
{{lineup.sd}}
Variance
{{lineup.var}}
Mean
{{lineup.mean}}
Line Scores
{{lineup.scores}}


Tom is a Business Analyst who works within the Commodities Trading Industry
Check out Tom's Skill
Thanks for visitinging! Get in contact with Tom via Twitter: @tcirwin


The script wipes workspaces of certain jobs on all nodes.
Execute it from <Jenkins host>/computer/(master)/script Change the TODO part to specify which jobs to affect
import hudson.model.* // For each job for (item in Hudson.instance.items) { jobName = item.getFullDisplayName() // check that job is not building if (!item.isBuilding()) { // TODO: Modify the following condition to select which jobs to affect if (jobName == "MyJob") { println("Wiping out workspaces of job " + jobName) customWorkspace = item.getCustomWorkspace() println("Custom workspace = " + customWorkspace) for (node in Hudson.getInstance().getNodes()) { println(" Node: " + node.getDisplayName()) workspacePath = node.getWorkspaceFor(item) if (workspacePath == null) { println(" Could not get workspace path") } else { if (customWorkspace != null) { workspacePath = node.getRootPath().child(customWorkspace) } pathAsString = workspacePath.getRemote() if (workspacePath.exists()) { workspacePath.deleteRecursive() println(" Deleted from location " + pathAsString) } else { println(" Nothing to delete at " + pathAsString) } } } } } else { println("Skipping job " + jobName + ", currently building") } }


Welcome to Agoda
The effortless engine for Hotels and Accomodations
Trending search: Tokyo, Hong Knong, New York
Public
KIEV, UKRAINE
Ilya Dmitruk
I'm #founder and #designer at cardsaround. Connect me for #investment #productdesign
Public
HENRY"S VIDEO GAMES
Michael Rodriguez
#executivevicepresident, Devices & Services #henryvideogames. Ice cream lover.
Personal
KIEV, UKRAINE
Jakov Green
#Objective-C #Java #cocoa #c++ #developer


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Makes 4 popovers
Great for cooks under five these savoury bacon snacks are easy to whip up for a playtime treat.
Equipment and preparation: You will need a 6-hole muffin baking tray.
Before cooking, wash your hands and put an apron on. Weigh and measure all the ingredients. Ask a grown-up to preheat the oven to 220C/425F/Gas 7.
Oil the muffin tray using a pastry brush and place it onto a baking tray.
Break the egg into a small bowl and beat it with the fork. Place the flour into a mixing bowl, add the egg and stir.
Add the milk to the flour mixture and stir again until you have lots of bubbles and all the flour disappears. This mixture is called a batter.
Add the mustard to the batter. Pour the batter from the mixing bowl into the measuring jug that had the milk in it.
Tear up the mushrooms and divide the pieces between the muffin cups.
Ask a grown-up to help you with using the scissors to cut up the bacon into small pieces. Divide these between the muffin cups, too.
Then chop the tomatoes and share them out between the muffin cups. Finally, pour the batter over the top.
You’ll need to ask a grown-up for help with this part. Put the muffins into the preheated oven for 15–20 minutes, or until brown on top. Once the popovers have cooled down a little, you can eat them!


DONATIONS
Look familiar?
The hassle of always taking inventory, reading constant emails, and dealing with the endless paperwork. Large donations can be bittersweet, as you stay up all night cataloging. And without any proper documentation, it's near impossible to trust anyone but yoursel to do it all.
STAFF
ORDERING
Ready for a change?
UNLOCK THE POWER OF
I'll Serve Soup
The all-in-one inventory platform
Simplify your life by using an all-in-one system where data syncs automatically - you'll never have to juggle a dozen different systems, or pull your hair out consolidating data.
I'll Serve Soup makes life as easy as possible because your mission is important, and you need software that gets you to your goals faster.


markdown:
[Henrik's Site](path-to-site)
markdown:
[Henrik's Site](path-to-site "Henrik's Site")
My Blog is called Henrik’s blog.
markdown:
My Blog is called [Henrik's blog][BLOG].
[BLOG]: path-to-site "Henrik's blog"
Remember BLOG tag must be defined at the bottom of markdown document.
Some Information about this blog and me can be found here.
markdown:
Some Information about this blog and me can be found [here](path-to-site)
markdown:
![Northeastern](path-to-image.png "Northeastern"){:width="128px" :height="128px"}


User Registration Form
Incorrect data
Name
Incorrect data
Email
Incorrect data
Password
Incorrect data
Submit


Paintings
Participants
Settings
Add a lot
Paintings
Description
Title
Author
Description
Image source
Starting price
Min step
Max step
Participation in tenders
Save
Close
Edit


welcome
Welcome to the getting started guide, you will find here a step by step guide using a Maven archetype. Optionally, you might want to try the one of the starter projects:
requirements
start
Just paste this into a terminal (make sure you are in an empty folder, and Java 8 and Maven 3.x are installed):
mvn archetype:generate -B -DgroupId=com.mycompany -DartifactId=my-app -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=jooby-archetype -DarchetypeGroupId=org.jooby -DarchetypeVersion=1.6.6
You might want to edit/change:
-
-DgroupId: A Java package’s name
-
-DartifactId: A project’s name in lower case and without spaces
-
-Dversion: A project’s version, like
1.0-SNAPSHOT
or1.0.0-SNAPSHOT
Let’s try it!:
mvn archetype:generate -B -DgroupId=com.mycompany -DartifactId=my-app -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=jooby-archetype -DarchetypeGroupId=org.jooby -DarchetypeVersion=1.6.6
cd my-app
mvn jooby:run
You should see something similar to this at the end of the output:
INFO [2015-03-19 21:34:00,365] Hotswap available on: [my-app/public, my-app/conf, my-app/target/classes]
INFO [2015-03-19 21:34:00,368] includes: [**/*.class,**/*.conf,**/*.properties]
INFO [2015-03-19 21:34:00,369] excludes: []
INFO [2015-03-19 21:34:00,937] [dev@netty]: App server started in 502ms
GET / [*/*] [*/*] (anonymous)
listening on:
http://<IP_ADDRESS>:8080/
Jooby! is up and running!
getting started
exploring the newly created project
A new directory was created: my-app
. Let’s see what it looks like:
.
├── public
| └── (empty)
├── conf
| ├── application.conf
| └── logback.xml
└── src
├── main
| └── java
| └── com
| └── mycompany
| └── App.java
└── test
└── java
└── com
└── mycompany
└── AppTest.java
The public folder contains static content like *.html
, *.js
, *.css
, …, *.png
files.
The conf folder contains *.conf
.
The src/main/java folder contains *.java
files (of course).
The src/test/java folder contains unit and integration tests.
NOTE: The
public
andconf
folders are part of the classpath.
App.java
import org.jooby.Jooby;
public class App extends Jooby { // 1
{
// 2
get("/", () -> "Hello World!");
}
public static void main(final String[] args) {
run(App::new, args); // 3. start the application.
}
}
Steps involved are:
1) extend Jooby
2) define some routes
3) call the run
method
running
Open a console and type:
mvn jooby:run
The maven plugin will compile the code (if necessary) and start the application.
Of course, you can generate the IDE metadata from Maven or import as a Maven project in your favorite IDE.  After all, this is a plain Java application with a main
method.
where to go now?
- read the documentation
- check out one of the starter projects


Release {{appState.release}}
City Hub is your hub into the City Chain. As always, use with caution.
Network: {{appState.network}}
Mode: {{appState.mode}}
Version: {{node.version}}
Protocol: {{node.protocolVersion}}
What's new
Third party licenses
Privacy Policy
Wallet directory:
{{ node.dataDirectoryPath }}
{{ node.dataDirectoryPath }}
City Chain Website
Source Code


L. Rochelle Beal
Web Developer - MERN Stack
I am a Full Stack Web Developer, transitioned from the Navy as an Avionics Technician. The skills I learned while being in the military (e.g. leadership, problem-solving, teamwork, and time-management) has led to the successful creation of numerous applications.
I am growing every day as a developer and have recently been developing projects using MERN (Mongo, Express, React + Redux, and Node) stack technologies. I love taking on new challenges and thrive in an enviroment that constantly embraces change.


We use proven methods to test your water for e-coli and other contaminants.
Everything you need to test your water for E-Coli and Hepatitus A.
Find out why water treatment is necessary.
©2017 W.E.T. Laboratory -


@Experimental public final class TDigestQuantiles extends java.lang.Object
PTransform
s for getting information about quantiles in a stream.
This class uses the T-Digest structure introduced by Ted Dunning, and more precisely
the MergingDigest
implementation.
The paper and implementation are available on Ted Dunning's Github profile
Only one parameter can be tuned in order to control the tradeoff between
the estimation accuracy and the memory use.
Stream elements are compressed into a linked list of centroids.
The compression factor cf
is used to limit the number of elements represented by
each centroid as well as the total number of centroids.
The relative error will always be a small fraction of 1% for values at extreme quantiles
and always be less than 3/cf at middle quantiles.
By default the compression factor is set to 100, which guarantees a relative error less than 3%.
There are 2 ways of using this class:
PTransform
s that return a PCollection
which contains
a MergingDigest
for querying the value at a given quantile or
the approximate quantile position of an element.
TDigestQuantiles.TDigestQuantilesFn
CombineFn
that is exposed in order
to make advanced processing involving the MergingDigest
.
The simplest use is to call the globally()
or perKey()
method in
order to retrieve the digest, and then to query the structure.
PCollection<Double> pc = ...;
PCollection<MergingDigest> countMinSketch = pc.apply(TDigestQuantiles
.globally()); // .perKey()
One can tune the compression factor cf
in order to control accuracy and memory.
This tuning works exactly the same for globally()
and perKey()
.
double cf = 500;
PCollection<Double> pc = ...;
PCollection<MergingDigest> countMinSketch = pc.apply(TDigestQuantiles
.globally() // .perKey()
.withCompression(cf);
This example shows how to query the resulting structure, for example to
build PCollection
of KV
s with each pair corresponding to
a couple (quantile, value).
PCollection<MergingDigest> pc = ...;
PCollection<KV<Double, Double>> quantiles = pc.apply(ParDo.of(
new DoFn<MergingDigest, KV<Double, Double>>() {
@ProcessElement
public void procesElement(ProcessContext c) {
double[] quantiles = {0.01, 0.25, 0.5, 0.75, 0.99}
for (double q : quantiles) {
c.output(KV.of(q, c.element().quantile(q));
}
}}));
One can also retrieve the approximate quantile position of a given element in the stream
using cdf(double)
method instead of quantile(double)
.
The CombineFn
does the same thing as the PTransform
s but
it can be used for doing stateful processing or in
CombineFns.ComposedCombineFn
.
This example is not really interesting but it shows how one can properly
create a TDigestQuantiles.TDigestQuantilesFn
.
double cf = 250;
PCollection<Double> input = ...;
PCollection<MergingDigest> output = input.apply(Combine
.globally(TDigestQuantilesFn.create(cf)));
Warning: this class is experimental.
Its API is subject to change in future versions of Beam.
| Modifier and Type | Class and Description |
|---|---|
static class |
TDigestQuantiles.GlobalDigest
Implementation of
globally() . |
static class |
TDigestQuantiles.PerKeyDigest<K>
Implementation of
perKey() . |
static class |
TDigestQuantiles.TDigestQuantilesFn
Implements the
Combine.CombineFn of TDigestQuantiles transforms. |
| Constructor and Description |
|---|
TDigestQuantiles() |
| Modifier and Type | Method and Description |
|---|---|
static TDigestQuantiles.GlobalDigest |
globally()
Compute the stream in order to build a T-Digest structure (MergingDigest)
for keeping track of the stream distribution and returns a
PCollection<MergingDigest> . |
static <K> TDigestQuantiles.PerKeyDigest<K> |
perKey()
Like
globally() , but builds a digest for each key in the stream. |
public static TDigestQuantiles.GlobalDigest globally()
PCollection<MergingDigest>
.
public static <K> TDigestQuantiles.PerKeyDigest<K> perKey()
globally()
, but builds a digest for each key in the stream.K
- the type of the keys


You can easily override the methods of the base class by pressing &shortcut:OverrideMethods; (Code | Override Methods).


Fresh Fruits
It has long been known that a diet that includes at least a few servings of fresh fruit every day will help keep you healhty. fit and trim.
Title goes here
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O


We run a tight ship here. Our PC builders have years of experience and never cut corners when it comes to cable management and assembly.
Rainbow RGB with a unicorn laser engraved on? How about a minimalistic setup for the stealthy gamer? We've got you covered with innumerable options.
You don't have to be a gamer to appreciate aesthetics or want something that just works. If you need to work from home and need to get the ball rolling quickly, we've got you covered.
Partner up with the best custom PC system builder in the world and earn extra cash! Become An Official ORIGIN PC Affiliate Today!
JoinOnce you join us, we will have you covered. With every system, ORIGIN PC provides a free phone and online lifetime service guarantee.
Learn More


--- layout: page id: Fab16BostonHub hastitle: true title: Join us for FAB16 - Boston Hub Events! hasdescription: false description: - paragraph: >-
A week-long celebration of Making, Innovation, Art and Manufacturing in the Greater Boston area. August 8 to August 14, 2021
SCROLL DOWN TO VIEW THE FULL SCHEDULE!
hasjumplinks: false jumplinks: - link: Schedule Boston Hub Fab 16 url: bostonschedule background-img: Fab16BOSbackground4.png --- {% include fixed/services-cards.html texts=site.data.bostonhub.about %} {% include fixed/section.html texts=site.data.bostonhub.schedule %} {% include fixed/services-cards.html texts=site.data.bostonhub.locations %} {% include fixed/become-a-partner.html texts=site.data.bostonhub.partnersfab16boston %} {% include fixed/posts-gallery.html %}


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
Illustration by Megan Knapp
4/4/19
In the small city of Vincent lies Cutler Station, a band comprised of four best friends who were born destined to be heard and loved through the music they make together.
The band’s formation process, though, was not entirely cohesive. It took years for brothers John and Kirby Evans, and their longtime friends Steve Lipscomb and Jason Swiger to get to where Cutler Station is now. Despite the long process, all four guys, who have been together now for two decades, had nothing but smiles when reflecting back on their journey.
The story begins with Lipscomb and the Evans brothers playing in Columbus as Cutler Station, John said. John moved to the area once he secured a job in Parkersburg, West Virginia, and Lipscomb moved here six months later. Kirby stayed in Columbus until summer 2018.
Bre Offenberger | FOR THE POST
From left to right, John Evans, Jason Swiger, Steve Lipscomb and Kirby Evans of local band Cutler Station pose for a portrait in Front Room Coffeehouse
“We had played in bands prior to that in high school and college and stuff,” John said. “So as soon as we got back, we were like, ‘Let’s start it up like this.’”
Swiger, who had moved back here after finishing up at Marshall University in Huntington, West Virginia, had been following the band on social media.
“I was kind of following along because I liked what I had heard,” Swiger said.
The band is inspired by influential bands of the early ‘90s and early 2000s, especially Weezer.
“Green Day, too,” John offered.
“Weezer,” Kirby said. “No thanks.”
And the other guys agreed.
“We all really liked Weezer, so we were like, ‘Hey, we would like to make music like that,’” Swiger said.
All four men had different beginnings of how they decided to pursue music, though all members, except Swiger, were in choir. John received a guitar during his eighth grade birthday and once his older brother stole it and learned how to play, Kirby, the younger brother, asked for a guitar that Christmas.
“They got me a guitar from Sam’s Club,” Kirby said, as the group all chuckled. “We had our cousin in the first version, and we just had five-gallon buckets that we would play the drums on. That’s kind of how we (the Evans brothers) started playing music. It just kind of evolved from there.”
Lipscomb started playing trombone in fifth grade but chose to learn even more than that during high school.
“Some of these guys that are our friends were in a band in high school, and I kind of envied the thing they were doing,” Lipscomb said. “They were having fun and I had to work through high school, so I learned how to play guitar and drums.”
Swiger’s dad was a fan of metal music, so he had grown up listening to hair bands all his life. However, he became a drummer through a trip he made to Hard Rock Cafe.
“I started playing drums because I went to a Hard Rock Cafe and wanted souvenir drum sticks,” Swiger said. “I got them but didn’t keep them as a souvenir. I air drummed to all my favorite bands. My dad thought, ‘Well, I should buy you a set of drums if you’re gonna do that.’ All the noise started from there.”
Cutler Station released its self-titled album on Jan. 18. The album tackles different issues prevalent in Appalachia, especially the drug problem, but is surrounded by feel-good riffs and eccentricity. The band knows it manufactures its own distinct sound that can’t be compared to anyone else — and with that, each member is always willing to try anything. No one ever says no.
“I don’t think we have good enough vocals to just rock the Americana singer-songwriting thing, so we kind of have to lean on being creative,” Kirby said. “Then hope that the conglomerate of the song is good and not just someone who can sing really good. I think we’re trying to find more ways to connect with people — finding those things that most people don’t write about but still relate to people.”
The track “Southeast Ohio Speedster” is inspired by an ex-marine Lipscomb hired to work at his and his dad’s construction company. He was a drug addict and went to jail, but he had straightened himself up.
“In modern Appalachia, it’s really hard to find help in any business, really — qualified people who are willing to help,” Lipscomb said. “In the construction side of things, it’s even harder because it’s a physically demanding job and it doesn’t pay very well so you get a lot of unsavory characters.”
That guy eventually quit and later left Lipscomb a voicemail. John came up with the hook for the song based on him and that message: “You’re a Southeast Ohio speedster — higher than the minimum wage.”
“(The ex-marine) quits, leaves one day and doesn’t come back to work, and I get a voicemail where he butt-dialed me. It’s a four-minute long conversation he’s having with someone in his car about doing drugs and getting high and money. In that song, we took snippets of that voicemail underneath the track. John took the idea of that guy and made a character that resembles him but also some other Appalachia things like stir-track racing.”
The track “Appalachian Highway” started off as a bluesy, slower song, but it never felt right to the group. This was the song when the band really shifted gears and decided it wanted to play live shows.
“It was a turning point,” Swiger said. “Our point shifted as a band a little over a year ago. If you go back and listen to our first album (Happy Campers), it’s a lot different. We wanted to make an album where we could go on the road and replicate and play.
Cutler Station is not interested in making songs for radio play — rather, the band members prefer to create music they like and will constitute happiness for them.
“We do this for enjoyment, it takes away the stress,” Swiger said. “To me, it seems so ingenuine when you’re writing a song that’s like, ‘Okay, what would they like?’”
Lipscomb agreed but also included a humorous moment that got the whole band to form a smile.
“There really is not a radio (station) for the kind of music that we like,” Lipscomb said. “Maybe we are trying to be on the radio, but we’re just not good enough.”
Cutler Station finds it is very different from the artists with which they perform.
“The local bands we play with are normally driven by one singer-songwriter, one main person of the band,” Lipscomb said. “We come from a unit perspective of it. I think that makes us different.”
Jimmy Roux, a recording artist who performed with Cutler Station at a show in Belpre, Ohio, in October 2018, loves the band’s style.
“Cutler Station is something the Mid-Ohio Valley has needed now for a long time, from their original signature sound to their bizarre props and exploding energy they pour out to the audience,” Roux said.
The band prides itself on having no one leader of the group.
“Anyone can do anything in the band,” Lipscomb said. “If you wanted to play drums on a song, you can play drums. If you wanted to play guitar and you wrote a song, it’s your song. And we’ll accompany it the best we can. There’s no lead person.”
The band collectively agreed it’s easier to make music together being the best friends they are. Lipscomb added it’s always been that way, that they’ve always gravitated toward each other.
“You get a certain level of comfort when you’re playing with someone you know really well but also played with a long time,” Swiger agreed. “I guess it’s not something you can really replicate.”
“This first and foremost is our hobby. This is the truest representation of our personalities in music”Steve Lipscomb
Cutler Station will be playing at Smiling Skull Saloon, 108 W. Union St., on May 10 at 10 p.m. Adrienne Whitney, owner and booking manager of Smiling Skull Saloon, loves to book bands that fit the exciting atmosphere of the venue — and Cutler Station meets those requirements.
“Cutler Station looked like a good fit for our venue — fun and funky,” Whitney said in an email. “The local music scene in Athens is part of what makes our town great, and we enjoy hosting bands from around the region as well as touring acts from as far as California or Maine and all points in between.”
The members of Cutler Station finds it important to let people know they don’t have to listen to the band’s music, but they hope they do.
“We offer a different pallet but still in a package that’s listenable,” Lipscomb said. “It’s not hard to dig into. ... This first and foremost is our hobby. This is the truest representation of our personalities in music.”
Landing Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


WITNESS LIST Education Committee February 26, 2001 -10:00A Public School Employee Health Insur ON: Beckett, Sheila Executive Director (Employees Retirement System), Austin, TX Dial, Philip Consulting Actuary (Employees Retirment System), Austin, TX Lebas, James (Comptroller's Office), Austin, TX McCabe, Martha Attorney (State Auditor's Office), Austin, TX Smith, Carol Ann CPA (State Auditor's Office), Austin, TX


Series of live stream code sessions
Playing with Perlin noise with JavaScript on an HTML5 canvas
Further playing with Perlin noise with Cube (Pair programming!)
Polygon Ninja with Robert (Pair programming!)


CLEAR
A REG
CLEAR
R REG
CLEAR
D REG
CLEAR
B REG
CLEAR
CONT. TOG.
CLEAR
C REG
TEST SYSTEM
COUNTER
T8
T4
T2
T1
PULSE SOURCE
ON
OFF
WORD
CONTINUOUS
INC.
↷
L.F. ADJ.
SINGLE PULSE
SINGLE WORD
ZERO
EXT.
 ALARM
DISABLE
CLEAR
LOCK
NORMAL
TIMING TOGGLE
EXECUTE
FETCH
OPERATION
CONTINUOUS
STEP
START
MEMORY CONTROL
MAIN
R/W/M
R/W/L
WD/BL
ACT.
ACCESS
L/M
L7
L6
L5
L4
Using "??"
|
retro-205 ?.??


Themeable scrollbar is the scrollbar component made accordingly to the Fiori 3 design guidelines.
Using the themeable scrollbar is preferred over the browser's default in the components that support having
scrollbars and made accordingly to the Fiori 3 design guidelines.
Themeable scrollbar works in Chrome, Safari, and other WebKit\Blink-based browsers and partially works in
Firefox (no hover effects).
Component is not working in the IE, default scrollbar is shown instead.


v0.1 - by Víctor & Ela
13 Feb 2020
Our game is a Mario-type scroller game (that doesn't automatically scroll), where you control a character escaping a monster
following them from the side of the screen.
Apart from that, there are other enemies and obstacles that you either have to avoid or defeat
by completing mini-puzzles.
The objective is to last as long as possible alive.
Our target audience is a young audience, with an age range of 14 to 30 year old.
There are no levels as such, but the background of the game changes to give a sensation of advancement.
At the beggining of the game there's a default character to play, there are other two unlockable characters
that can be unlocked with points from the game.
Also, players can upload a png to use as a customized character.
There are three main obstacles: small enemies, boulders and rocks.
Small enemies block the way, and can only be defeated by solving word puzzles. If you fail, the enemy strikes
your character and removes life points.
 There are three types: bronze boulders, silver boulders
and gold boulders. The more valuable the material is, the more puzzles you have to complete to destroy the boulder.
Rocks fall from the ceiling, and remove some life points if they hit your character. To avoid this you must move your
character to dodge them.
As you move along the scrolling map you'll find different powerups.


Next Gen
Video with
360 Cam
Shop Now >
Top Rated
Gadgets
are on Sale
Shop Now >
Catch Big
Deals on
Earbuds
Shop Now >
World of music with
Choose between top brands
More Products >
Headphones
Wireless Bluetooth Headphones
$198.00
Computers
AipPort Extreme Basestation
$98.50
TV Video & Audio
Smart TV LED 49" Ultra HD
Out of stock
Smart Home
Smart Speaker with Voice Control
$49.99
Wearable Electronics
Fitness GPS Smart Watch
$317.40
Smartphones
Popular Smartphone 128GB
$965.00
Wearable Electronics
Smart Watch Series 5, Aluminium
$349.99
Computers
Convertible 2-in-1 HD Laptop
$412.00
All new
at discounted price. Hurry up!
28d 23h 46m 39s
Bestsellers
Wireless Bluetooth Headphones
$259.00
Cloud Security Camera
$122.00
Android Smartphone S10
$799.00
Android Smart TV Box
$67.00
New Arrivals
Monoblock Desktop PC
$1,949.00
Laserjet Printer All-in-One
$428.60
Console Controller Charger
$799.00
Smartwatch Series 5, Aluminium
$349.99
Top Rated
Android Smartphone S9
$799.99
Wireless Bluetooth Headphones
$428.60
360 Degree Cameras
$98.75
Digital Camera 40MP
$210.00
250k+
View latest gadgets reviews available for purchase in our store
5 New Cool Gadgets You Must See
on Cartzilla - Cheap Budget
5 Super Useful Gadgets on Cartzilla
You Must have in 2020
Top 5 New Amazing Gadgets on
Cartzilla You Must See
Latest store,fashion news and trends
#ShopWithCartzilla
Sneakers & Athletic
Athletic Apparel
Sandals
Jeans
Shirts & Tops
Shorts
T-Shirts
Swimwear
Clogs & Mules
Bags & Wallets
Accessories
Sunglasses & Eyewear
Watches
Your Account
Shipping rates & policies
Refunds & Replacements
Order Tracking
Delivery info
Taxes & Fees
About Company
Our Teams
Careers
News
Subscribe to our newsletter to receive early discount offers,updates
and new
product info.
Free delivery for all orders over $200
We return money within 30 days
Friendly 24/7 customer support
We possess SSL/Secure certificate
Outlets
Affiliates
Support
Privacy
Terms of use
All rights reserved.Made by Createx Studio.


Ack defines signature for middleware invoked on *amqp.Channel.Ack() call.
type Ack func(next HandlerAck) HandlerAck
ArgsAck stores args to amqp.Channel.Ack() for middleware to inspect.
type ArgsAck struct { Tag uint64 Multiple bool }
ArgsConfirms stores args to amqp.Channel.Confirms() for middleware to inspect.
type ArgsConfirms struct { NoWait bool }
ArgsExchangeBind stores args to amqp.Channel.ExchangeBind() for middleware to inspect.
type ArgsExchangeBind struct { Destination string Key string Source string NoWait bool Args streadway.Table }
ArgsExchangeDeclare stores args to amqp.Channel.ExchangeDeclare() for middleware to inspect.
type ArgsExchangeDeclare struct { Name string Kind string Durable bool AutoDelete bool Internal bool NoWait bool Args streadway.Table }
ArgsExchangeDelete stores args to amqp.Channel.ExchangeDelete() for middleware to inspect.
type ArgsExchangeDelete struct { Name string IfUnused bool NoWait bool }
ArgsExchangeUnbind stores args to amqp.Channel.ExchangeUnbind() for middleware to inspect.
type ArgsExchangeUnbind struct { Destination string Key string Source string NoWait bool Args streadway.Table }
ArgsFlow stores args to amqp.Channel.Flow() for middleware to inspect.
type ArgsFlow struct { Active bool }
ArgsGet stores args to amqp.Channel.Get() for middleware to inspect.
type ArgsGet struct { Queue string AutoAck bool }
ArgsNack stores args to amqp.Channel.Nack() for middleware to inspect.
type ArgsNack struct { Tag uint64 Multiple bool Requeue bool }
ArgsNotifyPublish stores args to amqp.Channel.NotifyPublish() for middleware to inspect.
type ArgsNotifyPublish struct { Confirm chan dataModels.Confirmation }
ArgsPublish stores args to amqp.Channel.Publish() for middleware to inspect.
type ArgsPublish struct { Exchange string Key string Mandatory bool Immediate bool Msg streadway.Publishing }
ArgsQoS stores args to amqp.Channel.QoS() for middleware to inspect.
type ArgsQoS struct { PrefetchCount int PrefetchSize int Global bool }
ArgsQueueBind stores args to amqp.Channel.QueueBind() for middleware to inspect.
type ArgsQueueBind struct { Name string Key string Exchange string NoWait bool Args streadway.Table }
ArgsQueueDeclare stores args to amqp.Channel.QueueDeclare() for middleware to inspect.
type ArgsQueueDeclare struct { Name string Durable bool AutoDelete bool Exclusive bool NoWait bool Args streadway.Table }
ArgsQueueDelete stores args to amqp.Channel.QueueDelete() for middleware to inspect.
type ArgsQueueDelete struct { Name string IfUnused bool IfEmpty bool NoWait bool }
ArgsQueueUnbind stores args to amqp.Channel.QueueUnbind() for middleware to inspect.
type ArgsQueueUnbind struct { Name string Key string Exchange string Args streadway.Table }
ArgsReject stores args to amqp.Channel.Reject() for middleware to inspect.
type ArgsReject struct { Tag uint64 Requeue bool }
Confirm defines signature for middleware invoked on *amqp.Channel.Confirm() call.
type Confirm func(next HandlerConfirm) HandlerConfirm
ConsumeEvent defines signature for middleware invoked on event processed during relay of *amqp.Channel.Consume() events.
type ConsumeEvent func(next HandlerConsumeEvent) HandlerConsumeEvent
EventConsume passes event information from a to amqp.Channel.Consume() event for middleware to inspect / modify before the event is passed to the caller.
type EventConsume struct { Delivery dataModels.Delivery }
EventNotifyPublish passes event information from a to amqp.Channel.NotifyPublish() event for middleware to inspect / modify before the event is passed to the caller.
type EventNotifyPublish struct { Confirmation dataModels.Confirmation }
ExchangeBind defines signature for middleware invoked on *amqp.Channel.ExchangeBind() call.
type ExchangeBind func(next HandlerExchangeBind) HandlerExchangeBind
ExchangeDeclare defines signature for middleware invoked on *amqp.Channel.ExchangeDeclare() call.
type ExchangeDeclare func(next HandlerExchangeDeclare) HandlerExchangeDeclare
ExchangeDelete defines signature for middleware invoked on *amqp.Channel.ExchangeDelete() call.
type ExchangeDelete func(next HandlerExchangeDelete) HandlerExchangeDelete
ExchangeUnbind defines signature for middleware invoked on *amqp.Channel.ExchangeUnbind() call.
type ExchangeUnbind func(next HandlerExchangeUnbind) HandlerExchangeUnbind
Flow defines signature for middleware invoked on *amqp.Channel.Flow() call.
type Flow func(next HandlerFlow) HandlerFlow
Get defines signature for middleware invoked on *amqp.Channel.Get() call.
type Get func(next HandlerGet) HandlerGet
HandlerAck: signature for handlers invoked when amqp.Channel.Ack() is called.
type HandlerAck func(args *ArgsAck) error
HandlerConfirm: signature for handlers invoked when amqp.Channel.Confirm() is called.
type HandlerConfirm func(args *ArgsConfirms) error
HandlerConsumeEvent: signature for handlers invoked when an event from a amqp.Channel.Consume() is being processed before beings sent to the caller.
type HandlerConsumeEvent func(event *EventConsume)
HandlerExchangeBind: signature for handlers invoked when amqp.Channel.ExchangeBind() is called.
type HandlerExchangeBind func(args *ArgsExchangeBind) error
HandlerExchangeDeclare: signature for handlers invoked when amqp.Channel.ExchangeDeclare() is called.
type HandlerExchangeDeclare = func(args *ArgsExchangeDeclare) error
HandlerExchangeDelete: signature for handlers invoked when amqp.Channel.ExchangeDelete() is called.
type HandlerExchangeDelete func(args *ArgsExchangeDelete) error
HandlerExchangeUnbind: signature for handlers invoked when amqp.Channel.ExchangeUnbind() is called.
type HandlerExchangeUnbind func(args *ArgsExchangeUnbind) error
HandlerFlow: signature for handlers invoked when amqp.Channel.Flow() is called.
type HandlerFlow func(args *ArgsFlow) error
HandlerGet: signature for handlers invoked when amqp.Channel.Get() is called.
type HandlerGet func(args *ArgsGet) (msg dataModels.Delivery, ok bool, err error)
HandlerNack: signature for handlers invoked when amqp.Channel.Nack() is called.
type HandlerNack func(args *ArgsNack) error
HandlerNotifyPublish: signature for handlers invoked when amqp.Channel.NotifyPublish() is called.
type HandlerNotifyPublish func(args *ArgsNotifyPublish) chan dataModels.Confirmation
HandlerNotifyPublishEvent: signature for handlers invoked when an event from a amqp.Channel.NotifyPublish() is being processed before beings sent to the caller.
type HandlerNotifyPublishEvent func(event *EventNotifyPublish)
HandlerPublish: signature for handlers invoked when amqp.Channel.Publish() is called.
type HandlerPublish func(args *ArgsPublish) error
HandlerQoS: signature for handlers invoked when amqp.Channel.QoS() is called.
type HandlerQoS func(args *ArgsQoS) error
HandlerQueueBind: signature for handlers invoked when amqp.Channel.QueueBind() is called.
type HandlerQueueBind = func(args *ArgsQueueBind) error
HandlerQueueDeclare: signature for handlers invoked when amqp.Channel.QueueDeclare() is called.
type HandlerQueueDeclare = func(args *ArgsQueueDeclare) (streadway.Queue, error)
HandlerQueueDelete: signature for handlers invoked when amqp.Channel.QueueDelete() is called.
type HandlerQueueDelete = func(args *ArgsQueueDelete) (count int, err error)
HandlerQueueUnbind: signature for handlers invoked when amqp.Channel.QueueUnbind() is called.
type HandlerQueueUnbind = func(args *ArgsQueueUnbind) error
HandlerReconnect: signature for handlers triggered when a channel is being re-established.
type HandlerReconnect = func( ctx context.Context, logger zerolog.Logger, ) (*streadway.Channel, error)
HandlerReject: signature for handlers invoked when amqp.Channel.Reject() is called.
type HandlerReject func(args *ArgsReject) error
Nack defines signature for middleware invoked on *amqp.Channel.Nack() call.
type Nack func(next HandlerNack) HandlerNack
NotifyPublish defines signature for middleware invoked on *amqp.Channel.NotifyPublish() call.
type NotifyPublish func(next HandlerNotifyPublish) HandlerNotifyPublish
NotifyPublishEvent defines signature for middleware invoked on event processed during relay of *amqp.Channel.NotifyPublish() events.
type NotifyPublishEvent func(next HandlerNotifyPublishEvent) HandlerNotifyPublishEvent
Publish defines signature for middleware invoked on *amqp.Channel.Publish() call.
type Publish func(next HandlerPublish) HandlerPublish
QoS defines signature for middleware invoked on *amqp.Channel.QoS() call.
type QoS func(next HandlerQoS) HandlerQoS
QueueBind defines signature for middleware invoked on *amqp.Channel.QueueBind() call.
type QueueBind = func(next HandlerQueueBind) HandlerQueueBind
QueueDeclare defines signature for middleware invoked on *amqp.Channel.QueueDeclare() call.
type QueueDeclare = func(next HandlerQueueDeclare) HandlerQueueDeclare
QueueDelete defines signature for middleware invoked on *amqp.Channel.QueueDelete() call.
type QueueDelete = func(next HandlerQueueDelete) HandlerQueueDelete
QueueUnbind defines signature for middleware invoked on *amqp.Channel.QueueUnbind() call.
type QueueUnbind = func(next HandlerQueueUnbind) HandlerQueueUnbind
Reconnect defines signature for middleware called on underlying channel reconnection event.
type Reconnect = func(next HandlerReconnect) HandlerReconnect
Reject defines signature for middleware invoked on *amqp.Channel.Reject() call.
type Reject func(next HandlerReject) HandlerReject


Practicing mindfulness
Doing everything possible to stay at <= 18% body fat
Playing long electric guitar solos from the 70s/80s
Learning to sketch
Reading a few books
Thanks Derek!


Hi! My name is Clovis Fritzen (Fritzen, Clovis), I am currently based in Brazil. Here you will find information about who I am, my previous works, my skills, my current work and where to find me.


Note
Click here to download the full example code
(advanced) PyTorch 1.0 Distributed Trainer with Amazon AWS¶
Author: Nathan Inkawhich
Edited by: Teng Li
In this tutorial we will show how to setup, code, and run a PyTorch 1.0 distributed trainer across two multi-gpu Amazon AWS nodes. We will start with describing the AWS setup, then the PyTorch environment configuration, and finally the code for the distributed trainer. Hopefully you will find that there is actually very little code change required to extend your current training code to a distributed application, and most of the work is in the one-time environment setup.
Amazon AWS Setup¶
In this tutorial we will run distributed training across two multi-gpu nodes. In this section we will first cover how to create the nodes, then how to setup the security group so the nodes can communicate with eachother.
Creating the Nodes¶
In Amazon AWS, there are seven steps to creating an instance. To get started, login and select Launch Instance.
Step 1: Choose an Amazon Machine Image (AMI) - Here we will select
the Deep Learning AMI (Ubuntu) Version 14.0
. As described, this
instance comes with many of the most popular deep learning frameworks
installed and is preconfigured with CUDA, cuDNN, and NCCL. It is a very
good starting point for this tutorial.
Step 2: Choose an Instance Type - Now, select the GPU compute unit
called p2.8xlarge
. Notice, each of these instances has a different
cost but this instance provides 8 NVIDIA Tesla K80 GPUs per node, and
provides a good architecture for multi-gpu distributed training.
Step 3: Configure Instance Details - The only setting to change here is increasing the Number of instances to 2. All other configurations may be left at default.
Step 4: Add Storage - Notice, by default these nodes do not come with a lot of storage (only 75 GB). For this tutorial, since we are only using the STL-10 dataset, this is plenty of storage. But, if you want to train on a larger dataset such as ImageNet, you will have to add much more storage just to fit the dataset and any trained models you wish to save.
Step 5: Add Tags - Nothing to be done here, just move on.
Step 6: Configure Security Group - This is a critical step in the configuration process. By default two nodes in the same security group would not be able to communicate in the distributed training setting. Here, we want to create a new security group for the two nodes to be in. However, we cannot finish configuring in this step. For now, just remember your new security group name (e.g. launch-wizard-12) then move on to Step 7.
Step 7: Review Instance Launch - Here, review the instance then launch it. By default, this will automatically start initializing the two instances. You can monitor the initialization progress from the dashboard.
Configure Security Group¶
Recall that we were not able to properly configure the security group when creating the instances. Once you have launched the instance, select the Network & Security > Security Groups tab in the EC2 dashboard. This will bring up a list of security groups you have access to. Select the new security group you created in Step 6 (i.e. launch-wizard-12), which will bring up tabs called Description, Inbound, Outbound, and Tags. First, select the Inbound tab and Edit to add a rule to allow “All Traffic” from “Sources” in the launch-wizard-12 security group. Then select the Outbound tab and do the exact same thing. Now, we have effectively allowed all Inbound and Outbound traffic of all types between nodes in the launch-wizard-12 security group.
Necessary Information¶
Before continuing, we must find and remember the IP addresses of both nodes. In the EC2 dashboard find your running instances. For both instances, write down the IPv4 Public IP and the Private IPs. For the remainder of the document, we will refer to these as the node0-publicIP, node0-privateIP, node1-publicIP, and node1-privateIP. The public IPs are the addresses we will use to SSH in, and the private IPs will be used for inter-node communication.
Environment Setup¶
The next critical step is the setup of each node. Unfortunately, we cannot configure both nodes at the same time, so this process must be done on each node separately. However, this is a one time setup, so once you have the nodes configured properly you will not have to reconfigure for future distributed training projects.
The first step, once logged onto the node, is to create a new conda environment with python 3.6 and numpy. Once created activate the environment.
$ conda create -n nightly_pt python=3.6 numpy
$ source activate nightly_pt
Next, we will install a nightly build of Cuda 9.0 enabled PyTorch with pip in the conda environment.
$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu90/torch_nightly.html
We must also install torchvision so we can use the torchvision model and dataset. At this time, we must build torchvision from source as the pip installation will by default install an old version of PyTorch on top of the nightly build we just installed.
$ cd
$ git clone https://github.com/pytorch/vision.git
$ cd vision
$ python setup.py install
And finally, VERY IMPORTANT step is to set the network interface
name for the NCCL socket. This is set with the environment variable
NCCL_SOCKET_IFNAME
. To get the correct name, run the ifconfig
command on the node and look at the interface name that corresponds to
the node’s privateIP (e.g. ens3). Then set the environment variable as
$ export NCCL_SOCKET_IFNAME=ens3
Remember, do this on both nodes. You may also consider adding the NCCL_SOCKET_IFNAME setting to your .bashrc. An important observation is that we did not setup a shared filesystem between the nodes. Therefore, each node will have to have a copy of the code and a copy of the datasets. For more information about setting up a shared network filesystem between nodes, see here.
Distributed Training Code¶
With the instances running and the environments setup we can now get into the training code. Most of the code here has been taken from the PyTorch ImageNet Example which also supports distributed training. This code provides a good starting point for a custom trainer as it has much of the boilerplate training loop, validation loop, and accuracy tracking functionality. However, you will notice that the argument parsing and other non-essential functions have been stripped out for simplicity.
In this example we will use torchvision.models.resnet18 model and will train it on the torchvision.datasets.STL10 dataset. To accomodate for the dimensionality mismatch of STL-10 with Resnet18, we will resize each image to 224x224 with a transform. Notice, the choice of model and dataset are orthogonal to the distributed training code, you may use any dataset and model you wish and the process is the same. Lets get started by first handling the imports and talking about some helper functions. Then we will define the train and test functions, which have been largely taken from the ImageNet Example. At the end, we will build the main part of the code which handles the distributed training setup. And finally, we will discuss how to actually run the code.
Imports¶
The important distributed training specific imports here are torch.nn.parallel, torch.distributed, torch.utils.data.distributed, and torch.multiprocessing. It is also important to set the multiprocessing start method to spawn or forkserver (only supported in Python 3), as the default is fork which may cause deadlocks when using multiple worker processes for dataloading.
import time
import sys
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.distributed as dist
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torchvision.models as models
from torch.multiprocessing import Pool, Process
Helper Functions¶
We must also define some helper functions and classes that will make
training easier. The AverageMeter
class tracks training statistics
like accuracy and iteration count. The accuracy
function computes
and returns the top-k accuracy of the model so we can track learning
progress. Both are provided for training convenience but neither are
distributed training specific.
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
Train Functions¶
To simplify the main loop, it is best to separate a training epoch step
into a function called train
. This function trains the input model
for one epoch of the train_loader. The only distributed training
artifact in this function is setting the
non_blocking
attributes of the data and label tensors to True
before the forward
pass. This allows asynchronous GPU copies of the data meaning transfers
can be overlapped with computation. This function also outputs training
statistics along the way so we can track progress throughout the epoch.
The other function to define here is adjust_learning_rate
, which
decays the initial learning rate at a fixed schedule. This is another
boilerplate trainer function that is useful to train accurate models.
def train(train_loader, model, criterion, optimizer, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to train mode
model.train()
end = time.time()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
# Create non_blocking tensors for distributed training
input = input.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# compute gradients in a backward pass
optimizer.zero_grad()
loss.backward()
# Call step of optimizer to update model params
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % 10 == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses, top1=top1, top5=top5))
def adjust_learning_rate(initial_lr, optimizer, epoch):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = initial_lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
Validation Function¶
To track generalization performance and simplify the main loop further
we can also extract the validation step into a function called
validate
. This function runs a full validation step of the input
model on the input validation dataloader and returns the top-1 accuracy
of the model on the validation set. Again, you will notice the only
distributed training feature here is setting non_blocking=True
for
the training data and labels before they are passed to the model.
def validate(val_loader, model, criterion):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
with torch.no_grad():
end = time.time()
for i, (input, target) in enumerate(val_loader):
input = input.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % 100 == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1, top5=top5))
print(' * Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'
.format(top1=top1, top5=top5))
return top1.avg
Inputs¶
With the helper functions out of the way, now we have reached the interesting part. Here is where we will define the inputs for the run. Some of the inputs are standard model training inputs such as batch size and number of training epochs, and some are specific to our distributed training task. The required inputs are:
batch_size - batch size for each process in the distributed training group. Total batch size across distributed model is batch_size*world_size
workers - number of worker processes used with the dataloaders in each process
num_epochs - total number of epochs to train for
starting_lr - starting learning rate for training
world_size - number of processes in the distributed training environment
dist_backend - backend to use for distributed training communication (i.e. NCCL, Gloo, MPI, etc.). In this tutorial, since we are using several multi-gpu nodes, NCCL is suggested.
dist_url - URL to specify the initialization method of the process group. This may contain the IP address and port of the rank0 process or be a non-existant file on a shared file system. Here, since we do not have a shared file system this will incorporate the node0-privateIP and the port on node0 to use.
print("Collect Inputs...")
# Batch Size for training and testing
batch_size = 32
# Number of additional worker processes for dataloading
workers = 2
# Number of epochs to train for
num_epochs = 2
# Starting Learning Rate
starting_lr = 0.1
# Number of distributed processes
world_size = 4
# Distributed backend type
dist_backend = 'nccl'
# Url used to setup distributed training
dist_url = "tcp://<IP_ADDRESS>:23456"
Initialize process group¶
One of the most important parts of distributed training in PyTorch is to
properly setup the process group, which is the first step in
initializing the torch.distributed
package. To do this, we will use
the torch.distributed.init_process_group
function which takes
several inputs. First, a backend input which specifies the backend to
use (i.e. NCCL, Gloo, MPI, etc.). An init_method input which is
either a url containing the address and port of the rank0 machine or a
path to a non-existant file on the shared file system. Note, to use the
file init_method, all machines must have access to the file, similarly
for the url method, all machines must be able to communicate on the
network so make sure to configure any firewalls and network settings to
accomodate. The init_process_group function also takes rank and
world_size arguments which specify the rank of this process when run
and the number of processes in the collective, respectively.
The init_method input can also be “env://”. In this case, the address
and port of the rank0 machine will be read from the following two
environment variables respectively: MASTER_ADDR, MASTER_PORT. If rank
and world_size arguments are not specified in the init_process_group
function, they both can be read from the following two environment
variables respectively as well: RANK, WORLD_SIZE.
Another important step, especially when each node has multiple gpus is to set the local_rank of this process. For example, if you have two nodes, each with 8 GPUs and you wish to train with all of them then \(world\_size=16\) and each node will have a process with local rank 0-7. This local_rank is used to set the device (i.e. which GPU to use) for the process and later used to set the device when creating a distributed data parallel model. It is also recommended to use NCCL backend in this hypothetical environment as NCCL is preferred for multi-gpu nodes.
print("Initialize Process Group...")
# Initialize Process Group
# v1 - init with url
dist.init_process_group(backend=dist_backend, init_method=dist_url, rank=int(sys.argv[1]), world_size=world_size)
# v2 - init with file
# dist.init_process_group(backend="nccl", init_method="file:///home/ubuntu/pt-distributed-tutorial/trainfile", rank=int(sys.argv[1]), world_size=world_size)
# v3 - init with environment variables
# dist.init_process_group(backend="nccl", init_method="env://", rank=int(sys.argv[1]), world_size=world_size)
# Establish Local Rank and set device on this node
local_rank = int(sys.argv[2])
dp_device_ids = [local_rank]
torch.cuda.set_device(local_rank)
Initialize Model¶
The next major step is to initialize the model to be trained. Here, we
will use a resnet18 model from torchvision.models
but any model may
be used. First, we initialize the model and place it in GPU memory.
Next, we make the model DistributedDataParallel
, which handles the
distribution of the data to and from the model and is critical for
distributed training. The DistributedDataParallel
module also
handles the averaging of gradients across the world, so we do not have
to explicitly average the gradients in the training step.
It is important to note that this is a blocking function, meaning program execution will wait at this function until world_size processes have joined the process group. Also, notice we pass our device ids list as a parameter which contains the local rank (i.e. GPU) we are using. Finally, we specify the loss function and optimizer to train the model with.
print("Initialize Model...")
# Construct Model
model = models.resnet18(pretrained=False).cuda()
# Make model DistributedDataParallel
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=dp_device_ids, output_device=local_rank)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), starting_lr, momentum=0.9, weight_decay=1e-4)
Initialize Dataloaders¶
The last step in preparation for the training is to specify which
dataset to use. Here we use the STL-10
dataset from
torchvision.datasets.STL10.
The STL10 dataset is a 10 class dataset of 96x96px color images. For use
with our model, we resize the images to 224x224px in the transform. One
distributed training specific item in this section is the use of the
DistributedSampler
for the training set, which is designed to be
used in conjunction with DistributedDataParallel
models. This object
handles the partitioning of the dataset across the distributed
environment so that not all models are training on the same subset of
data, which would be counterproductive. Finally, we create the
DataLoader
’s which are responsible for feeding the data to the
processes.
The STL-10 dataset will automatically download on the nodes if they are not present. If you wish to use your own dataset you should download the data, write your own dataset handler, and construct a dataloader for your dataset here.
print("Initialize Dataloaders...")
# Define the transform for the data. Notice, we must resize to 224x224 with this dataset and model.
transform = transforms.Compose(
[transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# Initialize Datasets. STL10 will automatically download if not present
trainset = datasets.STL10(root='./data', split='train', download=True, transform=transform)
valset = datasets.STL10(root='./data', split='test', download=True, transform=transform)
# Create DistributedSampler to handle distributing the dataset across nodes when training
# This can only be called after torch.distributed.init_process_group is called
train_sampler = torch.utils.data.distributed.DistributedSampler(trainset)
# Create the Dataloaders to feed data to the training and validation steps
train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=(train_sampler is None), num_workers=workers, pin_memory=False, sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=workers, pin_memory=False)
Training Loop¶
The last step is to define the training loop. We have already done most
of the work for setting up the distributed training so this is not
distributed training specific. The only detail is setting the current
epoch count in the DistributedSampler
, as the sampler shuffles the
data going to each process deterministically based on epoch. After
updating the sampler, the loop runs a full training epoch, runs a full
validation step then prints the performance of the current model against
the best performing model so far. After training for num_epochs, the
loop exits and the tutorial is complete. Notice, since this is an
exercise we are not saving models but one may wish to keep track of the
best performing model then save it at the end of training (see
here).
best_prec1 = 0
for epoch in range(num_epochs):
# Set epoch count for DistributedSampler
train_sampler.set_epoch(epoch)
# Adjust learning rate according to schedule
adjust_learning_rate(starting_lr, optimizer, epoch)
# train for one epoch
print("\nBegin Training Epoch {}".format(epoch+1))
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
print("Begin Validation @ Epoch {}".format(epoch+1))
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint if desired
# is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
print("Epoch Summary: ")
print("\tEpoch Accuracy: {}".format(prec1))
print("\tBest Accuracy: {}".format(best_prec1))
Running the Code¶
Unlike most of the other PyTorch tutorials, this code may not be run directly out of this notebook. To run, download the .py version of this file (or convert it using this) and upload a copy to both nodes. The astute reader would have noticed that we hardcoded the node0-privateIP and \(world\_size=4\) but input the rank and local_rank inputs as arg[1] and arg[2] command line arguments, respectively. Once uploaded, open two ssh terminals into each node.
On the first terminal for node0, run
$ python main.py 0 0
On the second terminal for node0 run
$ python main.py 1 1
On the first terminal for node1, run
$ python main.py 2 0
On the second terminal for node1 run
$ python main.py 3 1
The programs will start and wait after printing “Initialize Model…”
for all four processes to join the process group. Notice the first
argument is not repeated as this is the unique global rank of the
process. The second argument is repeated as that is the local rank of
the process running on the node. If you run nvidia-smi
on each node,
you will see two processes on each node, one running on GPU0 and one on
GPU1.
We have now completed the distributed training example! Hopefully you can see how you would use this tutorial to help train your own models on your own datasets, even if you are not using the exact same distributed envrionment. If you are using AWS, don’t forget to SHUT DOWN YOUR NODES if you are not using them or you may find an uncomfortably large bill at the end of the month.
Where to go next
Check out the launcher utility for a different way of kicking off the run
Check out the torch.multiprocessing.spawn utility for another easy way of kicking off multiple distributed processes. PyTorch ImageNet Example has it implemented and can demonstrate how to use it.
If possible, setup a NFS so you only need one copy of the dataset
Total running time of the script: ( 0 minutes 0.000 seconds)


import os.path as op
import mne
data_path = op.join(mne.datasets.sample.data_path(), 'MEG', 'sample')
raw = mne.io.read_raw_fif(op.join(data_path, 'sample_audvis_raw.fif'))
events = mne.read_events(op.join(data_path, 'sample_audvis_raw-eve.fif'))
picks = mne.pick_types(raw.info, meg='grad')
epochs = mne.Epochs(raw, events, [1, 2], picks=picks)
Out:
Opening raw data file /home/ubuntu/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...
Read a total of 3 projection items:
PCA-v1 (1 x 102) idle
PCA-v2 (1 x 102) idle
PCA-v3 (1 x 102) idle
Current compensation grade : 0
Range : 25800 ... 192599 = 42.956 ... 320.670 secs
Ready.
Adding average EEG reference projection.
1 projection items deactivated
145 matching events found
Applying baseline correction (mode: mean)
4 projection items activated
This tutorial focuses on visualization of epoched data. All of the functions introduced here are basically high level matplotlib functions with built in intelligence to work with epoched data. All the methods return a handle to matplotlib figure instance.
All plotting functions start with plot
. Let’s start with the most
obvious. mne.Epochs.plot()
offers an interactive browser that allows
rejection by hand when called in combination with a keyword block=True
.
This blocks the execution of the script until the browser window is closed.
epochs.plot(block=True)
Out:
Loading data for 145 events and 421 original time points ...
0 bad epochs dropped
Loading data for 20 events and 421 original time points ...
The numbers at the top refer to the event id of the epoch. We only have events with id numbers of 1 and 2 since we included only those when constructing the epochs.
Since we did no artifact correction or rejection, there are epochs contaminated with blinks and saccades. For instance, epoch number 9 (see numbering at the bottom) seems to be contaminated by a blink (scroll to the bottom to view the EOG channel). This epoch can be marked for rejection by clicking on top of the browser window. The epoch should turn red when you click it. This means that it will be dropped as the browser window is closed. You should check out help at the lower left corner of the window for more information about the interactive features.
To plot individual channels as an image, where you see all the epochs at one
glance, you can use function mne.Epochs.plot_image()
. It shows the
amplitude of the signal over all the epochs plus an average of the
activation.
epochs.plot_image(97)
# You also have functions for plotting channelwise information arranged into a
# shape of the channel array. The image plotting uses automatic scaling by
# default, but noisy channels and different channel types can cause the scaling
# to be a bit off. Here we define the limits by hand.
epochs.plot_topo_image(vmin=-200, vmax=200, title='ERF images')
Out:
Loading data for 145 events and 421 original time points ...
Loading data for 145 events and 421 original time points ...
Total running time of the script: (0 minutes 4.825 seconds)
plot_visualize_epochs.py
plot_visualize_epochs.ipynb


iArchives
Home
About
Contact
Upload
View
Dropdown
Action
Another action
Something else here
Separated link
{% block main %} {% endblock main %}


--- layout: page permalink: "/community-commissioned/voices/" ---
I was commissioned by Oxfordshire Theatre Company to respond visually to interviews made with people from rural Oxfordshire when questioned about the changing countryside. These same interviews formed the basis for a play written by their last Artistic Director Brendan Murray ‘The Falling Sky’, and performed during 2007.
Exhibition at Oxfordshire Museum, Oxfordshire ended April 2008.
June 2009, larger versions of 14 of the images are permanently
displayed at the new Churchill Cancer Hospital in Oxford.
village scene
next


Preparation time
over 2 hours
Cooking time
less than 10 mins
Serves
Serves 8
Dietary
Bananas, caramel, biscuit, cream - there's nothing to go wrong here. Easy banoffee pie is a great dessert for parties.
Make the biscuit base first. Melt the butter in a medium-sized pan. Put the biscuits into a food bag and crush with a rolling pin, or pulse them until fine in a food processor.
Tip the biscuit crumbs into the melted butter until evenly coated. Pour the mixture into the centre of a 23cm/9inch loose-bottomed tart tin. Then press the mixture firmly over the base of the tin and up the sides. Transfer the base to the fridge to chill for about 30 minutes, until firm.
While the base cools, make the caramel. Heat the brown sugar and butter together in a pan over a medium heat until the butter melts and the sugar has dissolved. At first the sugar and butter won’t mix, but keep stirring. As the sugar melts, it will come together.
Stir in the condensed milk and the sea salt flakes. Bring up to the boil, then take off the heat.
Take the set biscuit base out of the fridge and pour the caramel onto the biscuit base. Transfer to the fridge and leave to cool completely.
When ready to serve, slice the bananas and layer them over the set caramel. Pour the cream into a large bowl, and whip with electric hand beaters till thickened but not stiff. Spoon the cream over the bananas.
Grate the chocolate over the top of the pie.
Remove the pie from the tart tin, by placing the tin on top of an upturned bowl, then sliding the edge of the tin down. Move the bowl out of the way, then slide the banoffee pie off the tin base and onto a board or plate. It’s now ready to serve.


Winston is a normal citizien of Oceania, he is not strong nor handsome. He is in his middle 40s and he has a horrible ulcer at his foot. But he is a critical thinker. He doubts the government. Something that is very dangerous to do in Oceania
He has memories from before IngSoc took control in Britain and his knowledge of the specifically created language for oceania, Newspeak, makes him valuable for the Ministry of Truth.
Julia is a young blackhaired Woman. She is the love of Winstons life and she also loves him in the same manner. She also loves to break rules, not because she wants to rebel but because it thrills her. Her last name is never mentioned in the book
He is a member of the inner party and works with Julia and Winston at the Ministry of Truth. He is seen by Winston as someone with the same mindset as his own and Winston believes him to be part of the resistance.
The book is a dystopian novel which means that it is depicting a possible or impossible worst case scenario future. It was written as a warning for everyone to never let anything similar happen. The author took a lot of inspiration not only from Stalins Regime in Russia but also from Hitler, Mussolini and Franco and created in this book the perfect totalitarian system in which even the minds of the people could be controlled.
The effect the book had on me was as expected i think: I noticed the small things that are moving us towards a world like the one in the book. The cameras that are without us really noticing everywhere around us or the news we read, who are never really objective but always in some way biased
Click here to continue


--- layout: post status: publish published: true title: Cool Job Add author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 436 wordpress_url: http://winterdom.com/2003/07/cooljobadd date: '2003-07-03 19:59:43 +0000' date_gmt: '2003-07-03 19:59:43 +0000' categories: - ".NET" tags: [] comments: [] ---
You gotta love a job
add that starts with the line "Some of the ugliest code in the industry goes
through COM and COM+" :)


public class NativeCreative
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
java.util.List<Asset> |
assets
The assets that belong to this creative
|
java.lang.String |
callToAction |
java.util.Map<java.lang.Integer,Entity> |
dataMap
The data asset of this creative.
|
Asset |
img
The img asset of this creative
|
java.util.List<java.lang.String> |
imptrackers
The impression trackers used by this creative
|
Link |
link
The link asset for this creative
|
java.lang.Integer |
nativeAdType
The native ad type of this creative
|
Asset |
title
The title asset of this creative.
|
Asset |
video
The video asset of this creative.
|
| Constructor and Description |
|---|
NativeCreative()
An empty constructor for use by Jackson
|
| Modifier and Type | Method and Description |
|---|---|
void |
encode()
Pulls the image, video, link, and title assets out of the array and assigns them to objects.
|
java.lang.String |
getEncodedAdm(BidRequest br)
Create the encoded native ADM from the assets of the creative matches with the assets of the bid request.
|
public java.util.List<Asset> assets
public Link link
public java.util.List<java.lang.String> imptrackers
public java.lang.Integer nativeAdType
public transient java.util.Map<java.lang.Integer,Entity> dataMap
public transient Asset img
public transient Asset video
public transient Asset title
public transient java.lang.String callToAction
public void encode()
public java.lang.String getEncodedAdm(BidRequest br)
br
- BidRequest. The bid request of this transaction


Email
History
Settings
Subscription
SignOut
Edit Profile
First Name
Last Name
Instagram Acount
Phone
Username
Email
Update


Wayback Machine APIs
The Internet Archive Wayback Machine supports a number of different APIs to make it easier for developers to retrieve information about Wayback capture data.
The following is a listing of currently supported APIs. This page is subject to change frequently, please check back for the latest info.
Updated on September, 24, 2013Wayback Availability JSON API
This simple API for Wayback is a test to see if a given url is archived and currenlty accessible in the Wayback Machine. This API is useful for providing a 404 or other error handler which checks Wayback to see if it has an archived copy ready to display. The API can be used as follows:
http://archive.org/wayback/available?url=example.com
which might return:
{ "archived_snapshots": { "closest": { "available": true, "url": "http://web.archive.org/web/20130919044612/http://example.com/", "timestamp": "20130919044612", "status": "200" } } }
if the url is available. When available, the url is the link to the archived snapshot in the Wayback Machine At this time, archived_snapshots just returns a single closest snapshot, but additional snapshots may be added in the future.
If the url is not available (not archived or currently not accessible), the response will be:
{"archived_snapshots":{}}
Other Options
Additional options which may be specified are
timestamp
and
callback
-
timestamp
is the timestamp to look up in Wayback. If not specified, the most recenty available capture in Wayback is returned. The format of the timestamp is 1-14 digits (YYYYMMDDhhmmss) ex:
http://archive.org/wayback/available?url=example.com×tamp=20060101
may result in the following response (note that the snapshot timestamp is now close to 20060101):
{ "archived_snapshots": { "closest": { "available": true, "url": "http://web.archive.org/web/20060101064348/http://www.example.com:80/", "timestamp": "20060101064348", "status": "200" } } }
callback
is an optional callback which may be specified to produce a JSONP response.
Memento API
The Internet Archive Wayback Machine is also fully compliant with the Memento Protocol The Memento API provides additional interfaces for querying snapshots (eg 'Mementos') in the Wayback Machine. The Availability API is partially based on the Memento APIs.
Here are some specific examples of Memento support in the Wayback Machine
Wayback CDX Server API
The CDX Server is another API which allows for complex querying, filtering and analysis of Wayback capture data. If you are looking for more in depth information about Wayback machine data, please take a look at the CDX server API.
The latest documentation on the CDX server can be found at: Wayback CDX Server @ GitHub


Voter List Manager
Source Code:
https://github.com/kentarchie/cross-platform-coding-talk
Built With Versions:
Node:
Chrome:
Electron:


添加帐户
*
用户名:
*
密码:
*
电子邮件:
*
名字:
*
姓氏:
*
域:
帐户:
*
类型:
User
Admin
时区:
[UTC-12:00] GMT-12:00
[UTC-11:00] GMT-11:00
[UTC-11:00] Samoa Standard Time
[UTC-10:00] Hawaii Standard Time
[UTC-09:00] Alaska Standard Time
[UTC-08:00] Pacific Standard Time
[UTC-08:00] Baja California
[UTC-07:00] Arizona
[UTC-07:00] Mountain Standard Time
[UTC-07:00] Chihuahua, La Paz
[UTC-06:00] Central Standard Time
[UTC-06:00] Central America
[UTC-06:00] Mexico City, Monterrey
[UTC-06:00] Saskatchewan
[UTC-05:00] Bogota, Lima
[UTC-05:00] Eastern Standard Time
[UTC-04:00] Venezuela Time
[UTC-04:00] Paraguay Time
[UTC-04:00] Amazon Time
[UTC-04:00] Atlantic Standard Time
[UTC-04:00] Bolivia Time
[UTC-04:00] Chile Time
[UTC-03:30] Newfoundland Standard Time
[UTC-03:00] Brasilia Time
[UTC-03:00] Argentine Time
[UTC-03:00] French Guiana Time
[UTC-03:00] Greenland Time
[UTC-03:00] Uruguay Time]
[UTC-02:00] GMT-02:00
[UTC-01:00] Azores Time
[UTC-01:00] Cape Verde Time
[UTC] Casablanca
[UTC] Coordinated Universal Time
[UTC] Reykjavik
[UTC] Western European Time
[UTC+01:00] Central European Time
[UTC+02:00] Eastern European Time
[UTC+02:00] South Africa Standard Time
[UTC+02:00] Beirut
[UTC+02:00] Cairo
[UTC+02:00] Israel Standard Time
[UTC+02:00] Minsk
[UTC+03:00] Moscow Standard Time
[UTC+03:00] Eastern African Time
[UTC+05:00] Pakistan Time
[UTC+05:30] India Standard Time
[UTC+05:30] Indochina Time
[UTC+08:00] China Standard Time
[UTC+08:00] Malaysia Time
[UTC+08:00] Western Standard Time (Australia)
[UTC+08:00] Taiwan
[UTC+09:00] Japan Standard Time
[UTC+09:00] Korea Standard Time
[UTC+09:30] Central Standard Time (South Australia)
[UTC+09:30] Central Standard Time (Northern Territory)
[UTC+10:00] Eastern Standard Time (Queensland)
[UTC+10:00] Eastern Standard Time (New South Wales)
[UTC+10:00] Chamorro Standard Time
[UTC+12:00] New Zealand Standard Time
网络域:
添加域
*
域:


mindvisor
Mindvisor is a Yume Nikki fan-game about a girl named Rikotsura, who receives a prototype for a headset capable of granting users the ability to explore their dreams while conscious, and manipulate them through thoughts alone.
although exploring your subconscious and reliving memories might seem like a good idea at first, perhaps there are some things which are best left forgotten... or at least things you'd rather not think about.
the game is currently being worked on, and there are no plans to announce a release date as of now.


WASHINGTON SQUARE
A Film Review by James Berardinelli
RATING (0 TO 10): 7.5 Alternative Scale: *** out of ****
United States, 1997 U.S. Release Date: 10/17/97 (limited) Running Length: 1:55 MPAA Classification: PG (Mature themes, mild profanity) Theatrical Aspect Ratio: 1.85:1
Cast: Jennifer Jason Leigh, Albert Finney, Ben Chaplin, Maggie Smith Director: Agnieszka Holland Producers: Roger Birnbaum, Julie Bergman Sender Screenplay: Carol Doyle based on the novel by Henry James Cinematography: Jerzy Zielinski Music: Jan A.P. Kaczmarek U.S. Distributor: Hollywood Pictures
Love is supposed to be one of the most wonderful things known to humanity, and Hollywood has produced countless pictures that place it on the highest pedestal. But there is another kind of love -- a darker, uglier sort that rarely reaches the screen because the public, it is deemed, finds it too unpleasant. So, while most films are content to explore the lighter, romantic side of love, WASHINGTON SQUARE takes a cold, hard look at the painful, destructive aspect of the same emotion.
Two years ago, motion pictures enjoyed a flirtation with Jane Austen, adapting no less than four of her novels into major motion pictures and/or television mini-series. Last year, it was Shakespeare's turn. Now, in 1997, the classic author du jour appears to be Henry James. Within a twelve-month period, three of his novels have been adapted for the screen (PORTRAIT OF A LADY, WASHINGTON SQUARE, THE WINGS OF THE DOVE). Curiously, however, James' best-known works, THE TURN OF THE SCREW and THE GOLDEN BOWL, have not received new treatments, which leaves the door wide open for further exploration in the near future.
WASHINGTON SQUARE is actually the second film to be made from the James novel of the same name. The first, 1949's THE HEIRESS (directed by William Wyler and starring Olivia De Havilland, who won an Oscar for her role), was based on a stage play version of the book that eliminated many of the more subtle aspects of James' text. For this interpretation of WASHINGTON SQUARE, director Agnieszka Holland and screenwriter Carol Doyle have returned to James' original story and created a quiet, thoughtful examination of the author's favorite theme: the difficulty of balancing love and money, and the pernicious influence of the latter upon the former.
As WASHINGTON SQUARE opens, we are greeted with a tragic scene: a young woman lying dead in the aftermath of childbirth. Her husband, Austin Sloper (Albert Finney), barely looks at his newborn daughter, Catherine, as she is presented to him. Flash-forward several years. Catherine, an awkward adolescent, is shown trying to please her father on his birthday. But, despite her best efforts, everything goes wrong, and she is forced to flee from his party in embarrassment. When we next meet Catherine (now played by Jennifer Jason Leigh), she is an adult, but is still slavishly trying to win her father's adoration. However, in his characteristically brusque manner, he finds fault with nearly everything she does.
The domestic tranquillity of the Sloper household changes dramatically on the day that Catherine meets Morris Townsend (Ben Chaplin), an adventurer and wanderer who has just returned to America from abroad. Catherine falls in love with him, and, although he apparently returns her feelings, Austin is suspicious of his motives. Morris is penniless and Catherine is wealthy, and all Austin sees in the young man is a fortune hunter. He refuses to sanction a marriage and indicates that if Catherine defies him, he will disown her.
The crux of Catherine's dilemma isn't whether to surrender money for love -- that would be no choice, since physical pampering is largely unimportant to her. Instead, she must struggle with the consequences of giving up her father's love for her suitor's. Initially, she is unwilling (and perhaps unable) to go against her father's wishes. The real meat of WASHINGTON SQUARE focuses on Catherine's growth as an individual to the point where she can see that her father's feelings for her are not as pure as she once believed them to be. Jennifer Jason Leigh manages to capture the essence of Catherine by avoiding histrionics, finding the core of innocence that forms Catherine's center, and showing the inner strength that blossoms from it.
Austin could easily have become a black-and-white villain, but Finney's performance defies the audience's desire to label him as such. While many of Austin's actions are reprehensible, we understand that he is not just motivated by selfishness. There is a great wellspring of pain in his life -- a void left by the absence of a beloved wife whose death he blames on his daughter. And, although in one sense he resents Catherine, it is also clear that, in his own way, he loves her as well. Finney handles the complex motivations of his character expertly, creating a fascinating antagonist.
The third major character is the most ambiguous. WASHINGTON SQUARE keeps us guessing about Morris' real motivations. Is he truly in love with Catherine because she feeds his vanity and makes him feel "like the most important thing in the world"? Or is he, as Austin suspects, after her money, and an easy path to a pampered life? While Ben Chaplin's performance is not the equal of Leigh's or Finney's, he is solid enough not to give away the truth about Morris until the script reveals it.
Lest WASHINGTON SQUARE seem too serious and downbeat, there's always the character of Aunt Livinia (Maggie Smith) on hand to provide comic relief. Austin's sister, who has served as Catherine's surrogate mother, delivers many of the film's most witty lines, and her presence single-handedly keeps the tone gentler than one might otherwise expect. In part because of her, WASHINGTON SQUARE is considerably lighter than the other currently-available (and similarly-themed) James adaptation, THE WINGS OF THE DOVE.
The best thing about WASHINGTON SQUARE is that it draws us into the world of the characters and challenges us to understand them and question their views and motivations. The film is emotionally effective without going overboard. Director Agnieszka Holland (whose previous efforts include EUROPA EUROPA and OLIVIER OLIVIER) opts to avoid the temptation of reducing WASHINGTON SQUARE to the level of a costume melodrama. Her careful, modulated handling of the material makes this resemble Merchant-Ivory's better work (like THE REMAINS OF THE DAY). WASHINGTON SQUARE is faithful representation of James' text, and a moving and satisfying portrait of one woman's struggle for independence in a society where everything is defined by love, money, or both.
Copyright 1997 James Berardinelli
- James Berardinelli e-mail<EMAIL_ADDRESS>Now with more than 1300 reviews... The ReelViews web site: http://movie-reviews.colossus.net/
"For me, the cinema is not a slice of life, but a piece of cake."
- Alfred Hitchcock
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Multee
Hypotheses
Enter one hypothesis per line
Premises
Enter one permise per line
Predict
Run model to view results


Recent research
Research and development continues to refine the lighting, optics, sensors, processing, storage, display, and software used in digital photography. Here are a few examples:
- 3D models can be created from collections of normal images. The resulting scene can be viewed from novel viewpoints, but creating the model is very computationally intensive. An example is Microsoft's Photosynth, which provides some models of famous places as examples.
- Panoramic photographs can be created directly in camera without the need for any external processing. Some cameras feature a 3D Panorama capability, combining shots taken with a single lens from different angles to create a sense of depth.
- High dynamic range cameras and displays are commercially available. Sensors with dynamic range in excess of 1,000,000:1 are in development, and software is also available to combine multiple non-HDR images (shot with different exposures) into an HDR image.
- Motion blur can be dramatically removed by a flutter shutter (a flickering shutter that adds a signature to the blur, which postprocessing recognizes).[20] It is not yet commercially available.
- Advanced bokeh techniques use a hardware system of 2 sensors, one to take the photo as usual while the other records depth information. Bokeh effect and refocusing can then be applied to an image after the photo is taken.
- In advanced camera or camcorders, manipulating the sensitivity of the sensor not one, but 2 or more neutral density filters are available.
- An object's specular reflection can be captured using computer-controlled lights and sensors. This is needed to create attractive images of oil paintings, for instance. It is not yet commercially available, but some museums are starting to use it.
- Dust reduction systems help keep dust off of image sensors. Originally introduced only by a few cameras like Olympus DSLRs, have now become standard in most models and brands of detachable lens camera, except the low-end/cheap ones.
Other areas of progress include improved sensors, more powerful software, advanced camera processors (sometimes using more than one processor, e.g., the Canon 7d camera has 2 Digic 4 processors), enlarged gamut displays, built in GPS & WiFi, and computer-controlled lighting.


Folders
<parent>
insertion...roject
radix_sort_project
sorting
bubble_so...roject
merge_sort_project
selection...roject
Sorts
counting_...roject
quick_sort_project
Folders: 10


Geo Replication
Many architectures have streams of events deployed across multiple datacenters spanning boundaries of Event Streaming Platforms, datacenters, or geographical regions. In these situations, it may be useful for client applications in one event streaming platform to have access to Events produced in another one. All clients shouldn't be forced to read from the source event streaming platform, which can incur high latency and data egress costs. Instead, with a move-once-read-many approach, the data can be replicated to a local datacenter where clients can do all their processing quickly and cheaply.
Problem
How can multiple Event Streaming Platforms be connected so that events available in one site are also available on the others?
Solution
Create a connection between the two Event Streaming Platforms, enabling the destination platform to read from the source one. Ideally this is done in realtime such that as new events are published in the source event streaming platform, they can be immediately copied, byte for byte, to the destination event streaming platform. This allows the client applications in the destination to leverage the same set of data.
Implementation
Typically, replication is not enabled on all event streams in practice. There are always exceptions, organizational limitations, technical constraints, or other reasons why we wouldn't want to copy absolutely everything. Instead, we can do this on a per-stream basis, where we can map a source stream to a destination stream.
With Apache Kafka®, we can do this in one of several ways.
Option 1: Cluster Linking
Cluster Linking enables easy data sharing between event streaming platforms, mirroring Kafka topics (i.e., streams) across them. Because Cluster Linking uses native replication protocols, client applications can easily failover in the case of a disaster recovery scenario.
ccloud kafka link create east-west ...
ccloud kafka topic create <destination topic> --link east-west --mirror-topic <source topic> ...
Other messaging systems like RabbitMQ and ActiveMQ provide similar functionality, but without the same levels of parallelism.
Option 2: Connect-based Replication
Operators can set up inter-cluster data flows with Confluent's Replicator or Kafka's MirrorMaker (version 2), tools that replicate data between different Kafka environments. Unlike Cluster Linking, these are separate services built upon Kafka Connect, with built-in producers and consumers.
Considerations
Note that this type of replication between event streaming platforms is asynchronous, which means an event that is recorded in the source may not be immediately available at the destination. There is also synchronous replication across event streaming platforms (e.g. Multi Region Clusters) but this is often limited to when the event streaming platforms are in the same operational domain.
References
- This pattern is derived from Messaging Bridge in Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf