The Adventures of Huckleberry Finn
by Mark Twain
“Chapter 34”
Additional Information
- Year Published: 1884
- Language: English
- Country of Origin: United States of America
- Source: Twain, M. (1884). The Adventures of Huckleberry Finn Charles L. Webster And Company.
-
Readability:
- Flesch–Kincaid Level: 10.2
- Word Count: 2,512
- Genre: Adventure
- Keywords: 19th century literature, american literature, mark twain, samuel clemens, southern authors
- ✎ Cite This
Downloads
WE stopped talking, and got to thinking. By and by Tom says:
“Looky here, Huck, what fools we are to not think of it before! I bet I know where Jim is.”
“No! Where?”
“In that hut down by the ash-hopper. Why, looky here.  Well, it wasn’t for a dog.”
“Why?”
“Because part of it was watermelon.”
“So it was – I noticed it. Well, it does beat all that I never thought about a dog not eating watermelon. It shows how a body can see and don’t see at the same time.”
“Well, the nigger unlocked the padlock when he went in, and he locked it again when he came out. He fetched uncle a key about the time we got up from table – same key, I bet. Watermelon shows man, lock shows prisoner; and it ain’t likely there’s two prisoners on such a little plantation, and where the people’s all so kind and good. Jim’s the prisoner. All right – I’m glad we found it out detective fashion; I wouldn’t give shucks for any other way. Now you work your mind, and study out a plan to steal Jim, and I will study out one, too; and we’ll take the one we like the best.”
  I went to thinking out a plan, but only just to be doing something; I knowed very well where the right plan was going to come from. Pretty soon Tom says:
“Ready?”
“Yes,” I says.
“All right – bring it out.”
“My plan is this,” I says. “We can easy find out if it’s Jim in there. Then get up my canoe to-morrow night, and fetch my raft over from the island. Then the first dark night that comes steal the key out of the old man’s britches after he goes to bed, and shove off down the river on the raft with Jim, hiding daytimes and running nights, the way me and Jim used to do before. Wouldn’t that plan work?”
“WORK? Why, cert’nly it would work, like rats a-fighting. But it’s too blame’ simple; there ain’t nothing TO it. What’s the good of a plan that ain’t no more trouble than that? It’s as mild as goose-milk. Why, Huck, it wouldn’t make no more talk than breaking into a soap factory.”
I never said nothing, because I warn’t expecting nothing different; but I knowed mighty well that whenever he got HIS plan ready it wouldn’t have none of them objections to it.
And it didn’t. He told me what it was, and I see in a minute it was worth fifteen of mine for style, and would make Jim just as free a man as mine would, and maybe get us all killed besides. So I was satisfied, and said we would waltz in on it. I needn’t tell what it was here, because I knowed it wouldn’t stay the way, it was. I knowed he would be changing it around every which way as we went along, and heaving in new bullinesses wherever he got a chance. And that is what he done.
Well, one thing was dead sure, and that was that Tom Sawyer was in earnest, and was actuly going to help steal that nigger out of slavery. That was the thing that was too many for me. Here was a boy that was respectable and well brung up; and had a character to lose; and folks at home that had characters; and he was bright and not leather-headed; and knowing and not ignorant; and not mean, but kind; and yet here he was, without any more pride, or rightness, or feeling, than to stoop to this business, and make himself a shame, and his family a shame, before everybody. I COULDN’T understand it no way at all. It was outrageous, and I knowed I ought to just up and tell him so; and so be his true friend, and let him quit the thing right where he was and save himself.  Don’t I generly know what I’m about?”
“Yes.”
“Didn’t I SAY I was going to help steal the nigger?”
“Yes.”
“WELL, then.”
That’s all he said, and that’s all I said. It warn’t no use to say any more; because when he said he’d do a thing, he always done it. But I couldn’t make out how he was willing to go into this thing; so I just let it go, and never bothered no more about it. If he was bound to have it so, I couldn’t help it.
When we got home the house was all dark and still; so we went on down to the hut by the ash-hopper for to examine it. We went through the yard so as to see what the hounds would do. They knowed us, and didn’t make no more noise than country dogs is always doing when anything comes by in the night. When we got to the cabin we took a look at the front and the two sides; and on the side I warn’t acquainted with – which was the north side – we found a square windowhole, up tolerable high, with just one stout board nailed across it. I says:
“Here’s the ticket. This hole’s big enough for Jim to get through if we wrench off the board.”
Tom says:
“It’s as simple as tit-tat-toe, three-in-a-row, and as easy as playing hooky. I should HOPE we can find a way that’s a little more complicated than THAT, Huck Finn.”
“Well, then,” I says, “how ‘ll it do to saw him out, the way I done before I was murdered that time?”
“That’s more LIKE,” he says. “It’s real mysterious, and troublesome, and good,” he says; “but I bet we can find a way that’s twice as long. There ain’t no hurry; le’s keep on looking around.”
Betwixt the hut and the fence, on the back side, was a lean-to that joined the hut at the eaves, and was made out of plank. It was as long as the hut, but narrow – only about six foot wide. The door to it was at the south end, and was padlocked. Tom he went to the soap-kettle and searched around, and fetched back the iron thing they lift the lid with; so he took it and prized out one of the staples. The chain fell down, and we opened the door and went in, and shut it, and struck a match, and see the shed was only built against a cabin and hadn’t no connection with it; and there warn’t no floor to the shed, nor nothing in it but some old rusty played-out hoes and spades and picks and a crippled plow. The match went out, and so did we, and shoved in the staple again, and the door was locked as good as ever. Tom was joyful. He says;
“Now we’re all right. We’ll DIG him out. It ‘ll take about a week!”
Then we started for the house, and I went in the back door – you only have to pull a buckskin latchstring, they don’t fasten the doors – but that warn’t romantical enough for Tom Sawyer; no way would do him but he must climb up the lightning-rod. But after he got up half way about three times, and missed fire and fell every time, and the last time most busted his brains out, he thought he’d got to give it up; but after he was rested he allowed he would give her one more turn for luck, and this time he made the trip.
In the morning we was up at break of day, and down to the nigger cabins to pet the dogs and make friends with the nigger that fed Jim – if it WAS Jim that was being fed. The niggers was just getting through breakfast and starting for the fields; and Jim’s nigger was piling up a tin pan with bread and meat and things; and whilst the others was leaving, the key come from the house.
 That was to keep witches off. He said the witches was pestering him awful these nights, and making him see all kinds of strange things, and hear all kinds of strange words and noises, and he didn’t believe he was ever witched so long before in his life. He got so worked up, and got to running on so about his troubles, he forgot all about what he’d been a-going to do. So Tom says:
“What’s the vittles for? Going to feed the dogs?”
 Cur’us dog, too. Does you want to go en look at ‘im?”
“Yes.”
I hunched Tom, and whispers:
“You going, right here in the daybreak? THAT warn’t the plan.”
“No, it warn’t; but it’s the plan NOW.”
So, drat him, we went along, but I didn’t like it much. When we got in we couldn’t hardly see anything, it was so dark; but Jim was there, sure enough, and could see us; and he sings out:
“Why, HUCK! En good LAN’! ain’ dat Misto Tom?”
I just knowed how it would be; I just expected it. I didn’t know nothing to do; and if I had I couldn’t a done it, because that nigger busted in and says:
“Why, de gracious sakes! do he know you genlmen?”
We could see pretty well now. Tom he looked at the nigger, steady and kind of wondering, and says:
“Does WHO know us?”
“Why, dis-yer runaway nigger.”
“I don’t reckon he does; but what put that into your head?”
“What PUT it dar? Didn’ he jis’ dis minute sing out like he knowed you?”
Tom says, in a puzzled-up kind of way:
“Well, that’s mighty curious. WHO sung out? WHEN did he sing out? WHAT did he sing out?”
Of course there warn’t nothing to be said but the one thing; so I says:
“No; I ain’t heard nobody say nothing.”
Then he turns to Jim, and looks him over like he never see him before, and says:
“Did you sing out?”
“No, sah,” says Jim; ” I hain’t said nothing, sah.”
“Not a word?”
“No, sah, I hain’t said a word.”
“Did you ever see us before?”
“No, sah; not as I knows on.”
So Tom turns to the nigger, which was looking wild and distressed, and says, kind of severe:
“What do you reckon’s the matter with you, anyway? What made you think somebody sung out?”
“Oh, it’s de dad-blame’ witches, sah, en I wisht I was dead, I do. Dey’s awluz at it, sah, en dey do mos’ kill me, dey sk’yers me so. Please to don’t tell nobody ‘bout it sah, er ole Mars Silas he’ll scole me; ‘kase he say dey AIN’T no witches. I jis’ wish to goodness he was heah now – DEN what would he say! I jis’ bet he couldn’ fine no way to git aroun’ it DIS time.
Tom give him a dime, and said we wouldn’t tell nobody; and told him to buy some more thread to tie up his wool with; and then looks at Jim, and says:
“I wonder if Uncle Silas is going to hang this nigger.  And whilst the nigger stepped to the door to look at the dime and bite it to see if it was good, he whispers to Jim and says:
“Don’t ever let on to know us. And if you hear any digging going on nights, it’s us; we’re going to set you free.”
Jim only had time to grab us by the hand and squeeze it; then the nigger come back, and we said we’d come again some time if the nigger wanted us to; and he said he would, more particular if it was dark, because the witches went for him mostly in the dark, and it was good to have folks around then.


Stereotype threat is a psychological process wherein someone of a specific social identity underperforms for fear of acting out a stereotype. This can be accentuated by a lack of trust towards a group at large, the perceived stereotypers. Additionally, stereotype threat has a compounding effect by which a person disengages from a group at large (i.e. a profession, field or school) or "disidentifies" with their own identity group for fear of acting out the stereotype.
While I am lucky enough to not have been a direct victim of stereotype threat, I have suffered from the related "spotlight anxiety" or underperforming for fear of being judged. While not having to battle subconcious manifestations of racial or gender stereotypes, I can relate to this self-handicapping and sense of disappointment and resulting disilusionment. My experience has been in musical performance, and I have always asked myself, "What if I realy do lack the required talent?" or "What if I simply didn't prepare enough?" even though the poor examples of perforamance were almost always a case of mental self-sabotage.
Like in education, the tech sector needs to foster a culture of trust to alleviate some of the instances of stereotype threat. We need to stress a path of shared growth and learning rather than a competition and exhibition of ability/intelligence. I've already noticed this in paired programming exercises. Someone can always "show you want they know," whereas their nerves, or in many cases stereotype threat, can derail them when they are tested to perform.


{% extends "pages/homepage.html" %} {% block tickets %}
Tickets are sold out!
Workshop registration for PyCon CZ ticket holders will open on this website on Thursday, 24 May 20:00 CEST


MTC Axon Bank
Bank Accounts
Create
#
Balance
Overdraft Limit
{{bankAccount.axonBankAccountId}}
{{bankAccount.balance}}
{{bankAccount.overdraftLimit}}
Deposit
Withdraw
Transfer
Bank Transfers
There are no bank accounts


Year 2015
AngularJS best practices and design patterns, HTML & CSS Architecture, Build Automation, TDD, Code Organization and
building the complete DevOps pipeline. Also talks on Asynchronous Programming, Functional JavaScript, Reactive Programming with JavaScript
and ES6. Below is the link to 2015's Building Enterprise Web Applications with AngularJS event.
Building Enterprise Web Applications with AngularJS
Year 2014
2014 was the year of inception (Not the 2010 Nolan's Inception flick) for <web/F>.
Only event we conducted in 2014 was Front-end architecture.
We were trying to figure out bits and pieces of developer conference management.
Right from arranging water to selection of venue, everything was new.
We noted every possible feedback from our attendees and then laid track for the future of <web/F>.
It only makes sense that we dedicate an entire blog post for this.
Below is the link to 2014's Front-end architecture event.
Front-end architecture


Please login to access your music lists
There was an error! Please try your username and password again.
Username
Password
Submit


PSYCHO A film review by Steve Rhodes Copyright 1998 Steve Rhodes RATING (0 TO ****): **
Why?
Yes, that is the obvious question. Why would director Gus Van Sant want to reconstruct the Alfred Hitchcock classic from 1960, PSYCHO? And why, instead of reinterpreting it, did he actually recreate the film shot-by-shot with precisely the same timing and camera angles. He even arranged for his crew to shoot it on the same six-week schedule that Hitchcock used.
Van Sant has said that one of his motivations was to get inside the head of the great director, which presumably he now has.
The question is why -- other than curiosity -- would audiences want to see it? It is here that Van Sant provides no answers.
Whereas the original was fascinating and shocking, the reconstruction is bland and lifeless. The reconstruction could easily be summarized in a single word -- tedious.
The original movie starred Anthony Perkins as Norman Bates, the motel manager from Hell and Janet Leigh as the larcenous Marion Crane, his victim. The reconstruction is well cast but not well acted.
Vince Vaughn isn't particularly creepy as Norman Bates. He was much better as a psycho earlier this year in CLAY PIGEONS.
The normally emotive Anne Heche plays Marion Crane with facial expressions that border on blank slates. Heche delivers probably the weakest performance of her career.
To be fair, both actors may just have been following the director's instructions, but it is truly a shame to see such talent wasted.
And they aren't the only excellent actors to appear in the film. Also on hand are Julianne Moore as Marion's sister, Viggo Mortensen as Marion's boyfriend, William H. Macy as the private detective and Philip Baker Hall as the sheriff.
Are there ANY differences? Well, not many other than the obvious one of a switch to color from the black-and-white original. There are a few modest changes, but I'll let you discover them. Keeping your eye out for them is one of the few ways to pass the time while waiting for the movie to end.
One particularly infuriating semi-change is that the director can't make up his mind on the time period. He starts the movie by giving the year as 1998, but he constantly confuses things by putting in ridiculous looking take-offs on 1960s clothing and making the sets an eclectic mixture of the two periods.
Van Sant drains all of the lifeblood out of the story, just like Norman did on the animals in his taxidermy collection. The result is just as strange. Why one would want to see either dead animals or a dead movie is the mystery.
PSYCHO runs 1:45. It is rated R for violence, nudity and sex and would be fine for teenagers.
Email<EMAIL_ADDRESS>Web: www.InternetReviews.com
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


See: Description
| Package | Description |
|---|---|
| bench | |
| bench.gen |
The Message
Generator Utility
|
| Copyright (c) 2004-2011, Progress Software Corporation - All Rights Reserved.
Please see important License Information regarding this material. |
The Performance Bench is a Java class library designed to support simple, flexible load tests for SQL-based integration products. It is tested with MySQL, but should be compliant with any JDBC standard library. The package, including documentation and source code, is available without charge on an open source basis.
Documentation for individual Java Packages:
The Sonic Test Harness contains source, binaries and examples for several Java packages:
java -cp ./lib/test_harness.jar TestHarness -help
call setenv.bat
java TestHarness param1=val1 param2=val2 param3=val3
call setenv.bat
java TestHarness -props myPropertyFile.props
java TestHarness -props baseline.props,override.props
call setenv.bat
java TestHarness -prompt
java TestHarness -props test.props mode=pub
java TestHarness -props test.props mode=sub
Specify client mode (PUBlisher, SUBscriber, SENDer or RECeiver)
"?" - see a detailed description of the property
"X" - change the value of the property
"D" - revert to the default value for the property
"B" - go Back to the previous param
"Q" - quit entering params and continue test harness
Once the prompt sequence ends, you have the option of saving settings to a properties file. It may be worth going through the detailed help for each item once, to help you understand the options available. You can abort the test harness run at any time by simply hitting the <ctl-c> key; the only potential side effect of this is if test warmup or iteration runs have already started, in which case queues and durable subscribers may not be properly cleaned up.
Once the program is set up, you can
- props - example TestHarness properties files
- scripts - simple shell scripts invoking TestHarness
- templates - examples of processing instructions used by the text generator package and TemplateMsgGenerator
- First, using the jndiURL property to establish a connection to a JNDI service; this atttempt is skipped if you set "jndiurl=none"
- This performs a JNDI lookup for the JMSConnectionFactory object identified by the factoryName property (default factory name is "TestHarnessFactory")
- Authentication is performed using the user and password parameters
- Any parameters beginning with the prefix "jndi." are added to the JNDI properties for the call after stripping the prefix; for example test harness parameter jndi.com.sonicsw.jndi.mfcontext.domain is passed to the lookup as JNDI property com.sonicsw.jndi.mfcontext.domain
- If the JNDI lookup fails or is skipped, the ClientObj looks for a registered vendor extension, configured via the vendorext parameter; if one is found, the getConnectionFactory() method for that extension plugin is invoked to create the factory.
- The provided Sonic extension attempts to connect directly to a Sonic broker identified by parameter "sonic.url" (default value "tcp://localhost:2506")
- Note that a vendor extension may override an existing parameter's characteristics or define new parameters, which typically are prefixed with the vendor name.
- IT IS STRONGLY RECOMMENDED THAT YOU USE A NAMED JNDI CONNECTION:
- It will better document the use and function of the connection (e.g. if you use JNDI factory names like "ClusteredFTConnection")
- It will make scripts more uniform and portable
The key to running a successful load test is to carefully analyze the questions you need answered, then tailor your use
of the Sonic TestHarness to address these questions directly. For tests of a JMS messaging infrastructure, you should identify the
numbers of connections, producers and consumers, along with basic information about message size and send rate, then set up properties
files for each invocation of the test harness. You can run the various invocations in different windows, taking care to start consumers first
(to avoid lost messages) and to initiate test measurement in all windows as quickly as possible. For ESB tests, the content of the
message can be critical to performing a realistic simulation, particularly if content-based routing and transformation are key
elements of the test. You may find value in using the Sonic text generation utility to methodically vary message content, so that the
various routings and transformations are appropriately exercised.
Each test harness client will output the message rate being achieved at the end of each test iteration, so you can verify that uniform,
steady-state performance is being achieved. At the end, the program will print out:
Note that you can also append these statistics to a file (see below).
The behavior of a given TestHarness invocation depends broadly upon the values of individual test parameters. These include JMS behaviors, test run management and
custom parameters used for customized code or reports. Parameters are stored and managed within a singleton instance of the TestParams class,
which uses the nested TestParam class to manage individual paramater values. By default, the TestParams class uses a static initializer to
set up a parameter table with the following categories:
A given test client instance can run in only one domain (pubsub or point to point) and one role (producer or consumer). Thus you declare the purpose of the test instance by setting mode equal to pub (publisher), sub (subscriber), send (queue sender),or rec (queue receiver). To get mixed environments, you normally set up multiple windows, each with a distinct role.
This covers the definition of the JMS connections and sessions, which in turn determines the topology of the
test. The number of threads launched by the test instance is equal to the number of sessions
declared here. If istransacted is set true, then transacted sessions will be used, with message commit
performed at the appropriate point, indicated by the msgpertxnparam. The numdests param defines the number
of queues or topics, which are named by merging a unique destination number (ranging from 1 to numdests)
into the destination name defined by destname.
If the destname includes the "@" character, the destination number will be substituted for this
character, otherwise the number is appended to the destname string.
These parameters define the characteristics of the JMS Producer object (i.e. the publisher or
sender, depending on mode). You set message Quality of Service using the deliverymode and priority
parameters.
For more sophisticated tests, you can set the isreplyto param to 'true'. In this case, test harness will set the JMSReplyTo message
field to the specified destination and wait for a reply to come back. Make certain that there is an active JMS client out there (which can be
simulated by a test harness consumer with the "isforward" parameter set), otherwise the producer thread will wait for timeout after
each message. If the message times out, it will print a '.' to the console and continue. If you set isreplyto
and checklatency both true, the response time for the send/reply roundtrip will be reported.
Note that internal consumer used to receive the reply message will use all the consumer parameters specified for the test, including the ackmode and msgselector parameters. By default, the replyTo destination (the replytodest parameter) is set to "TempDest", which results in each session thread creating a temporary topic or queue for returned replies. If you use any other string, it will listen for replies on a permanent topic or queue. If the replytodest contains the '@' symbol in the string, the '@' will be replaced with the current Thread ID. This allows each thread to listen on a different permanent destination for replies. If you specify a msgselector, the same replacement of '@' with thread ID occurs, allowing you to have all threads listen on the same queue, but use message selectors to split the replies.
For SOA tests it can be important to introduce variation in the type and content of messages being sent. The msgtype
parameter allows you to select most of the JMS and Sonic-specific message types. You manipulate content by specifying a
MessageGenerator implementation, either one of the built-in options or a custom one of your own, using the msggenclass
parameter. You then set other message gen parameters to constrain the behavior. The ConstantMsgGenerator
simply creates a fixed message of the configured type and size and resends it multiple times. The FileMsgGenerator
uses the configured msgfiledir filesystem directory to input message data from flat files. The ObjectMsgGenerator
serializes objects of class objectmsgclass into Object messages (optionally initializing the object with current
message number). Finally, the TemplateMsgGenerator option generates unique content for each message based on an input
template file indicated by the template param. More details of the template message generator can be found in
the description of the com.progress.perf.gen package.
Message generators also know how to generate message properties. These are passed as properties files back to TestHarness, where they are applied to
individual messages. The message generator is passed the destination ID and the test iteration number (within thread) and these
can be encoded in message property values. For instance, the default implementation creates message properties from the msgproperties
parameter and then substitutes the destination ID for every occurance of the "@" character, and the iteration number for every occurance of the "#"
character. This lets you randomize message property content somewhat.
Since message generation can be expensive in certain cases, you
might want to minimize that overhead. Do this by setting the msgcache parameter to the number of
unique messages you want cached and sent. Each producer will resend this set in round-robin fashion.
For consumers, you specify the Quality of Service using the durable and ackmode parameters, and you
can optionally configure a JMS Message Selector by specifying a msgselector parameter string. Please note: If you do not want to use a
message selector, you must leave the msgselector param at the default value of 'none'. Also, note that if the message selector
contains the "@" sign anywhere, every instance of "@" will be replaced with the numeric thread ID. This allows you to set up message
selectors so that different consumer threads listen on different selectors.
For more sophisticated tests, you can specify that the incoming message be forwarded on to another destination, be setting the isforward
parameter to 'true'. In this case, all the Producer options, described above, now apply to the message that gets forwarded, including the
message generation specs. You can set forwarddest to a topic or queue name, or alternatively to 'UseReplyTo' in which case the new message
will be sent back to the JMSReplyTo destination. Note that the built-in Producer sending the reply will ignore the "isreplyto" parameter, i.e.
it will never expect a reply back from the reply message itself.
You can also capture a data set from the initial messages of a run, by setting the recordercount
parameter to the number of messages you want to capture, and the recorderdir param to the filesystem
location where you want the content dropped. This same directory can then be passed in to the FileMsgGenerator in subsequent test runs.
This includes parameters that impact test logistics and reporting. One important factor for constant-load tests is the sleepmsecs param, which specifies the time each thread should sleep between messages. You can use this to gain general control over the rate of message production or consumption, to better simulate the actual real-world load. You can also set the number and length for test intervals, and whether each test thread should immediate go into 'warmup' iterations upon launch, or alternatively to wait for the user to hit the 'enter' key before processing any messages. In either event, only those messages processed after you hit the 'enter' key to begin will be included in results. If you checklatency to 'true', the end-to-end and/or round-trip latency will be measured (exactly what depends on whether you are using the replyto and forward options). Note that if you are checking latency and test harness is running on multiple hosts, you must specify a clockhost computer, and on that computer you must launch the NetPing program, which will correct for flaws in clock synchronization. If you are running a non-constant message generator, you can ask test harness to track message size with the checkmsgsize param. Finally, if you specify a resultsfile file location, output from your test will be concatenated into that file for aggregate analysis. This output will include the values for throughput, optionally for latency and/or message size if tracked, and for any other parameter you specify in the variablelist parameter (including any custom properties). Thus you can append concurrent and sequential tests and use the variable list to uniquely identify each client and iteration. Then you can import the whole thing into excel for analysis.
This category defines how test harness will connect to the broker. You can specify a generic JNDI lookup,
which will allow you to run multi-vendor JMS tests, or you can enter
Sonic-specific broker connect URLs. While test harness was
designed to test against any JMS provider, specific connection options
are only defined for Sonic.
This includes any custom properties that you have added to the list. Custom properties can be referenced
in the variablelist report list, or used in custom message generators and other test harness
extensions. You can define custom properties by simply including them on the command line (e.g. java TestHarness hostname=godzilla),
putting them in an input properties file (using java TestHarness -props file) or extending the source code.
Messaging tests are often focused on measuring the steady state performance as high volumes of realtime messages are processed. To avoid artifacts resulting from the startup and initialization of the various clients and services, the test harness by default sets the doWarmup parameter to true, which means that test threads will start handling messages immediately upon launch, allowing the system to come up to speed. During the warmup interval, each producer will sleep for ProducerObj.STARTUP_SLEEP_MSECS after each send, preventing producers in warmup mode from overwhelming the system with incoming messages during this stage. Once the user hits the Enter key to begin test iterations, test harness begins measuring message throughput, latency and size, as specified. After each send or receive, Producers or Consumers will sleep as specified by the sleepMsecs parameter, prior to continuing.
Once the last interval is complete, the test harness signals all the session threads to cease measuring statistics, then pauses a little while (about 1/5 of the test interval time) to allow them to process the signal. Then it waits for processes to complete work, allowing subscribers additional time to deplete queues and durable subscriptions. These warmdown messages are not counted in the message statistics, but are included in the total message count. Thus, regardless of warmup and warmdown behavior, assuming you start Consumers before Producers, the total message count for Producers and Consumers should tally correctly.
In order to get meaningful, repeatable test results, you should check that queues and durable subscriptions are
cleared prior to the test and launch consumers prior to producers. This will avoid having the broker go into inefficient log operations and ensure that total
message counts add up. Note that test harness attempts to consume undelivered messages during the warmdown phase, assuming it isn't interrupted.
For each interval, TestHarness will print the throughput, in messages per second, and the message count for that interval. At the end of the test run, it will print the overall throughput and message count across all intervals, and the total message count for the run, including warmup and warmdown intervals. This latter is important, as it is the only way to verify that all messages sent by producers were, in fact, received by consumers.
Message latency will be measured within consumers if you set the checklatency test param 'true'. If you set isreplyto true, the producer will report the round-trip latency for the request/reply loop. For end-to-end tests, where producer and consumer are in different processes, the producer stores a timestamp as a message property, and the consumer that retrieves the message compares this with the current system time to compute message latency. This is commonly called end to end latency. At the end of the run, the average, minimum and maximum message latencies will be reported. For this measure to be meaningful, either both producer and consumer must be on the same system, or you must allow test harness to synchronize times by doing the following:
TestHarness will compute the time discrepancy and store a correction factor that will make timestamps comparable. Another issue in the accuracy of latency measurement is the precision of the system clock itself. In the current release of TestHarness, system time is measured with the System.currentTimeMillis() call, which on many platforms has a measurement granularity of 10 msecs or more.
If you set the checkmsgsize test param 'true', TestHarness will also try to measure message size. This too is measured at the receiving end (either replyto point or consumer), and may not precisely match the requested message size set by the msgsizekb param in the producer. The actual api used to measure message size varies with message type, and is defined in the ConsumerObj.getMessageSize() method. At the end of the run the consumer's TestHarness program will print the average, minimum and maximum message size encountered.
The core TestHarness program was designed to have a simple, extensible code base. As a result, it lacks the sophisticated
multi-host coordination features of SLAMD, Grinder, JUnit and other open source utilities.
As a simple alternative, we suggest opening a window for each TestHarness to be launched, using Telnet, pcAnywhere or VNC for remote
hosts. Invoke the test harness with appropriate properties files and/or param args in each window.
For simple tests, leave the starter param at the default value of 'prompt'. Once consumer windows display the "Press Enter key to start test intervals" message, hit <return> in all consumer windows, then immediately in the producer windows. We recommend setting the dowarmup param 'true' (the default), toensure reasonably accurate measurements of 'steady state' message throughput for the multihost test.
If you have many windows and want a more precise triggering of startup, set the start
param to 'topic'; then you can synchronize the start of iterations across all clients by simply publishing a message to the 'TestHarness.start'
topic on the same message broker used for the test. In this mode all test harness clients are waiting on a topic
receive for that message, so the degree of synchronization depends on the efficiency of the pub sub mechanism of the broker. The content of
the trigger message is irrelevant and you can use the Sonic JMS Test Client or similar tool to perform the send. Since no screen input
is required, this is also the preferred way of starting test harness clients that have been launched as background processes.
You can simply pipe the output of the TestHarness program to a file, and this is adequate for many needs, or you can instrument your test to append results to a comma-separated output file. This, in turn, is easily imported into a commercial spreadsheet for analysis purposes. To achieve this, simply:


{include file="Common/top" title="首页" metas='' /} {if condition="authority('ApplyCreate')"}
{include file="Common/progress"} {include file="Common/bottom" /} {include file="Common/calendar" /} {include file="Common/popup_warn" /} {include file="Common/popup_list" /} {include file="Common/calendar" /} {include file="Common/upload"} {else /}


Heroes
Our community are legendary charitable warriors, waging war against all that annoying stuff in our neighbourhoods. They can help an elderly relative with their shopping, fix your computer, or help tidy your area for free! Now that's a hero. Up for joining the ranks?
Become a heroVillains
Villains are pesky problems that need to be beaten to a pulp by our league of awesome community heroes! Maybe there's litter on a street near you, or an unruly garden that needs to be tamed? Our villains come in all shapes and sizes. Why not submit one today?
Report a villain Report a villain- Mighty Max


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Interface Summary | |
|---|---|
| WritableConverter<W extends Writable> | Extends LoadStoreCaster to add initialization and schema validation routines useful when dealing with conversion between Pig and Writable types. |
| Class Summary | |
|---|---|
| AbstractLazyTuple | |
| AbstractWritableConverter<W extends Writable> | Base class providing default implementations for WritableConverter methods. |
| GenericWritableConverter | Supports conversion between Pig bytearray (DataByteArray ) and an arbitrary
Writable implementation type. |
| IntWritableConverter | Supports conversion between Pig types and IntWritable . |
| LazyThriftWritableConverter<M extends TBase<?,?>> | Supports conversion between Pig Tuple and ThriftWritable types. |
| LoadFuncTupleIterator | Utility to simplify iteration over Tuples loaded by some LoadFunc . |
| LongWritableConverter | Supports conversion between Pig types and LongWritable . |
| LzoBufferedPositionedInputStream | A wrapper around Pig's BufferedPositionedInputStream that counts the number of compressed bytes read rather than the number of decompressed bytes read. |
| NullWritableConverter | Supports conversion from NullWritable to Pig null, and from all Pig types to NullWritable
. |
| PigCounterHelper | A helper class to deal with Hadoop counters in Pig. |
| PigTokenHelper | A helper class to deal with standard Pig tokens and delimiters. |
| PigToProtobuf | Converts a Pig Tuple into a Protobuf message. |
| PigToThrift<T extends TBase<?,?>> | Converts a Pig Tuple into a Thrift struct. |
| PigUtil | |
| ProjectedProtobufTupleFactory<M extends Message> | A tuple factory to create protobuf tuples where only a subset of fields are required. |
| ProjectedThriftTupleFactory<T extends TBase<?,?>> | A tuple factory to create thrift tuples where only a subset of fields are required. |
| ProtobufToPig | A class for turning codegen'd protos into Pig Tuples and Schemas for custom Pig LoadFuncs. |
| ProtobufTuple | |
| ProtobufWritableConverter<M extends Message> | Supports conversion between Pig Tuple and ProtobufWritable types. |
| ResourceSchemaUtil | Utilities for ResourceSchema and friends. |
| TextConverter | Supports conversion from Text to Pig chararray and numeric types, and from all Pig types to
Text via Object.toString() . |
| ThriftToPig<M extends TBase<?,?>> | converts a Thrift struct to a Pig tuple utilities to provide schema for Pig loaders and Pig scripts |
| ThriftWritableConverter<M extends TBase<?,?>> | Supports conversion between Pig Tuple and ThriftWritable types. |
| WritableLoadCaster<W extends Writable> | Base LoadCaster implementation which simplifies conversion specification from Writable type to Pig types. |
| WritableStoreCaster<W extends Writable> | Base LoadStoreCaster implementation which simplifies specification of conversion from Pig types to Writable type. |
| Enum Summary | |
|---|---|
| ProtobufToPig.CoercionLevel |
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Vehicle Detection and Speed Estimation
Estimating the speed of vehicles
Vehicle Count
Speed of Vehicle (km/h)
Image
Violation of Speed Limit (80 km/h)
{% for speed_path_tuple in speeds %}
{{loop.index}}
{{speed_path_tuple[0]}}
{% if speed_path_tuple[0] | int > 80 %}
{{"YES"}}
{% else %}
{{"NO"}}
{% endif %}
{% endfor %}


| Title | Author | Created | |
|---|---|---|---|
| {{ post.title }} | {{ post.author }} | {{ post.created }} |
You do not have currently have any posts, add a post.
{% endif %}| Title | Author | Created | |
|---|---|---|---|
| {{ post.title }} | {{ post.author }} | {{ post.created }} |
You do not have currently have any posts, add a post.
{% endif %}


Once you uploaded the WP-Stateless plugin, you will be redirected to Set up Assistant which will navigate you through all the 3 steps
Login with the Google Account you want to be associated with your website and consent to the permissions request.
Set up Google Cloud Project and Bucket names. By default we are creating new project and bucket for you
That's all. Try to upload something. Any media file you upload to WordPress will now be uploaded to Google Cloud Storage and served to your users from Google servers!
Now all image's links will go to Google Cloud Storage. You could also edit and regenerate single image.
You can also regenerate all your existing images


A blue Bar chart that has an offset X-axis but also has both
of the axes and
the background grid turned off. It has a title, subtitle,
labelsAbove
labels
and is using the wave()
animation effect. The
font size of the the text is a
little bit smaller than usual too.
 Put this where you want the chart to show up:

This is the code that generates the chart - it should be placed AFTER the

tag:


#mune
Photo Gallery
Pick your lens to view the album.
Or, click here to download all photos in a single click.
Pick your lens to view the album.
Or, click here to download all photos in a single click.


History Established in 2017, A small team which has fruitful experience, on Server Maintainence and Server Development Provide a stable atmosphere for east-asia players.


32 overrides of StopProcessing
Microsoft.Management.Infrastructure.CimCmdlets (1)
CimCommandBase.cs (1)
511
protected override void
StopProcessing
()
Microsoft.PowerShell.Commands.Diagnostics (1)
GetCounterCommand.cs (1)
226
protected override void
StopProcessing
()
Microsoft.PowerShell.Commands.Utility (11)
commands\utility\DebugRunspaceCommand.cs (1)
226
protected override void
StopProcessing
()
commands\utility\FormatAndOutput\OutGridView\OutGridViewCommand.cs (1)
201
protected override void
StopProcessing
()
commands\utility\ShowCommand\ShowCommand.cs (1)
255
protected override void
StopProcessing
()
commands\utility\StartSleepCommand.cs (1)
119
protected override void
StopProcessing
()
commands\utility\trace\TraceExpressionCommand.cs (1)
252
protected override void
StopProcessing
()
commands\utility\WaitEventCommand.cs (1)
110
protected override void
StopProcessing
()
commands\utility\WebCmdlet\Common\WebRequestPSCmdlet.Common.cs (1)
1637
protected override void
StopProcessing
()
commands\utility\WebCmdlet\ConvertToJsonCommand.cs (1)
159
protected override void
StopProcessing
()
commands\utility\XmlCommands.cs (3)
177
protected override void
StopProcessing
()
369
protected override void
StopProcessing
()
520
protected override void
StopProcessing
()
System.Management.Automation (19)
engine\InternalCommands.cs (1)
343
protected override void
StopProcessing
()
engine\Modules\GetModuleCommand.cs (1)
290
protected override void
StopProcessing
()
engine\Modules\ImportModuleCommand.cs (1)
1748
protected override void
StopProcessing
()
engine\remoting\commands\ConnectPSSession.cs (1)
467
protected override void
StopProcessing
()
engine\remoting\commands\DebugJob.cs (1)
195
protected override void
StopProcessing
()
engine\remoting\commands\DisconnectPSSession.cs (1)
320
protected override void
StopProcessing
()
engine\remoting\commands\EnterPSHostProcessCommand.cs (1)
212
protected override void
StopProcessing
()
engine\remoting\commands\getrunspacecommand.cs (1)
389
protected override void
StopProcessing
()
engine\remoting\commands\InvokeCommandCommand.cs (1)
1311
protected override void
StopProcessing
()
engine\remoting\commands\newrunspacecommand.cs (1)
354
protected override void
StopProcessing
()
engine\remoting\commands\PushRunspaceCommand.cs (1)
520
protected override void
StopProcessing
()
engine\remoting\commands\ReceiveJob.cs (1)
546
protected override void
StopProcessing
()
engine\remoting\commands\ReceivePSSession.cs (1)
395
protected override void
StopProcessing
()
engine\remoting\commands\RemoveJob.cs (1)
952
protected override void
StopProcessing
()
engine\remoting\commands\StopJob.cs (1)
203
protected override void
StopProcessing
()
engine\remoting\commands\WaitJob.cs (1)
292
protected override void
StopProcessing
()
engine\runtime\CompiledScriptBlock.cs (1)
2491
protected override void
StopProcessing
()
FormatAndOutput\common\BaseCommand.cs (1)
193
protected override void
StopProcessing
()
help\UpdatableHelpCommandBase.cs (1)
353
protected override void
StopProcessing
()
3 references to StopProcessing
System.Management.Automation (3)
engine\cmdlet.cs (1)
202
this.
StopProcessing
();
engine\remoting\commands\ReceiveJob.cs (1)
579
base.
StopProcessing
();
engine\runtime\CompiledScriptBlock.cs (1)
2494
base.
StopProcessing
();


Class implementation for stcamera_node.
More...
#include <stcamera_node.h>
|
| bool | getDeviceListCallback (omronsentech_camera::GetDeviceList::Request &req, omronsentech_camera::GetDeviceList::Response &res) |
| |
| bool | getGigEIPCallback (omronsentech_camera::GetGigEIPi::Request &req, omronsentech_camera::GetGigEIPi::Response &res) |
| |
| bool | getModuleListCallback (omronsentech_camera::GetModuleList::Request &req, omronsentech_camera::GetModuleList::Response &res) |
| |
| bool | getSDKInfoCallback (omronsentech_camera::GetSDKInfo::Request &req, omronsentech_camera::GetSDKInfo::Response &res) |
| |
| bool | initializeCamera (StApi::IStInterface *p_iface, const StApi::IStDeviceInfo *p_devinfo) |
| |
| bool | setGigEIPCallback (omronsentech_camera::SetGigEIPi::Request &req, omronsentech_camera::SetGigEIPi::Response &res) |
| |
|
| omronsentech_camera::DeviceConnection | fillDeviceConnectionData (const StApi::IStSystemInfo *p_tlinfo, StApi::IStInterface *p_iface, const StApi::IStDeviceInfo *p_devinfo, std::string device_namespace="", bool connected=false) |
| |
Class implementation for stcamera_node.
This class implements the stcamera_node.
Definition at line 64 of file stcamera_node.h.
| stcamera::StCameraNode::StCameraNode |
( |
| ) |
|
| stcamera::StCameraNode::StCameraNode |
( |
ros::NodeHandle |
nh | ) |
|
Constructor with parent node. This constructor is used by Nodelet.
- Parameters
-
Definition at line 80 of file stcamera_node.cpp.
| stcamera::StCameraNode::~StCameraNode |
( |
| ) |
|
|
virtual |
| omronsentech_camera::DeviceConnection stcamera::StCameraNode::fillDeviceConnectionData |
( |
const StApi::IStSystemInfo * |
p_tlinfo, |
|
|
StApi::IStInterface * |
p_iface, |
|
|
const StApi::IStDeviceInfo * |
p_devinfo, |
|
|
std::string |
device_namespace = "" , |
|
|
bool |
connected = false |
|
) |
| |
|
private |
Helper function to fill the structure of DeviceConnection.
- Parameters
-
| [in] | p_tlinfo | Pointer to the IStSystemInfo of the device. |
| [in] | p_iface | Pointer to the IStInterface of the device. |
| [in] | p_devinfo | Pointer to the IStDeviceInfo of the device. |
| [in] | device_namespace | Namespace of the device. |
| [in] | connected | whether the device is connected or not. |
- Returns
- Filled DeviceConnection.
Definition at line 567 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::getDeviceListCallback |
( |
omronsentech_camera::GetDeviceList::Request & |
req, |
|
|
omronsentech_camera::GetDeviceList::Response & |
res |
|
) |
| |
|
protected |
ROS service callback for obtaining list of all detected devices including the disallowed camera to connect.
- Parameters
-
| [in] | req | ROS service request |
| [out] | res | ROS service response |
- Returns
- Always true.
Definition at line 359 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::getGigEIPCallback |
( |
omronsentech_camera::GetGigEIPi::Request & |
req, |
|
|
omronsentech_camera::GetGigEIPi::Response & |
res |
|
) |
| |
|
protected |
ROS service callback for obtaining IP address information of the given GigEVision camera which is not opened yet.
- Parameters
-
| [in] | req | ROS service request |
| [out] | res | ROS service response |
- Returns
- True on success. False on failure.
Definition at line 446 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::getModuleListCallback |
( |
omronsentech_camera::GetModuleList::Request & |
req, |
|
|
omronsentech_camera::GetModuleList::Response & |
res |
|
) |
| |
|
protected |
ROS service callback for obtaining all module name: System, Interface, LocalDevice, RemoteDevice, DataStream.
- Parameters
-
| [in] | req | ROS service request |
| [out] | res | ROS service response |
- Returns
- Always true.
Definition at line 408 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::getSDKInfoCallback |
( |
omronsentech_camera::GetSDKInfo::Request & |
req, |
|
|
omronsentech_camera::GetSDKInfo::Response & |
res |
|
) |
| |
|
protected |
ROS service callback for obtaining SentechSDK and GenTL information.
- Parameters
-
| [in] | req | ROS service request |
| [out] | res | ROS service response |
- Returns
- Always true.
Definition at line 422 of file stcamera_node.cpp.
| void stcamera::StCameraNode::init |
( |
| ) |
|
|
virtual |
Initialization. This function is called by constructor. In the initialization, list of allowed camera to connect is retrieved and the GenTL modules are initialized.
Definition at line 118 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::initializeCamera |
( |
StApi::IStInterface * |
p_iface, |
|
|
const StApi::IStDeviceInfo * |
p_devinfo |
|
) |
| |
|
protected |
Function to initialize a camera. In this function, whether connection to the given camera is allowed will be checked.
- Parameters
-
| [in] | p_iface | Pointer to the IStInterface of the camera. |
| [in] | p_devinfo | Pointer to the IStDeviceInfo of the device. |
- Returns
- True if the camera is successfully initialized. False otherwise.
Definition at line 268 of file stcamera_node.cpp.
| bool stcamera::StCameraNode::setGigEIPCallback |
( |
omronsentech_camera::SetGigEIPi::Request & |
req, |
|
|
omronsentech_camera::SetGigEIPi::Response & |
res |
|
) |
| |
|
protected |
ROS service callback for assigning IP address to the given GigEVision camera which is not opened yet.
- Parameters
-
| [in] | req | ROS service request |
| [out] | res | ROS service response |
- Returns
- True on success. False on failure.
Definition at line 509 of file stcamera_node.cpp.
| void stcamera::StCameraNode::spin |
( |
| ) |
|
|
virtual |
Function called inside process loop. In this function, device availability is checked. Any device lost will be announced through device_connection topic. Any new found device will be processed through calling initializeCamera() .
Definition at line 174 of file stcamera_node.cpp.
Store the list of allowed camera or connected camera and the corresponding instances.
Definition at line 160 of file stcamera_node.h.
Store the list of all detected camera (including disallowed to connect) and the camera information.
Definition at line 164 of file stcamera_node.h.
| ros::Publisher stcamera::StCameraNode::msg_device_connection_ |
|
protected |
Publisher for announcing any device lost or newly found device that is allowed to connect.
Definition at line 171 of file stcamera_node.h.
| std::mutex stcamera::StCameraNode::mtx_map_camera_ |
|
private |
Guard to prevent race when accessing map_camera_.
Definition at line 211 of file stcamera_node.h.
| std::mutex stcamera::StCameraNode::mtx_update_device_list_ |
|
private |
Guard to prevent race when looking for new devices.
Definition at line 208 of file stcamera_node.h.
| ros::NodeHandle stcamera::StCameraNode::nh_ |
|
protected |
| ros::ServiceServer stcamera::StCameraNode::srv_get_device_list_ |
|
protected |
| ros::ServiceServer stcamera::StCameraNode::srv_get_gige_ip_i_ |
|
protected |
| ros::ServiceServer stcamera::StCameraNode::srv_get_module_list_ |
|
protected |
| ros::ServiceServer stcamera::StCameraNode::srv_get_sdk_info_ |
|
protected |
| ros::ServiceServer stcamera::StCameraNode::srv_set_gige_ip_i_ |
|
protected |
| StApi::CStApiAutoInit stcamera::StCameraNode::stapi_autoinit_ |
|
protected |
Variable for auto initialization of SentechSDK
Definition at line 185 of file stcamera_node.h.
| StApi::CIStSystemPtrArray stcamera::StCameraNode::stapi_systems_ |
|
protected |
List of GenTL instances used by SentechSDK
Definition at line 188 of file stcamera_node.h.
The documentation for this class was generated from the following files:


'It's a level playing field except that they've got the home tie' - McCarthy
The Ireland manager expects the Euro 2020 play-off semi-final with Slovakia to be a ‘difficult game’.
by Ben BlakeSO IRELAND WILL need to win two games on the road to qualify for a European championships played on home soil.
First up for the Boys in Green is a trip to Slovakia on Thursday, 26 March, with the venue yet to be announced.
If Mick McCarthy’s side progress through that, either Northern Ireland or Bosnia-Herzegovina await in the Euro 2020 play-off final on Tuesday, 31 March.
The likelihood is that would either be hosted by the Stadion Bilino Polje in Zenica or Windsor Park.
Speaking about the semi-final tie with Slovakia, who finished third in their group behind Croatia and Wales, the Ireland boss believes there will be little between the teams.
“It’ll be a difficult game, no doubt,” McCarthy told FAI TV before this morning’s draw.
“People have said to me ‘well, you’ll be playing one of the poorer sides and one of third teams in the group’. I said ‘yeah, exactly like us’. That’s where we are, so I think it’s a level playing field except that they’ve got the home tie.
 It will have an influence, but whether that is such a big influence or not, we’ll see.”
“I want to be in the Euro finals, I want to take the team there and the players want to get there,” he added. “There’s more pressure for all of us — me, the players, the staff — because we’ve got these games in Dublin if we qualify, so that heaps the pressure.”


iOS 6 beta hands-on I had a chance to try Apple’s new iOS 6 beta software on my iPhone. Here’s some quick hands-on review. Overall, it doesn’t seem as buggy as when Apple releas...
Barker Shoes 한국 공식 웹사이트 오픈 Barker Shoes 한국 공식 웹사이트가 오늘 오픈하였네요. 바커는 130년 전통의 영국 수제화 브랜드입니다. 오랜 노하우를 바탕으로 숙련된 장인이 직접 가죽손질부터 박음질까지 한땀한땀 제작한다고 합니다. 다른 브랜드와는 달리 구두만 주구장창 만들어왔다니 믿음이 가네요. 앞으로...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
Exporting Plink Result to Excel File Here’s a little tip using plink software. A lot of people might already know this and this might be “the way” to use this software, but I never knew about th...
Barker Shoes 한국 공식 웹사이트 오픈 Barker Shoes 한국 공식 웹사이트가 오늘 오픈하였네요. 바커는 130년 전통의 영국 수제화 브랜드입니다. 오랜 노하우를 바탕으로 숙련된 장인이 직접 가죽손질부터 박음질까지 한땀한땀 제작한다고 합니다. 다른 브랜드와는 달리 구두만 주구장창 만들어왔다니 믿음이 가네요. 앞으로...
Exporting Plink Result to Excel File Here’s a little tip using plink software. A lot of people might already know this and this might be “the way” to use this software, but I never knew about th...
WordPress Fix for GoDaddy Free Account If you install WordPress on GoDaddy’s free web hosting account, your CSS on dashboard gets all messed up. GoDaddy.com injects ad code on every page they proc...
Exporting Plink Result to Excel File Here’s a little tip using plink software. A lot of people might already know this and this might be “the way” to use this software, but I never knew about th...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
Exporting Plink Result to Excel File Here’s a little tip using plink software. A lot of people might already know this and this might be “the way” to use this software, but I never knew about th...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
Barker Shoes 한국 공식 웹사이트 오픈 Barker Shoes 한국 공식 웹사이트가 오늘 오픈하였네요. 바커는 130년 전통의 영국 수제화 브랜드입니다. 오랜 노하우를 바탕으로 숙련된 장인이 직접 가죽손질부터 박음질까지 한땀한땀 제작한다고 합니다. 다른 브랜드와는 달리 구두만 주구장창 만들어왔다니 믿음이 가네요. 앞으로...
WordPress Fix for GoDaddy Free Account If you install WordPress on GoDaddy’s free web hosting account, your CSS on dashboard gets all messed up. GoDaddy.com injects ad code on every page they proc...
How to install Caffe on Mac OS X 10.10 for dummies (like me) Update: The instruction is also available in Chinese. I’d like to thank panovr for providing Chinese translation. (http://ylzhao.blogspot.com/2015/04/mac-os-...
iOS 6 beta hands-on I had a chance to try Apple’s new iOS 6 beta software on my iPhone. Here’s some quick hands-on review. Overall, it doesn’t seem as buggy as when Apple releas...
iOS 6 beta hands-on I had a chance to try Apple’s new iOS 6 beta software on my iPhone. Here’s some quick hands-on review. Overall, it doesn’t seem as buggy as when Apple releas...


dataset is designed to easily manage collections of JSON documents. A JSON object is associated with a unique key you provide. If you are using the default storage engine the objects themselves are stored on disc in a folder inside the collection folder. If you are using a SQL storage engine they are stored in a column of a table of the collection in your SQL database.
The collection folder contains a JSON object document called collection.json. This file stores operational metadata about the collection. If the collection is using a pairtree then a keymap.json file will include the association of keys with paths to their objects. When a collection is initialized a minimal codemeta.json file will created describing the collection. This can be update to a full codemeta.json file, follow the guideline and practice described at the codemeta website.
dataset comes in several flavors — a command line program called dataset, a web service called datasetd and the Go language package used to build for programs.
This tutorial talks both the command line program and the Go package. The command line is great for simple setup, the Go package allows you to build on other programs that use dataset collections for content persistence.
To create a collection you use the init verb. In the following examples you will see how to do this with both the command line tool dataset as well as the Python module of the same name.
Let's create a collection called friends.ds. At the command line type the following.
dataset init friends.ds
Notice that after you typed this and press enter you see an "OK" response. If there had been an error then you would have seen an error message instead.
Working in Go is similar. We use the dataset.Init()
func
to create our new collection. We can import the “dataset” package using
the import line "github.com/caltechlibrary/dataset"
. Here’s
a general code sketch.
import (
// import the packages your program needs ...
"fmt"
"os"
// import dataset
"github.com/caltechlibrary/dataset"
)
func main() {
// The dataset collection is held in 'c'
// This create the collection "friends.ds"
collectionName := "frieds.ds"
// "c" is a handle to the collection
c, err := dataset.init(collectionName)
if err != nil {
fmt.Fprintf(os.Stderr, "Something went wrong, %s\n", err)
os.Exit(1)
}
defer c.Close() // Remember to close your collection
fmt.Printf("Created %q, ready to use\n", collectionName)
}
In this Go example if the error is nil a statement is written to standard out saying the collection was created, if not an error is shown.
There is no dataset verb to remove a collection. A collection is just a folder with some files in it. You can delete the collection by throwing the folder in the trash (Mac OS X and Windows) or using a recursive remove in the Unix shell.
rm -fR friends.ds
Or using os.RemoveAll()
in Go programs.
if _, err := os.Stat(collectionName); err == nil {
os.RemoveAll(collectionName)
}
As with many systems that store information dataset provides for basic operations of creating, updating and deleting. In the following section we will work with the friends.ds collection and favorites.ds collection we created previously.
I have some friends who are characters in ZBS radio plays. I am going to create and save some of their info in our collection called friends.ds. I am going to store their name and email address so I can contact them. Their names are Little Frieda, Mojo Sam and Jack Flanders.
dataset create friends.ds frieda \
'{"name":"Little<EMAIL_ADDRESS>Notice the "OK". Just like init the create verb returns a status. "OK" means everything is good, otherwise an error is shown.
Doing the same thing in Go would look like. Note we have to
explicitly Open()
the collection to get a collection object
then call Create()
on the opened collection.
defer
make it easy for us to remember to close the
collection when we’re done.
import (
"fmt"
"os"
"github.com/caltechlibrary/dataset"
)
func main() {
c, err := dataset.Open("fiends.ds")
if err != nil {
fmt.Fprintf(os.Stderr, "something went wrong, %s", err)
os.Exit(1)
}
defer c.Close() // Don't forget to close the collection
id := "frieda"
m := map[string]interface{}{
"id": id,
"name":"Little Frieda",
<EMAIL_ADDRESS>}
// Create adds a map[string]interface{} to the collection.
if err := dataset.Create(id, m); err != nil {
fmt.Fprintf(os.Stderr, "%s",err)
os.Exit(1)
}
fmt.Printf("OK")
os.Exit(0)
}
Go supports easy translation of struct types into JSON encoded byte
slices. Can then use that store the JSON representations using the
CreateObject()
to create a JSON object from any Go
type.
import (
"encoding/json"
"fmt"
"os"
"github.com/caltechlibrary/dataset"
)
type Record struct {
ID string `json:"id"`
Name string `json:"name,omitempty"`
EMail string `json:"email,omitempty"`
}
func main() {
obj := &Record{
ID: "frieda",
Name: "Little Fieda",
EMail<EMAIL_ADDRESS>}
if err := dataset.CreateObject("friends.ds", obj.ID, obj); err != nil {
fmt.Fprintf(os.Stderr, "%s", err)
os.Exit(1)
}
fmt.Printf("OK")
os.Exit(0)
}
On the command line create requires us to provide a collection name, a key (e.g. "frieda") and JSON markup to store the JSON object. We can provide that either through the command line or by reading in a file or standard input.
command line --
cat <<EOT >mojo.json
{
"id": "mojo",
"name": "Mojo Sam, the Yudoo Man",
"email"<EMAIL_ADDRESS>}
EOT
cat mojo.json | dataset create friends.ds "mojo"
cat <<EOT >jack.json
{
"id": "jack",
"name": "Jack Flanders",
"email"<EMAIL_ADDRESS>EOT
dataset create -i jack.json friends.ds "jack"
in Go we can loop through records easily and add them --
// Open the collection
c, err := dataset.Open("friends.ds")
if err != nil {
...
}
defer c.Close()// Don't forget to close the collection
// Create some new records
newRecords := []Record{
Record{
ID: "mojo",
Name: "Mojo Sam",
EMail<EMAIL_ADDRESS>},
Record{
ID: "jack",
Name: "Jack Flanders",
Email<EMAIL_ADDRESS>},
}
// Save the new records into the collection
for _, record := range newRecords {
if err := dataset.CreateObject(record.ID, record); err != nil {
fmt.Fprintf(os.Stderr,
"something went wrong add %q, %s\n", record.ID, key)
}
}
We have three records in our friends.ds collection — "frieda", "mojo", and "jack". Let's see what they look like with the read verb.
command line --
dataset read friends.ds frieda
On the command line you can easily pipe the results to a file for latter modification. Let's do this for each of the records we have created so far.
dataset read -p friends.ds frieda >frieda-profile.json
dataset read -p friends.ds mojo >mojo-profile.json
dataset read -p friends.ds jack >jack-profile.json
Working in Go is similar but rather than write out our JSON structures to a file we're going to keep them in memory as an array of record structs before converting to JSON and writing it out.
In Go --
// Open our collection
c, err := dataset.Open("friends.ds")
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
defer c.Close() // remember to close the collection
// build our list of keys
keys := []string{ "frieda", "mojo", "jack" }
records := []*Record{}
// loop through the list and write the JSON source to file.
for _, key := range keys {
obj := &Record{}
if err := c.ReadObject(key, &obj); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
records = append(records, obj)
}
src, _ := json.MarshalIndent(records)
fmt.Println("%s\n", src)
os.Exit(0)
Next we can modify the profiles (the *.json files for the command line version). We're going to add a key/value pair for "catch_phrase" associated with each JSON object in friends.ds. For Little Frieda edit freida-profile.json to look like --
{
"_Key": "frieda",
"email"<EMAIL_ADDRESS>"name": "Little Frieda",
"catch_phrase": "Woweee Zoweee"
}
For Mojo's mojo-profile.json --
{
"_Key": "mojo",
"email"<EMAIL_ADDRESS>"name": "Mojo Sam, the Yudoo Man",
"catch_phrase": "Feet Don't Fail Me Now!"
}
An Jack's jack-profile.json --
{
"_Key": "jack",
"email"<EMAIL_ADDRESS>"name": "Jack Flanders",
"catch_phrase": "What is coming at you is coming from you"
}
On the command line we can read in the updated JSON objects and save the results in the collection with the update verb. Like with init and create the update verb will return an “OK” or error message. Let's update each of our JSON objects.
dataset update friends.ds freida frieda-profile.json
dataset update friends.ds mojo mojo-profile.json
dataset update friends.ds jack jack-profile.json
TIP: By providing a filename ending in “.json” the dataset command knows to read the JSON object from disc. If the object had stated with a "{" and ended with a "}" it would assume you were using an explicit JSON expression.
In Go we can work with each of the record as
map[string]interface{}
variables. We save from our previous
Read example. We add our “catch_phrase” attribute then
Update each record.
c, err := dataset.Open("friends.ds")
if err != nil {
// ... handle errors
}
defer c.Close()
// Read our three profiles
friedaProfile := map[string]interface{}{}
if err := c.Read("frieda", fredaProfile); err != nil {
// ... handle error
}
mojoProfile := map[string]interface{}{}
if err := c.Read("mojo", mojoProfile); err != nil {
// ... handle error
}
jackProfile := map[string]interface{}{}
if err := c.Read("jack", jackProfile); err != nil {
// ... handle error
}
// Add our catch phrases
friedaProfile["catch_phrase"] = "Wowee Zowee"
mojoProfile["catch_phrase"] = "Feet Don't Fail Me Now!"
jackProfile["catch_phrase"] = "What is coming at you is coming from you"
// Update our records
if err := c.Update("frieda", friedaProfile); err != "" {
// ... handle error
}
if err := c.Update("mojo", mojoProfile); err != "" {
// ... handle error
}
if err := c.Update("jack", jackProfile); err != nil {
// ... handle error
}
A better approach where we would be to use a Go struct to hold the profile records. This would ensure that they mapping of attribute names are consistently handled.
import (
"github.com/caltechlibrary/dataset"
)
type Profile struct {
Name string `json:"name"`
EMail string `json:"email,omitempty"`
CatchPhrase string `json:"catech_phrase,omitempty"`
}
func main() {
// Load our minimal records, i.e. name and email
records := map[string]*Profile{}{
"frieda": &Profile{
Key: "frieda",
EMail<EMAIL_ADDRESS>Name: "Little Frieda",
},
"mojo": &Profile{
Key: "mojo",
EMail<EMAIL_ADDRESS>Name: "Mojo Sam, the Yudoo Man",
},
"jack": &Profile{
Key: "jack",
EMail<EMAIL_ADDRESS>Name: "Jack Flanders",
},
}
// Create the collection and add our records
c, err := dataset.Init("friends.ds", "")
if err != nil {
// ... handle errror
}
for key, record := range records {
if err := c.CreateObject(key, recorrd); err != nil {
// ... handle error
}
}
// Add our catch phrases
records["frieda"].CatchPhrase = "Wowee Zowee"
records["mojo"].CatchPhrase = "Feet Don't Fail Me Now!"
records["jack"].CatchPhrase =
"What is coming at you is coming from you"
// Update our records
for key, record := range records {
if err := c.UpdateObject(key, record); err != "" {
// ... handle error
}
}
}
Eventually you might want to remove a JSON object from the collection. Let's remove Jack Flander's record for now.
command line --
dataset delete friends.ds jack
Notice the “OK” in this case it means we've successfully delete the JSON object from the collection.
An perhaps as you've already guessed working in Go looks like --
c, err := dataset.Open("friends.ds")
if err != nil {
// ... handle error
}
defer c.Close()
if err := c.Delete("jack"); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
fmt.Println("OK")
os.Exit(0)
Eventually you have lots of objects in your collection. You are not going to be able to remember all the keys. dataset provides a keys function for getting a list of keys as well as a count to give you a total number of keys.
Now that we've deleted a few things let's see how many keys are in friends.ds. We can do that with the count verb.
Command line --
dataset count friends.ds
In Go --
c, err := dataset.Open("friends.ds")
if err != nil {
// ... handle error
}
defer c.Close()
cnt = c.Length() // NOTE: this is an int64 value
fmt.Printf("Total Records Now: %d\n", cnt)
Likewise we can get a list of the keys with the keys verb.
dataset keys friends.ds
If you are following along in Go then you can just save the keys to a variable called keys.
c, err := dataset.Open("friends.ds")
if err != nil {
// ... handle error
}
defer c.Close()
keys, err = c.Keys()
if err != nil {
// ... handle error
}
fmt.Printf("%s\n", strings.Join(keys, "\n"))
JSON objects are tree like. This structure can be inconvenient for some types of analysis like tabulation, comparing values or generating summarizing reports. Many languages support a concept of "data frame". Meaning a list of objects, possibly with associated metadata about how the list was created. This becomes a convenient way to process data. Frames can easily be transformed.
dataset also comes with a frame verb. A frame is an order list of objects based on a set of keys and metadata about how the values for the objects we mapped from the collection’s JSON documents. It is similar to the "data frames" concepts in languages like Julia, Matlab, Octave, Python and R.
To define a frame we only need two pieces of information, a list of keys in the collection to be framed and a list of dot notated paths to map into a set of labels for the object in the frame.
dataset frame-create -i=friends.keys friends.ds \
"name-and-email" \
\
.name=name .email=email .catch_phrase=catch_phrase
In Go it would look like
= dataset.Open("friends.ds")
c, err :// ... handle error
defer c.Close()
= true
verbose := c.Keys()
keys = []string{ ".name", ".email", ".catch_phrase" }
dotPaths := []string{ "name", "email", "catch_phrase" }
labels :if err := c.FrameCreate("friends.ds", "name-and-email",
; err != nil {
keys, dotPaths, labels, verbose)// ... handle error
}
In Go it'd look like
c, err := dataset.Open("friends.ds")
// ... handle error
defer c.Close()
frm, err := c.FrameRead("name-and-email")
// ... handle error
src, err := json.MarshalIndent(frm, "", " ")
// ... handle error
fmt.Printf("%s\n", src)
Looking at the resulting JSON object you see other attributes beyond the object list of the frame. These are created to simplify some of dataset more complex interactions.
Most of the time you don't want the metadata, so you we have a way of just retrieving the object list.
dataset frame-objects friends.ds "name-and-email"
Or in Go --
c, err := dataset.Open("friends.ds")
// ... handle error
defer c.Close()
objects, err := c.FrameObjects("name-and-email")
// ... handle error
src, err := json.MarshalIndent(objects, "", " ")
// ... handle error
fmt.Printf("%s\n", src)
Let's add back the Jack record we deleted a few sections ago and “reframe” our “name-and-email” frame.
# Adding back Jack
dataset create -i jack-profile.json friends.ds jack
# Save all the keys in the collection
dataset keys friends.ds >friends.keys
# Now reframe "name-and-email" with the updated friends.keys
dataset reframe -i=friends.keys friends.ds "name-and-email"
# Now let's take a look at the frame's objects
dataset frame-objects friends.ds "name-and-email"
Let's try the same thing in Go --
c, err := dataset.Open("friends.ds")
// ... handle error
defer c.Close()
if err := c.CreateObject("jack", jackProfile); err != nil {
// ... handle error
}
keys, err := c.Keys()
if err != nil {
// ... handle error
}
if err := c.Reframe("name-and-email", keys); err != nil {
// ... handle error
}
objects, err := c.FrameObjects("name-and-email")
// ... handle error
src, err := json.MarshalIndent(objects, "", " ")
// ... handle error
fmt.Printf("%s\n", src)
We can list the frames in the collection using the frames verb.
dataset frames friends.ds
In Go --
c, err := dataset.Open("friends.ds")
// ... handle error
defer c.Close()
frameNames := c.Frames()
fmt.Printf("%s\n", string.Join(frame_names, "\n"))
In our frame we have previously defined three columns, looking at the JSON representation of the frame we also see a "labels" attribute. Labels are used when exporting and synchronizing content between a CSV file, Google Sheet and a collection (labels become column names).
Labels are the target attribute name. They are set at the time of
frame definition and persist as long as the frame exists. The order of
the columns reflects the order of the pairs defining the dot paths and
labels. In our previous examples we provided the order of the columns
for the frame "name-and-email" as .name
,
.email
, .catch_phrase
dot paths. If we want to
have the labels "ID", "Display Name", "EMail", and "Catch Phrase" we
need to define our frame that way.
dataset frame-keys friends.ds >keys.json
dataset frame-delete friends.ds "name-and-email"
dataset frame -i keys.json friends.ds "name-and-email" \
"._Key=ID" ".name=Display Name" \
".email=EMail" ".catch_phrase=Catch Phrase"
In Go it might look like
c, err := dataset.Open("friends.ds")
// ... handle error
defer c.Close()
verbose := true
keys, err := c.FrameKeys("name-and-email")
// ... handle error
frm, err := c.FrameRead("name-and-email")
// ... handle error
// Retrieve our dot paths and labels then append
// the additional path and label
dotPaths := frm.DotPaths
dotPaths = append(dotPaths, ".catch_phrase")
labels := frm.Labels
labels = append(labels, "catch_phrase")
err := c.FrameDelete("name-and-email")
// ... handle error
err := c.Frame("name-and-email", keys, dotPath, labels, verbose)
if err != nil {
// ... handle error
}
Finally the last thing we need to be able to do is delete a frame. Delete frames work very similar to deleting a JSON record.
dataset frame-delete friends.ds "name-and-email"
Or in Go --
c, err := dataset.Open("friends.ds")
// ... handle
defer c.Close()
err := c.FrameDelete("name-and-email")
// ... handle error
TIP: Frames like collections have a number of operations. Here's the list
frame will let you define a frame
frame-def will let you read back a frame’s definition
frame-objects return the frame's object list
frame-keys return the frame's key list
frames will list the frames defined in the collection columns in a frame, it will cause the frame to regenerate its object list
delete-frame will remove the frame from the collection
refresh will let you refresh the objects in a frame from the current state of the collection, it’ll prune any existing objects in the frame is they no longer exist.
reframe will take a new list of keys from the colletion recreating ( (replacing) the objects in the data frame based on the new list of keys


Select a state to show licensure information
Scroll to zoom • Click and drag to pan
Pinch to zoom • Tap and drag to pan


ERIN BROCKOVICH (2000) / ** 1/2
Directed by Steven Soderbergh. Screenplay by Susannah Grant and Richard Lagravenese. Starring Julia Roberts, Albert Finney, Aaron Eckhart. Running time: 129 minutes. Rated AA for offensive language. Reviewed on March 29th, 2000.
By SHANNON PATRICK SULLIVAN
It's said that everyone loves an underdog. In that case, the box office success of new Julia Roberts vehicle "Erin Brockovich" is all but assured, for here is a movie all about celebrating the underdog. Not only is its heroine essentially an everywoman with the same problems and worries that confront the rest of us, but the villain of the piece is big business, a favorite target of the common man. The fact that the movie is based on real life events is merely the icing on the proverbial cake.
The story begins around 1992, when Erin Brockovich (Roberts), a twice-divorced mother of three, manages to gain employment at a legal firm run by Ed Masry (Albert Finney).  Setting to work as a legal secretary, Brockovich comes across some real estate files which, to her consternation, include medical records. Gaining no insight from her reluctant coworkers as to why this might be the case, Brockovich visits the home of Donna Jensen (Marg Helgenberger) to learn more.
The Jensens live in Hinkley, a small California town built around a refinery run by Pacific Gas and Electric (PG&E). The family has been plagued by medical problems, and Brockovich soon discovers that the cause may be hexavalent chromium, a pollutant which has leaked from the PG&E plant into the groundwater and has been contaminating the community for the past thirty years. Soon it becomes clear that the health of not just the Jensens, but indeed most of Hinkley's current and past residents, has been damaged by PG&E's neglect and outright lies (the company actually claimed at one point that the chromium in the environment was a type beneficial to humans). Brockovich manages to convince Masry to take on the Hinkley case, but must overcome people's perceptions of her own shortcomings as the lawsuit proceeds forward.
As the title implies, this is a movie not so much about the legal battle against PG&E as it is about Erin Brockovich herself. As such, it lives and dies on the performance of Julia Roberts. Fortunately Roberts is up to the challenge, demonstrating a facility for both the dramatic and comedic elements of the role. This is not the sort of character one would necessarily expect Roberts to take on, but it is not hard to see its appeal. Brockovich is tenacious, brassy and self-confident, an extrovert willing to speak her mind almost to the point of recklessness. Her life has not been an easy one -- "I got pregnant too young" she admits at one point, although there is no question that the overriding passion of her life is her children -- but she is doing the best she can.
No doubt the aspect of the character which has received the most attention has been Brockovich's provocative style of dress, but Roberts manages to pull it off. Rather than making her looking slutty, the clothes help to accentuate the idea that this is a woman who has her own way of getting things done, who refuses to be cowed by the expectations of others.
But "Erin Brockovich" is so focussed on the title character that the rest of the cast largely goes by the wayside. Finney does a respectable job as Ed Masry, but lives out the movie in Roberts' orbit. Masry's entire personality seems to be defined in terms of how he reacts to Brockovich, and consequently he has no capacity to develop on his own. The other major supporting actor is Aaron Eckhart, playing Brockovich's Harley-loving next-door neighbor and romantic interest, George. It is here that the film is at its weakest: their relationship is unconvincing from start to finish, and the flimsy George is never given much characterization. He seems to exist purely to either facilitate or complicate Brockovich's life, and his disappearance from much of the last third of the movie is all too easily overlooked.
"Erin Brockovich" does a decent job of portraying the real-life legal struggles against PG&E. It is smart enough to balance the courtroom dramatics with the more human elements of the case, such as the impact of the medical problems on the Hinkley families, and the way Brockovich's involvement affects her relationship with her children. It is peppered with laughs, but avoids going over the edge into parody. However, the film struggles to generate any real sense of incident. The lawyers representing PG&E all come across as hamfisted and ineffectual, and there is never much of a feeling of risk that things might not work out. Scenes such as one where Masry discusses the possible bankruptcy of the law firm, and a court proceeding where a judge could have dismissed the entire suit, are quickly defused and feel tokenistic.
The movie is also plagued by moments of bizarre characterization. Much is made, for example, of Brockovich's love for her kids. And yet, when she receives an anonymous phone call warning her to stop digging into the problems at Hinkley, almost nothing is made of it. This is not to say that her decision to proceed with the investigation indicates she doesn't care about her children; on the contrary, it demonstrates how passionate Brockovich is about both. But it seems inconceivable to me that she should treat the incident so offhandedly, dismiss it so easily. This is only exacerbated by the fact that the threat is never referred to again. What, then, was the point?
"Erin Brockovich" is a good movie and a good vehicle for Julia Roberts. But it sets the bar too low, settling for being just another popcorn movie instead of striving for deeper characterization or a more compelling screenplay. For a movie about a woman possessed of such determination and conviction, it is unfortunate that "Erin Brockovich" does not possess quite the same qualities.
Copyright © 2000 Shannon Patrick Sullivan. Archived at http://www.physics.mun.ca/~sps/movies/ErinBrockovich.html
-- _______________________________________________________________________ / Shannon Patrick Sullivan | "We are all in the gutter, but some of us \ | | are looking at the stars." | \<EMAIL_ADDRESS>| -- Oscar Wilde /
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


My design process
This is called the double diamond approach. It splits the design process into four phases: discover, define, develop, deliver. After the fourth phase the final deliverables should be handed over to the development team to implement the product. This is the design approach I follow but it is only the start.
As a UX designer I consider it my responsibility to go the extra mile and support implementation and test the final product once live. From my experience I know that unforeseen circumstances or technical obstacles will rise during implementation and UX relevant decisions need to be taken. Once the product is live it should be mandatory to test and validate the final outcome again.
When the product is good to go it is time to think about ways and channels to constantly get qualitative feedback from users and augment the quantitative data that is collected automatically. In case something went wrong and the product can’t be released as is, I support product managers with issue prioritisation, sprint planning and design testing. Together with the team I develop a pragmatic strategy to balance product fixing and time to go live.
Discover
The first phase is about researching user and business needs. Data is key: quantitative data shows what is happening and qualitative data reveals why it is happening. By analysing quantitative data, interviewing and observing users (and internal stakeholders), creating personas, mapping processes and experiences I help to make sure the team fully understands the problem before it starts to think about solutions.
Define
Next comes problem framing. The team needs to be clear on which exact issues and opportunities it wants to tackle. The Personas, experience maps I created and the user's jobs, pains, gains I discovered will enable the team to prioritise and define product opportunities it sees. The outcome is a set of hypotheses about how we might create a valuable and impactful experience for our users.
Develop
During this phase—my favourite by the way—I facilitate collaborative design workshops with stakeholders and/or users. Making use of everyone's creativity results in better concepts and it fosters an inclusive team setup where everyone can participate and contribute. With everyone's input gathered I begin to sketch, wireframe, prototype and test refined concepts of the product. This is a very iterative process and prototypes I build range from paper to actual code (HTML/CSS/JS).
To do this as lean as possible, I work closely with the developers to immediately get feedback regarding the feasibility of concepts and together with the product manager I conduct prototype tests with actual users to ensure value and usability. Through this process we validate the hypotheses defined in the previous phase.
Deliver
When the team knows what it should build, I develop the product's personality by setting the tone of voice, handpicking beautiful typefaces and crafting a matching color palette. I refine animation of UI elements and deliver high-end mockups. If needed I can design and implement a whole pattern library that developers can use to build the final product. To fine tune the very details of interactions and the user interface, I often sit down with developers and support them to get it right.
Verify
Delivering the product is not enough. When others consider their work done, I go the extra mile and validate the live application with actual users to make sure the team actually meets the goals it has set. Evaluating quantitative and qualitative data together with the product manager after launch will help us further improve the product and bring it to the next level.


Adrian Galera
Senior software developer, Ocado technology
<EMAIL_ADDRESS>(+34) 667093100
Currently
Working as a Senior software developer in Ocado Technology, Communication Systems team located in Barcelona.
Specialized in
Software development, Java, Python, TDD, BDD, IoT, AWS, Docker, CI/CD
Experience
2019 - Now
Senior Software Engineer, Ocado technology, Communcation Systems, Barcelona
- Refactor of receipts templating engine to allow retailers configure their templates.
- Allow push notifications communication channel.
- Introduce the usage of localstack in the company: contribution to internal open source framework to support the usage of localstack by any team.
- Job swap during one week in Wroclaw, Poland.
2017 - 2019
Senior Software Engineer, Sensefields, Barcelona
- Redesign and implementation of the Traffic Analytics Platform: build a massively scalable IoT Python serverless solution deployed on AWS.
- Develop an IoT platform to let our customers implement a vehicle sharing service.
- Implementation of a high performance messaging middleware: its performance is based on a Akka cluster and the usage of the Actor model.
2013 - 2017
Java Developer, NicePeopleAtWork, Barcelona
- Led the plugin development team.
- Multi-model ETL Process: MySQL, Apache Kafka, Druid and custom based solutions.
- Design and implement a custom data warehouse service to develop Business Inteligence algorithms on top.
- Migrate the previous architecture to a micro services based solution.
- Performed customer in-house integrations in New York, Santa Clara, San Francisco, London and Paris.
2012-2013
Research developer, Universitat Politècnica de Catalunya, Castelldefels
- Collaborated to develop an IoT backend designed to receive events from multiple devices.
- Built several mobile applications (Android, PhoneGap) in order to populate the platform with e-health information, such as medication timings.
- Gathered information from a connected gymnasium through RFID devices and Bluetooth interfaces deployed on a Raspberry Pi.
- Built a cross platform streaming service using WebRTC and MotionJPEG compression technique.
2008 - 2011
Internship and multimedia developer, UPC-Fundació i2cat, Castelldefels
- Development of online transcoding system, high performance streaming and image processing.
- Evaluation of a telepresence system based on Set-Top-Boxes for medical environment.
Personal projects
Dogfeeder
- IoT application written in Python and React running on a Raspberry Pi to feed my dog.
- The Pi has a camera, a servomotor and one speaker: I can call my dog and give treats with the servo.
- Running on Tailscale VPN.
- Learn Python testing and mocking.
- Gitlab.com CI/CD pipeline to generate the executable file for Raspberry Pi.
- Web application to keep track of all mountains I've climbed: it's some sort of record book for mountaneering
- The user can create maps and markers
- Golang and AWS Serverless: Lambda, DynamoDB, S3. Maintenance cost is zero
- BDD both on frontend and backend: godog and cypress
Smart water
- Arduino based project.
- humidity sensor buried in the soil of my graden connected to an Arduino board.
- When the humidity reaches some threshold, the Arduino board open up a water pump that waters my garden.
Education
Formal
2009 - 2011
Master of Science in Telecommunications Engineering and Management, Universitat Politècnica de Catalunya (UPC), Castelldefels
Master Thesis: Benefits of batch provisioning in a PCE-based grid service interconnection network, Kungliga Tekniska Högskolan (KTH), Stockholm. With honors
2009 - 2011
Telecommunication engineering, Universitat Politècnica de Catalunya (UPC), Castelldefels
2005 - 2009
Telecommunication technical engineering, specialized in Telematics, Universitat Politècnica de Catalunya (UPC), Castelldefels
Informal
2019
Discrete Optimization, Coursera
2015
Audio Signal Processing for Music Applications, Coursera
2014
Machine learning, Coursera
2013
Functional programming principles in Scala, Coursera
2012
Artificial intelligence for Robotics, Udacity
2012
Circuits and electronics, MITx
Languages
English, Intermediate, Cambrige FCE
Spanish, Native
Catalan, Native